linq的性能差异c#foreach[关闭]

Question

我想知道这两者的区别：

为：

string[] arrayOld = new string(){"This", "other", "aaa", ...};
string[] arrayNew = new string[arrayOld.lenght];

for(int i = i < arrayOld.lenght; i++){
   arrayNew[i] = arrayOld[i];
}

FOREACH：

string[] arrayOld = new string(){"This", "other", "aaa", ...};
List<string> listNew = new List<string>();

foreach(string val in arrayOld){
   listNew.add(val);
}
string[] arrayNew = listNew.toArray();

LINQ：

string[] arrayOld = new string(){"This", "other", "aaa", ...};
string[] arrayNew = (from val in arrayOld select val).toArray();

我不想复制数组...

想法是从arrayOld中的对象构造新对象（可以不同于字符串，可以包含其他属性...）

我需要表现，所以...

¿什么是最好的选择，为什么？

Answer 1

粗略的结果最能说明问题：

class Program
{
    static void Main()
    {
        // Warm-up
        Method1();
        Method2();
        Method3();

        const int Count = 1000000;

        var watch = Stopwatch.StartNew();
        for (int i = 0; i < Count; i++)
        {
            Method1();
        }
        watch.Stop();
        Console.WriteLine("Method1: {0} ms", watch.ElapsedMilliseconds);

        watch = Stopwatch.StartNew();
        for (int i = 0; i < Count; i++)
        {
            Method2();
        }
        watch.Stop();
        Console.WriteLine("Method2: {0} ms", watch.ElapsedMilliseconds);

        watch = Stopwatch.StartNew();
        for (int i = 0; i < Count; i++)
        {
            Method3();
        }
        watch.Stop();
        Console.WriteLine("Method3: {0} ms", watch.ElapsedMilliseconds);

    }

    static void Method1()
    {
        string[] arrayOld = new[] { "This", "other", "aaa" };
        string[] arrayNew = new string[arrayOld.Length];

        for (var i = 0; i < arrayOld.Length; i++)
        {
            arrayNew[i] = arrayOld[i];
        }
    }

    static void Method2()
    {
        string[] arrayOld = new[] { "This", "other", "aaa" }; 
        var listNew = new List<string>(arrayOld.Length);

        foreach(var val in arrayOld)
        { 
            listNew.Add(val); 
        } 
        string[] arrayNew = listNew.ToArray();    
    }

    static void Method3()
    {
        string[] arrayOld = new[] { "This", "other", "aaa" }; 
        string[] arrayNew = (from val in arrayOld select val).ToArray();    
    }
}

在我的机器上打印：

Method1: 72 ms
Method2: 187 ms
Method3: 377 ms

Answer 2

以上都不是。

如果你想复制一个数组，我会尝试：

string[] arrayOld = new { "This", "other", "aaa" };
string[] arrayNew = new string[arrayOld.Length];

arrayOld.CopyTo(arrayNew, 0);

Answer 3

在大多数情况下，您应该为您正在编写的特定代码选择最清楚地表达意图的任何内容。但是，如果它是一个非常深的内部循环，并且您需要每隔最后一纳秒发出一声尖叫，我的经验是（使用 Release 构建代码）对数组进行索引的 for 循环比 foreach 循环快得多，而且稍微小一点使用带有 LINQ 的委托与带有循环内部逻辑的简单 foreach 的性能损失。

这些观察结果基于人工智能中使用的分数计算算法的微优化工作，其中分数函数被多次评估。具体的瓶颈和改进程度是使用分析工具确定的，如果您处于这种情况，我强烈建议您这样做。瓶颈很少出现在您认为的位置。

Answer 4

至于性能for 可能会超过其他性能，因为您直接使用索引器，而在foreach 中您使用的是Enumerator，因此您有更多行要执行（GetEnumerator、MoveNext、Current 等） .. 但区别是非常微妙，并为代码的可读性和可维护性付出了代价。

至于 LINQ 的工作量更大。但是想想为什么 LINQ 应该更快？它还在内部使用循环。

大多数时候，LINQ 会有点慢，因为它会引入开销。如果您非常关心性能，请不要使用 LINQ。使用 LINQ 是因为您想要更短、更易读、更易于维护的代码。

---

也就是说，如果您对性能过于敏感，并且希望在最后一个时钟周期中输出，那么您可能希望在 unsafe 上下文中使用 C 风格的 pointers fixed变量

Answer 5

最快的方法是Array.Copy。

string[] arrayOld = new string[] { "This", "other", "aaa" };
string[] arrayNew = new string[arrayOld.Length];

Array.Copy(arrayOld, arrayNew, arrayOld.Length);

Answer 6

Daniel A. White 的评论，不确定是否严重，但他是对的。您听说过 StopWatch 类吗？

我认为现在是您花点时间学习如何为自己判断表现的时候了。如果我们中的一个人真的想正确回答您的问题，我们将不得不编写性能检查代码，这就是为什么您的问题可能会收到如此多的反对票。因为你应该这样做。但我们会帮助你:)

您可以使用 StopWatch 类以及许多其他技术（计数时钟周期/迭代）以确定哪种方法具有最佳性能。

http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.aspx

using System;
using System.Diagnostics;
using System.Threading;
class Program
{
    static void Main(string[] args)
    {
        Stopwatch stopWatch = new Stopwatch();
        stopWatch.Start();
        Thread.Sleep(10000); // put one of your three scenarios here
        stopWatch.Stop();
        // Get the elapsed time as a TimeSpan value.
        TimeSpan ts = stopWatch.Elapsed;

        // Format and display the TimeSpan value.
        string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
            ts.Hours, ts.Minutes, ts.Seconds,
            ts.Milliseconds / 10);
        Console.WriteLine("RunTime " + elapsedTime);
    }
}

（来自 msdn 的代码 sn-p）