LINQ 语句是否比 \'foreach\' 循环更快？

Question

我正在编写一个网格渲染管理器，我认为将所有使用相同着色器的网格分组，然后在我处于该着色器通道中时渲染它们是个好主意。

我目前正在使用 foreach 循环，但想知道使用 LINQ 是否可以提高性能？

Answer 1

为什么 LINQ 应该更快？它还在内部使用循环。

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

Answer 2

LINQ 到对象一般来说将增加一些边际开销（多个迭代器等）。它仍然必须做循环，和有委托调用，和通常必须做一些额外的取消引用才能获取捕获的变量等。在大多数代码中，这实际上是检测不到的，并且多于由更易于理解的代码提供。

对于其他 LINQ 提供程序，如 LINQ-to-SQL，那么由于查询可以在服务器上进行过滤，因此应该很多更好的比公寓foreach，但很可能你不会做毯子"select * from foo"反正，所以这不是一定一个公平的比较。

重新 PLINQ；并行性可以减少过去时间，但由于线程管理等开销，总 CPU 时间通常会增加一点。

Answer 3

LINQ 现在变慢了，但在某些时候它可能会变快。 LINQ 的好处是您不必关心它是如何工作的。如果想出一种速度非常快的新方法，Microsoft 的人员甚至可以在不告诉您的情况下实施它，并且您的代码会快得多。

但更重要的是，LINQ 更易于阅读。这应该是足够的理由。

Answer 4

可能应该注意到for循环比foreach更快。因此对于原始帖子，如果您担心渲染器等关键组件的性能，请使用 for 循环。

参考：In .NET, which loop runs faster, 'for' or 'foreach'?

Answer 5

如果您对多核使用并行 LINQ，您可能会获得性能提升。看Parallel LINQ (PLINQ)（MSDN）。

Answer 6

我对这个问题很感兴趣，所以我刚才做了一个测试。在运行 Microsoft Windows 7 Ultimate 的 Intel(R) Core(TM) i3-2328M CPU @ 2.20GHz、2200 Mhz、2 核和 8GB 内存上使用 .NET Framework 4.5.2。

看起来 LINQ 可能比每个循环都快。这是我得到的结果：

Exists = True
Time   = 174
Exists = True
Time   = 149

如果你们中的一些人可以将此代码复制并粘贴到控制台应用程序中并进行测试，那将会很有趣。 在使用对象（员工）进行测试之前，我尝试使用整数进行相同的测试。 LINQ 在那里也更快。

public class Program
{
    public class Employee
    {
        public int id;
        public string name;
        public string lastname;
        public DateTime dateOfBirth;

        public Employee(int id,string name,string lastname,DateTime dateOfBirth)
        {
            this.id = id;
            this.name = name;
            this.lastname = lastname;
            this.dateOfBirth = dateOfBirth;

        }
    }

    public static void Main() => StartObjTest();

    #region object test

    public static void StartObjTest()
    {
        List<Employee> items = new List<Employee>();

        for (int i = 0; i < 10000000; i++)
        {
            items.Add(new Employee(i,"name" + i,"lastname" + i,DateTime.Today));
        }

        Test3(items, items.Count-100);
        Test4(items, items.Count - 100);

        Console.Read();
    }


    public static void Test3(List<Employee> items, int idToCheck)
    {

        Stopwatch s = new Stopwatch();
        s.Start();

        bool exists = false;
        foreach (var item in items)
        {
            if (item.id == idToCheck)
            {
                exists = true;
                break;
            }
        }

        Console.WriteLine("Exists=" + exists);
        Console.WriteLine("Time=" + s.ElapsedMilliseconds);

    }

    public static void Test4(List<Employee> items, int idToCheck)
    {

        Stopwatch s = new Stopwatch();
        s.Start();

        bool exists = items.Exists(e => e.id == idToCheck);

        Console.WriteLine("Exists=" + exists);
        Console.WriteLine("Time=" + s.ElapsedMilliseconds);

    }

    #endregion


    #region int test
    public static void StartIntTest()
    {
        List<int> items = new List<int>();

        for (int i = 0; i < 10000000; i++)
        {
            items.Add(i);
        }

        Test1(items, -100);
        Test2(items, -100);

        Console.Read();
    }

    public static void Test1(List<int> items,int itemToCheck)
    {

        Stopwatch s = new Stopwatch();
        s.Start();

        bool exists = false;
        foreach (var item in items)
        {
            if (item == itemToCheck)
            {
                exists = true;
                break;
            }
        }

        Console.WriteLine("Exists=" + exists);
        Console.WriteLine("Time=" + s.ElapsedMilliseconds);

    }

    public static void Test2(List<int> items, int itemToCheck)
    {

        Stopwatch s = new Stopwatch();
        s.Start();

        bool exists = items.Contains(itemToCheck);

        Console.WriteLine("Exists=" + exists);
        Console.WriteLine("Time=" + s.ElapsedMilliseconds);

    }

    #endregion

}

Answer 7

这实际上是一个相当复杂的问题。 Linq 使某些事情变得非常容易，如果你自己实现它们，你可能会绊倒（例如 linq .Except()）。这尤其适用于 PLinq，尤其适用于由 PLinq 实现的并行聚合。

通常，对于相同的代码，由于委托调用的开销，linq 会更慢。

但是，如果您正在处理大量数据，并对元素应用相对简单的计算，则在以下情况下您将获得巨大的性能提升：

1. 您使用数组来存储数据。

2. 您使用 for 循环访问每个元素（而不是 foreach 或 linq）。

   • 注意：进行基准测试时，请大家记住 - 如果连续两次测试使用相同的数组/列表，CPU 缓存会使第二个更快。 *

Answer 8

.NET Core 7 中对 .Min .Max、.Average 和 .Sum 的 LINQ 性能进行了一些重大更新 参考：https://devblogs.microsoft.com/dotnet/performance_improvements_in_net_7/#linq

这是帖子中的基准。

如果将 ForEach 循环与 ForEach 循环进行比较，那么很明显，在 .NET 6 中，ForEach 循环更快，而在 .NET 7 中，LINQ 方法：

这是使用 BenchmarkDotNet 的基准代码

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Jobs;
using BenchmarkDotNet.Running;

public class Program
{
    public static void Main()
    {
        BenchmarkRunner.Run<ForEachVsLinq>();
    }
}

[SimpleJob(RuntimeMoniker.Net60)]
[SimpleJob(RuntimeMoniker.Net70)]
[MemoryDiagnoser(false)]
public class ForEachVsLinq
{
    private int[] _intArray;

    [GlobalSetup]
    public void Setup()
    {
        var random = new Random();
        var randomItems = Enumerable.Range(0, 500).Select(_ => random.Next(999));
        this._intArray = randomItems.ToArray();
    }

    [Benchmark]
    public void ForEachMin()
    {
        var min = int.MaxValue;
        foreach (var i in this._intArray)
        {
            if ( i < min)
                min = i;
        }
        Console.WriteLine(min);
    }

    [Benchmark]
    public void Min()
    {
        var min = this._intArray.Min();
        Console.WriteLine(min);
    }

    [Benchmark]
    public void ForEachMax()
    {
        var max = 0;
        foreach (var i in this._intArray)
        {
            if (i > max)
                max = i;
        }
        Console.WriteLine(max);
    }

    [Benchmark]
    public void Max()
    {
        var max = this._intArray.Max();
        Console.WriteLine(max);
    }


    [Benchmark]
    public void ForEachSum()
    {
        var sum = 0;
        foreach (var i in this._intArray)
        {
            sum += i;
        }
        Console.WriteLine(sum);
    }

    [Benchmark]
    public void Sum()
    {
        var sum = this._intArray.Sum();
        Console.WriteLine(sum);
    }
}

在 .NET Core 6 和更早版本中，上述方法比执行您自己的 foreach 循环并查找最小值、最大值、平均值或汇总数组中的对象要慢。

但在 .NET Core 7 中，性能的提升实际上让这些内置的 LINQ 方法快了很多。 Nick Chapsas 在a benchmark video on YouTupe 中展示了这一点

所以如果你想计算总和、最小值、最大值或平均值，你应该使用 LINQ 方法而不是从 .NET Core 7 开始的 foreach 循环（至少，从性能的角度来看）