一直对LINQ简洁高效的语法青睐有加，对于经常和资料库，SQL语法打交道的C#开发者来说，LINQ无疑是一个非常不错的选择，当要在List<T>（T为一个普通对象）集合中查找满足某些条件的某个对象时，写成 form t in T where t. Property1 == "A" && t. Property2== "B" …select t或者写成T.Where(t=>t. . Property1 == "A" && t. Property2== "B" …)，是再自然不过的了。乍看之下，反正List<T>已被存在记忆体，无需顾忌反复查询所产生的连续成本，而且where条件也十分通俗易懂。但是当你需要频繁检索某个集合中的满足某些条件的对象时，比如需要求两个集合中的差集时，你有没有考虑过性能问题呢？最近的项目遇到频繁检索资料库，对比查询的多个对象的性能瓶颈问题，于是做了下面这个测试，下面我们来看一个对比测试：
1 public static class LinqOrDictioanry
2 {
3 public static string GetLinqSingle(List<Model> model, string id, string sbName)
4 {
5 return model.Single(o => o.Id == id && o.SbName == sbName).JuName;
6 }
7 public static string GetDictionaryValue(Dictionary<string, Model> dictionaryModel, string id, string sbName)
8 {
9 return dictionaryModel[string.Format("{0}\t{1}", id, sbName)].JuName;
10 }
11 }
1 [TestMethod]
2 public void TestMethod1()
3 {
4 var model = new List<Model>();
5 const int count = 100000;
6 var time = 3;
7 var random = new Random(count);
8 for (var i = 0; i < count; i++)
9 {
10 model.Add(new Model()
11 {
12 Id = Guid.NewGuid().ToString(),
13 JuName = "JuName" + random.Next(0, 10000),
14 SbName = "SbName" + random.Next(0, 10000),
15 Dydj = "Dydj" + random.Next(0, 10000),
16 ZhangChang = "ZhangChang" + random.Next(0, 10000),
17 YcHang = "YcHang" + random.Next(0, 10000),
18 Time = DateTime.Now,
19 Total = random.Next(0, 10000)
20 });
21 }
22 var dictionary = model.ToDictionary(d => string.Format("{0}\t{1}", d.Id, d.SbName), d => d);
23
24 var toModel = new List<Model>();
25 var tempCount = random.Next(500, 10000);
26 for (var i = 0; i < tempCount; i++)
27 {
28 var sample = model[random.Next(model.Count)];
29 toModel.Add(new Model()
30 {
31 Id = sample.Id,
32 SbName = sample.SbName
33 });
34 }
35 Console.WriteLine("Count={0}>{1}", model.Count, tempCount);
36 for (var i = 0; i < time; i++)
37 {
38 Console.WriteLine("第 {0}次检索{1} 个对象", i, tempCount);
39 var sw = new Stopwatch();
40 sw.Start();
41 for (var j = 0; j < tempCount; j++)
42 {
43 var model1 = toModel[j];
44 model1.JuName = LinqOrDictioanry.GetLinqSingle(model, model1.Id, model1.SbName);
45 }
46 sw.Stop();
47 Console.WriteLine("耗时 {0}ms", sw.ElapsedMilliseconds);
48 Console.WriteLine("查看目标集合中最前面的数据，中间一点的数据，和最后一个数据看是否成功把数据检索出来？{0}， {1}， {2}", toModel[1].JuName, toModel[tempCount / 2].JuName, toModel[tempCount - 1].JuName);
49 }
50 Console.WriteLine("");
51 for (var i = 0; i < time; i++)
52 {
53 Console.WriteLine("第 {0}次检索{1}个对象", i, tempCount);
54 var sw = new Stopwatch();
55 sw.Start();
56 for (var j = 0; j < tempCount; j++)
57 {
58 var model1 = toModel[j];
59 model1.JuName = LinqOrDictioanry.GetDictionaryValue(dictionary, model1.Id, model1.SbName);
60 }
61 sw.Stop();
62 Console.WriteLine("耗时 {0}ms", sw.ElapsedMilliseconds);
63 Console.WriteLine("查看目标集合中最前面的数据，中间一点的数据，和最后一个数据看是否成功把数据检索出来？{0} ，{1} ，{2}", toModel[1].JuName, toModel[tempCount / 2].JuName, toModel[tempCount - 1].JuName);
64 }
65 }
随机构造一个容量为10万的List<T>集合和Dictionary<string,T>集合，产生一个随机数作为检索的“频率”，也就是在这10万个对象中要检索的次数（这里产生了1639个检索对象），执行结果让人大吃一惊，耗时相差尽然如此之大。
从测试结果来看，两者的效率天壤之别，而且随着检索集合的容量大小和检索频率成”正比”趋势: 使用LINQ Where检索，执行三次平均检索1600多次13秒左右；而Dictionary执行三次检索1600多次也不超过10ms! LINQ to Object的Where的查询不像数据库可以靠索引加速检索，当查询元素的对象很多，并且查询检索非常频繁时，可以考虑使用Dictionary<string, T>等做法取代Where条件检索，避免不必要的性能损失。
结论:依赖LINQ的Where查询在大量资料库中频繁检索数据是，很容易形成效率瓶颈。遇到这样的需求，可通过ToDictionary()简单转换成Dictionary，可以获得大幅度的性能提升。
鄙人能力有限，以上测试纯属个人知识点查缺补漏应用，不敢强加应用场景，以免误人子弟，若有不妥或者错误的地方，还望各位大神斧正。