简单测试lambda和linq查找的性能

在List泛型中查找一个值（唯一），究竟用哪种方法快点呢。for循环、foreach迭代器、Lambda表达式、Linq语句。

简单的写了一个程序测试一下。思路：构造一个有26843545个int元素List泛型（从小到大）。然后复制四份，准备用于查找。随机生成一个查找内容，用Stopwatch来检查运行时间。

代码如下：

static void Main(string[] args)
        {
            Stopwatch sw = new Stopwatch();
            Random rand=new Random();
            string output = "{0}运行使用了{1}毫秒";

            List<int> intlist = new List<int>();
            const int length = 26843545;
            int temp;

            for (int i = 0; i < length; i++)
            {
                intlist.Add(i);
            }

            int target = rand.Next(length);

            Console.WriteLine("总长度{0}，查找对象{1}", length, target);

            List<int> forlist = new List<int>(); ;
            forlist.Clear();
            forlist.AddRange(intlist);

            List<int> lambdalist = new List<int>();
            lambdalist.Clear();
            lambdalist.AddRange(intlist);

            List<int> foreachlist = new List<int>();
            foreachlist.Clear();
            foreachlist.AddRange(intlist);

            List<int> linqlist = new List<int>();
            linqlist.Clear();
            linqlist.AddRange(intlist);
            //------------------------------------
            // for
            sw.Reset();
            sw.Start();
            for (int i = 0; i < length; i++)
            {
                if (forlist[i]==target)
                {
                    temp = forlist[i];
                    sw.Stop();
                    Console.WriteLine(output, "for循环",sw.ElapsedMilliseconds);
                }
            }
            //----------------------------------------------------------
            //foreach
            sw.Reset();
            sw.Start();
            foreach (int item in foreachlist)
            {
                if (item == target)
                {
                    temp = item;
                    sw.Stop();
                    Console.WriteLine(output, "foreach循环", sw.ElapsedMilliseconds);
                }
            }
            //------------------------------------------------
            //lambda
            sw.Reset();
            sw.Start();
           temp= lambdalist.Where(x => x == target).First();
            sw.Stop();
            Console.WriteLine(output, "Lambda表达式", sw.ElapsedMilliseconds);
            //----------------------------------------------------
            //Linq
            sw.Reset();
            sw.Start();
            temp = (from y in linqlist
                    where y == target
                    select y).First();  
            sw.Stop();
            Console.WriteLine(output, "Linq查询", sw.ElapsedMilliseconds);
            //-----------------------------------------------------------
            Console.Read();
        }

测试环境，core 2 duo P9400 2.4G双核，8G内存，win7 x64旗舰版。测试的结果，单位毫秒

查找对象	for	foreach	Lambda	Linq
25069205	242	286	296	294
5377884	52	62	70	63
11283402	110	129	140	134
5164132	52	59	66	59
23708079	239	274	518	514
26363083	271	308	576	568
1538372	15	17	23	18
7191108	70	84	91	85
3376391	33	39	46	39
9636456	91	171	119	113
23588001	233	276	385	289

简单的看出在百万个元素左右，差异并不十分大。总体性能for是最快，Lambda最低，但是Lambda和Linq基本差不多，性能比直接循环和迭代慢多了。

原因大致看了一下。在调用Where这个方法的时候，其实是用了很多层委托去调用，一直到调用Enumerable.CombinePredicates方法。

这个方法的实现代码

private static Func<TSource, bool> CombinePredicates<TSource>(Func<TSource, bool> predicate1, Func<TSource, bool> predicate2)
{
    return delegate (TSource x) {
        if (predicate1(x))
        {
            return predicate2(x);
        }
        return false;
    };
}

 

 

 

可见，Linq的写法是提高程序员的编程效率，而执行效率是会降低的。但是在现在的硬件环境下，一般的数据容量这些降低可以忽略。但是如果你的数据量有1亿，就另当别论。不过，就我的这个程序，消耗内存也挺大的，一个控制台程序都要600多M内存（一共有5个千万单元的list喔^_^）。