c# - For vs. Linq - 性能 vs. 未来

Question

非常简短的问题。我有一个随机排序的大字符串数组（100K+ 条目），我想在其中找到所需字符串的第一次出现。我有两个解决方案。

通过阅读我的猜测是，“for 循环”目前会提供更好的性能（但这个边距总是会改变），但我也发现 linq 版本更具可读性。总的来说，哪种方法通常被认为是当前的最佳编码实践，为什么？

string matchString = "dsf897sdf78";
int matchIndex = -1;
for(int i=0; i<array.length; i++)
{
    if(array[i]==matchString)
    {
        matchIndex = i;
        break;
    }
}

或者

int matchIndex = array.Select((r, i) => new { value = r, index = i })
                         .Where(t => t.value == matchString)
                         .Select(s => s.index).First();

score 59 · Accepted Answer

最佳实践取决于您的需要：

开发速度和可维护性：LINQ
性能（根据分析工具）：手动代码

LINQ 确实通过所有间接方式减慢了速度。不用担心，因为 99% 的代码不会影响最终用户的性能。

我从 C++ 开始，真正学会了如何优化一段代码。LINQ 不适合充分利用 CPU。因此，如果您将 LINQ 查询衡量为一个问题，那就放弃它。但也只有那时。

对于您的代码示例，我估计会减速 3 倍。通过 lambdas 进行的分配（以及随后的 GC！）和间接访问真的很痛苦。

score 34 · Accepted Answer

性能稍微好一点？循环将显着提高性能！

考虑下面的代码。在我的发布（非调试）构建系统上，它给出：

Found via loop at index 999999 in 00:00:00.2782047
Found via linq at index 999999 in 00:00:02.5864703
Loop was 9.29700432810805 times faster than linq.

特意设置了代码，以便要找到的项目就在最后。如果一开始是对的，事情就会完全不同。

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace Demo
{
    public static class Program
    {
        private static void Main(string[] args)
        {
            string[] a = new string[1000000];

            for (int i = 0; i < a.Length; ++i)
            {
                a[i] = "Won't be found";
            }

            string matchString = "Will be found";

            a[a.Length - 1] = "Will be found";

            const int COUNT = 100;

            var sw = Stopwatch.StartNew();
            int matchIndex = -1;

            for (int outer = 0; outer < COUNT; ++outer)
            {
                for (int i = 0; i < a.Length; i++)
                {
                    if (a[i] == matchString)
                    {
                        matchIndex = i;
                        break;
                    }
                }
            }

            sw.Stop();
            Console.WriteLine("Found via loop at index " + matchIndex + " in " + sw.Elapsed);
            double loopTime = sw.Elapsed.TotalSeconds;

            sw.Restart();

            for (int outer = 0; outer < COUNT; ++outer)
            {
                matchIndex = a.Select((r, i) => new { value = r, index = i })
                             .Where(t => t.value == matchString)
                             .Select(s => s.index).First();
            }

            sw.Stop();
            Console.WriteLine("Found via linq at index " + matchIndex + " in " + sw.Elapsed);
            double linqTime = sw.Elapsed.TotalSeconds;

            Console.WriteLine("Loop was {0} times faster than linq.", linqTime/loopTime);
        }
    }
}

score 6 · Accepted Answer

根据声明范式，LINQ 表达了计算的逻辑，而不描述其控制流。该查询是面向目标的、自我描述的，因此易于分析和理解。也很简洁。此外，使用 LINQ，高度依赖于数据结构的抽象。这涉及高可维护性和可重用性。

迭代方法解决了命令式范式。它提供了细粒度的控制，从而轻松获得更高的性能。代码也更易于调试。有时结构良好的迭代比查询更具可读性。

score 3 · Accepted Answer

性能和可维护性之间总是存在两难选择。通常（如果没有关于性能的特定要求）可维护性应该是赢家。只有当您遇到性能问题时，您才应该分析应用程序，找到问题根源并提高其性能（通过同时降低可维护性，是的，这就是我们生活的世界）。

关于您的样品。Linq 在这里不是很好的解决方案，因为它不会将匹配可维护性添加到您的代码中。实际上，对我来说，投影、过滤和再次投影看起来比简单的循环还要糟糕。您需要的是简单的 Array.IndexOf，它比循环更易于维护，并且具有几乎相同的性能：

Array.IndexOf(array, matchString)

score 2 · Accepted Answer

好吧，您自己给出了问题的答案。

For如果您想要最佳性能，请使用循环，或者如果Linq您想要可读性，请使用。

还可能要记住使用 Parallel.Foreach() 的可能性，这将受益于内联 lambda 表达式（因此，更接近 Linq），并且这比“手动”进行并行化更具可读性。

score 1 · Accepted Answer

我不认为这两者都被认为是最佳实践，有些人更喜欢看 LINQ，而有些人则不喜欢。

如果性能是一个问题，我会为您的场景分析这两种代码，如果差异可以忽略不计，那么选择您觉得更符合的那个，毕竟很可能是您维护代码。

您是否还考虑过使用 PLINQ 或使循环并行运行？

score 1 · Accepted Answer

只是一个有趣的观察。LINQ Lambda 查询肯定会增加 LINQ Where 查询或 For 循环的惩罚。在下面的代码中，它用 1000001 个多参数对象填充一个列表，然后使用 LINQ Lamba、LINQ Where 查询和 For 循环搜索在此测试中始终是最后一个的特定项目。每个测试迭代 100 次，然后平均时间以获得结果。

LINQ Lambda 查询平均时间：0.3382 秒

LINQ Where 查询平均时间：0.238 秒

For循环平均时间：0.2266秒

我一遍又一遍地运行这个测试，甚至增加了迭代，从统计学上讲，分布几乎相同。当然，我们所说的基本上是一百万个项目搜索的 1/10 秒。所以在现实世界中，除非有那么密集的事情，否则你不确定你是否会注意到。但是，如果您执行 LINQ Lambda 与 LINQ Where 查询确实会在性能上有所不同。LINQ Where 与 For 循环几乎相同。

private void RunTest()
{
    try
    {
        List<TestObject> mylist = new List<TestObject>();

        for (int i = 0; i <= 1000000; i++)
        {
            TestObject testO = new TestObject(string.Format("Item{0}", i), 1, Guid.NewGuid().ToString());
            mylist.Add(testO);
        }


        mylist.Add(new TestObject("test", "29863", Guid.NewGuid().ToString()));

        string searchtext = "test";

        int iterations = 100;

        // Linq Lambda Test
        List<int> list1 = new List<int>();
        for (int i = 1; i <= iterations; i++)
        {
            DateTime starttime = DateTime.Now;
            TestObject t = mylist.FirstOrDefault(q => q.Name == searchtext);
            int diff = (DateTime.Now - starttime).Milliseconds;
            list1.Add(diff);
        }

        // Linq Where Test
        List<int> list2 = new List<int>();
        for (int i = 1; i <= iterations; i++)
        {
            DateTime starttime = DateTime.Now;
            TestObject t = (from testO in mylist
                            where testO.Name == searchtext
                            select testO).FirstOrDefault();
            int diff = (DateTime.Now - starttime).Milliseconds;
            list2.Add(diff);
        }

        // For Loop Test
        List<int> list3 = new List<int>();
        for (int i = 1; i <= iterations; i++)
        {
            DateTime starttime = DateTime.Now;
            foreach (TestObject testO in mylist)
            {
                if (testO.Name == searchtext)
                {
                    TestObject t = testO;
                    break;
                }
            }
            int diff = (DateTime.Now - starttime).Milliseconds;
            list3.Add(diff);
        }

        float diff1 = list1.Average();
        Debug.WriteLine(string.Format("LINQ Lambda Query Average Time: {0} seconds", diff1 / (double)100));

        float diff2 = list2.Average();
        Debug.WriteLine(string.Format("LINQ Where Query Average Time: {0} seconds", diff2 / (double)100));

        float diff3 = list3.Average();
        Debug.WriteLine(string.Format("For Loop Average Time: {0} seconds", diff3 / (double)100));
    }
    catch (Exception ex)
    {
        Debug.WriteLine(ex.ToString());
    }
}

private class TestObject
{
    public TestObject(string _name, string _value, string _guid)
    {
        Name = _name;
        Value = _value;
        GUID = _guid;
    }
    public string Name;
    public string Value;
    public string GUID;
}

score 0 · Accepted Answer

最好的选择是使用 Array 类的 IndexOf 方法。由于它专门用于数组，因此它将比 Linq 和 For Loop 快得多。改进马特沃森的答案。

using System;
using System.Diagnostics;
using System.Linq;


namespace PerformanceConsoleApp
{
    public class LinqVsFor
    {

        private static void Main(string[] args)
        {
            string[] a = new string[1000000];

            for (int i = 0; i < a.Length; ++i)
            {
                a[i] = "Won't be found";
            }

            string matchString = "Will be found";

            a[a.Length - 1] = "Will be found";

            const int COUNT = 100;

            var sw = Stopwatch.StartNew();

            Loop(a, matchString, COUNT, sw);

            First(a, matchString, COUNT, sw);


            Where(a, matchString, COUNT, sw);

            IndexOf(a, sw, matchString, COUNT);

            Console.ReadLine();
        }

        private static void Loop(string[] a, string matchString, int COUNT, Stopwatch sw)
        {
            int matchIndex = -1;
            for (int outer = 0; outer < COUNT; ++outer)
            {
                for (int i = 0; i < a.Length; i++)
                {
                    if (a[i] == matchString)
                    {
                        matchIndex = i;
                        break;
                    }
                }
            }

            sw.Stop();
            Console.WriteLine("Found via loop at index " + matchIndex + " in " + sw.Elapsed);

        }

        private static void IndexOf(string[] a, Stopwatch sw, string matchString, int COUNT)
        {
            int matchIndex = -1;
            sw.Restart();
            for (int outer = 0; outer < COUNT; ++outer)
            {
                matchIndex = Array.IndexOf(a, matchString);
            }
            sw.Stop();
            Console.WriteLine("Found via IndexOf at index " + matchIndex + " in " + sw.Elapsed);

        }

        private static void First(string[] a, string matchString, int COUNT, Stopwatch sw)
        {
            sw.Restart();
            string str = "";
            for (int outer = 0; outer < COUNT; ++outer)
            {
                str = a.First(t => t == matchString);

            }
            sw.Stop();
            Console.WriteLine("Found via linq First at index " + Array.IndexOf(a, str) + " in " + sw.Elapsed);

        }

        private static void Where(string[] a, string matchString, int COUNT, Stopwatch sw)
        {
            sw.Restart();
            string str = "";
            for (int outer = 0; outer < COUNT; ++outer)
            {
                str = a.Where(t => t == matchString).First();

            }
            sw.Stop();
            Console.WriteLine("Found via linq Where at index " + Array.IndexOf(a, str) + " in " + sw.Elapsed);

        }

    }

}

输出：

Found via loop at index 999999 in 00:00:01.1528531
Found via linq First at index 999999 in 00:00:02.0876573
Found via linq Where at index 999999 in 00:00:01.3313111
Found via IndexOf at index 999999 in 00:00:00.7244812

score 0 · Accepted Answer

有点没有答案，实际上只是对https://stackoverflow.com/a/14894589的扩展，但我一直在致力于为 Linq-to-Objects 提供与 API 兼容的替代品而现在。它仍然不提供手动编码循环的性能，但对于许多（大多数？）linq 场景来说它更快。它确实会产生更多的垃圾，并且前期成本会稍高一些。

代码可用https://github.com/manofstick/Cistern.Linq

一个 nuget 包可用https://www.nuget.org/packages/Cistern.Linq/（我不能声称这是经过战斗强化的，使用风险自负）

从 Matthew Watson 的答案 ( https://stackoverflow.com/a/14894589 ) 中获取代码并进行两次微调，我们将时间缩短到“仅”比手动编码循环差 3.5 倍。在我的机器上大约需要原始 System.Linq 版本的 1/3 时间。

要替换的两个更改：

using System.Linq;

...

matchIndex = a.Select((r, i) => new { value = r, index = i })
             .Where(t => t.value == matchString)
             .Select(s => s.index).First();

具有以下内容：

// a complete replacement for System.Linq
using Cistern.Linq;

...

// use a value tuple rather than anonymous type
matchIndex = a.Select((r, i) => (value: r, index: i))
             .Where(t => t.value == matchString)
             .Select(s => s.index).First();

所以图书馆本身是一项正在进行的工作。它未能通过 corefx 的 System.Linq 测试套件中的几个边缘案例。它还需要转换一些函数（它们目前具有 corefx System.Linq 实现，从 API 角度来看，如果不是从性能角度来看，它是兼容的）。但是，如果有人愿意提供帮助、评论等，我们将不胜感激......

c# - For vs. Linq - 性能 vs. 未来

9 回答 9

Related

Reference