LINQ与foreach与for的性能测试结果对比

Question

有人能解释一下这些结果吗？ 我知道有重复的问题，但我还没有找到一个与我的结果得出相同结论的问题：o

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SpeedTest
{
    class Person
    {    
        public Person(string name)
        {
            this.Name = name;
        }

        public string Name { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var people = new List<Person>();
            AddTwins("FRANCISCO", people);
            var stopwatch = new Stopwatch();

            string name = "OCSICNARF";

            long linqTime = 0L;
            long foreachTime = 0L;
            long forTime = 0L;

            stopwatch.Start();
            Person person0;
            var result = from person in people
                         where person.Name == name
                         select person;
            person0 = result.First();
            linqTime = stopwatch.ElapsedMilliseconds;
            stopwatch.Restart();
            Person person1;
            foreach (Person p in people)
            {
                if (p.Name == name)
                {
                    person1 = p;
                    break;
                }
            }
            foreachTime = stopwatch.ElapsedMilliseconds;
            stopwatch.Restart();
            Person person2;
            for (int i = 0; i < people.Count; i++)
            {
                if (people[i].Name == name)
                {
                    person2 = people[i];
                    break;
                }
            }
            forTime = stopwatch.ElapsedMilliseconds;
            stopwatch.Stop();

            Console.WriteLine(string.Format("LINQ took {0}ms", linqTime));
            Console.WriteLine(string.Format("FOREACH took {0}ms", foreachTime));
            Console.WriteLine(string.Format("FOR took {0}ms", forTime));
        }

        static void AddTwins(string name, List<Person> people)
        {
            AddTwins(people, name, "");
        }

        private static void AddTwins(List<Person> people, string choices, string chosen)
        {
            if (choices.Length == 0)
            {
                people.Add(new Person(chosen));
            }
            else
            {
                for (int i = 0; i < choices.Length; i++)
                {
                    // choose
                    char c = choices[i];
                    string choose1 = choices.Substring(0, i);
                    string choose2 = choices.Substring(i + 1);
                    choices = choose1 + choose2;

                    // explore
                    AddTwins(people, choices, chosen + c);

                    // Unchoose
                    string unchoose1 = choices.Substring(0, i);
                    string unchoose2 = choices.Substring(i);
                    choices = unchoose1 + c + unchoose2;
                }
            }
        }
    }
}

- Francisco Aguilera

---

请查看http://ericlippert.com/2013/05/14/benchmarking-mistakes-part-one/。 - Brian Rasmussen

Answer 1

你从未执行LINQ查询，你只是创建了它。你应该使用ToList或ToArray方法强制迭代，尽管使用LINQ同样会使用foreach循环，并可能不会得到不同的结果。

编辑：由于你要遍历所有项，所以LINQ需要更多时间。但在你的另外两个循环中，只要找到匹配项就会退出循环。尝试使用FirstOrDefault而不是Where，你应该能够获得相同（或类似）的结果。

people.FirstOrDefault(p => p.Name == name);

- Selman Genç

---

我的错，我刚意识到了，请查看新的结果/代码。 - Francisco Aguilera

Answer 2

因为查询从未被实际评估，所以 Linq 查询不需要时间。

Linq 是一种懒加载机制，对于大多数操作，它不会实际执行任何操作，直到有人开始枚举结果。

如果您添加了

result.Count(); // add this line, query will be evaluated
linqTime = stopwatch.ElapsedMilliseconds;
stopwatch.Restart();

如果是这样，我相信您会得到一个LINQ的非零结果。

- John Gardner

---

是的，我注意到了，但你们太快了。看看新的结果。如果LINQ查询应该像foreach循环一样有一个foreach，为什么它会更慢呢？ - Francisco Aguilera

如果您查看其生成的代码，foreach 循环可能会相当“平”，其中生成的代码可能有一些额外的方法调用来进入/退出 foreach 循环，以及 yield return 等内容。 - John Gardner

Answer 3

显然，Sum必须在堆上存储列表枚举器的装箱实例，并使用该堆对象迭代列表。 内联foreach和for循环都避免了这种情况；前者是因为List的public GetEnumerator方法返回值类型。 如果您将对people的引用存储在IEnumerable<Person>变量中，则foreach循环需要更长的时间才能到达其结果。

此外，linq必须为where迭代器和传递给它的委托创建对象，并执行更多的null检查，以便如果任何参数为空，则抛出信息性异常。 这可能解释了linq代码所需的其他时间。

- phoog