标签：
有两个简单好用的LINQ扩展方法 ToDictionary() 和ToList(),你可能知道或不知道,但是它的的确确可以简化查询转化为集合的任务:
据你所认识的LINQ,你可能会不知道这些查询表达式在幕后做了些什么。 让我们说说今天我们示例的目的,我们有一些POCO类(POCO代表传统CLR对象,指的是一个类,它只有非常少的功能,这一概念源自Java POJO)。
1 // just a simple product POCO class.
2 public class Product
3 {
4 public string Name { get; set; }
5 public int Id { get; set; }
6 public string Category { get; set; }
7 }
非常简单的类,对吗? 我不是说程序需要如此简单,只是专注于LINQ本身,而且我们不一定要真正查询。 所以,在我们的程序中我们可以构建一个简单的例子,这些对象的集合的示例如下:
1 var products = new List<Product>
2 {
3 new Product { Name = "CD Player", Id = 1, Category = "Electronics" },
4 new Product { Name = "DVD Player", Id = 2, Category = "Electronics" },
5 new Product { Name = "Blu-Ray Player", Id = 3, Category = "Electronics" },
6 new Product { Name = "LCD TV", Id = 4, Category = "Electronics" },
7 new Product { Name = "Wiper Fluid", Id = 5, Category = "Automotive" },
8 new Product { Name = "LED TV", Id = 6, Category = "Electronics" },
9 new Product { Name = "VHS Player", Id = 7, Category = "Electronics" },
10 new Product { Name = "Mud Flaps", Id = 8, Category = "Automotive" },
11 new Product { Name = "Plasma TV", Id = 9, Category = "Electronics" },
12 new Product { Name = "Washer", Id = 10, Category = "Appliances" },
13 new Product { Name = "Stove", Id = 11, Category = "Electronics" },
14 new Product { Name = "Dryer", Id = 12, Category = "Electronics" },
15 new Product { Name = "Cup Holder", Id = 13, Category = "Automotive" },
16 };
就是说,有这些产品的对象集合,你需要查询它们。 例如,我们可以这样得到一个所有产品实例的类别为“Electronics”的集合:
1 var electronicProducts = products.Where(p => p.Category == "Electronics");
许多扩展方法(包括Where() )的查询结果是创建一个迭代器通过移动列表来执行查询。 因此,此时的electronicProducts不是List<Product>,只是IEnumerable<Product>,它会在您使用这个列表时动态求值. 这就是LINQ中强大的延迟执行,在你需要结果前,都不会对表达式求值。 此时我们可以去查询electronicProducts,这样我们就可以得到结果列表!
让我看一下下面的结果是什么:
1 // select all electronics, there are 7 of them 2 IEnumerable<Product> electronicProducts = products.Where(p => p.Category == "Electronics"); 3 4 // now clear the original list we queried 5 products.Clear(); 6 7 // now iterate over those electronics we selected first 8 Console.WriteLine(electronicProducts.Count());
你认为结果是7还是0? 答案是0,因为即使我们第2行上设置一个查询所有电子产品,但是我们在第5行清除列表。 因此,当我们在第8行实际处理查询列表(执行Count())是空的,没有找到结果。
如果你感到困惑,认为它是这样的: 创建一个使用LINQ查询扩展方法(和LINQ表达式语法)很像定义一个存储过程, 在你调用它之前都没有“运行”。 我知道这不是100%准确的比喻,但是希望你要知道LINQ表达式在语句2是没有执行的,我们处理了IEnumerable才执行。
如果你想立即得到(存储)LINQ表达式的结果,你应该把它到导入到另一个集合,这样就可以修改。 当然,你可以手动建立一个列表,然后以各种方式填充。
1 IEnumerable<Product> electronicProducts = products.Where(p => p.Category == "Electronics");
2
3 // You could create a list and then hand-iterate - BULKY!
4 var results = new List<Product>();
5
6 foreach (var product in electronicProducts)
7 {
8 results.Add(product);
9 }
10
11 // OR, you could take advantage of AddRange() - GOOD!
12 var results2 = new List<Product>();
13 results2.AddRange(electronicProducts);
14
15 // OR, you could take advantage of List‘s constructor that takes an IEnumerable<T> - BETTER!
16 var results3 = new List<Product>(electronicProducts);
实际上,使用一个循环,通常是非常冗长的,或者你可能利用AddRange()或List<T>函数构造 IEnumerable<T>列表。
但是你可以用另一种方式,。 LINQ扩展方法之上包含了ToList(),你可以将任何IEnumerable<T>来填充一个 List<T>。如果你想用一步执行查询和填充,这很方便:
var electronicProducts = products.Where(p => p.Category == "Electronics").ToList();
现在, List<T>代替 electronicProducts 作为IEnumerable<T> 动态执行的原始集合,这将是另一个新的集合,修改不会影响原来的集合。
当然,这有优点也有缺点。 通常,如果你只是要遍历的结果和过程,你不需要(也不想)将它存储在一个单独的列表,这只会浪费内存,后来还需要垃圾收集。 然而,如果你想保存子集,并将它分配给另一个类,ToList()是非常方便的,你不需要担心改变原来的集合。
ToList() 使用IEnumerable<T>并将其转换为 List<T>,那么 ToDictionary()也是类似的。大多数情况ToDictionary()是一个非常方便的方法,将查询的结果(或任何 IEnumerable<T>)转换成一个Dictionary<TKey,TValue>。 关键是您需要定义T如何分别转换TKey和TValue。
如果说我们有超级大的产品列表,希望把它放在一个Dictionary<int, product>,这样我们可以根据ID得到最快的查找时间。 你可能会这样做:
1 var results = new Dictionary<int, Product>();
2 foreach (var product in products)
3 {
4 results.Add(product.Id, product);
5 }
和它看起来像一个很好的代码,但是我们可以轻松地使用LINQ而无需手写一大堆逻辑:
1 var results = products.ToDictionary(product => product.Id);
它构造一个Dictionary<int, Product> ,Key是产品的Id属性,Value是产品本身。 这是最简单的形式ToDictionary(),你只需要指定一个key选择器。 如果你想要不同的东西作为你的value? 例如如果你不在乎整个Product,,你只是希望能够转换ID到Name? 我们可以这样做:
1 var results = products.ToDictionary(product => product.Id, product => product.Name);
这将创建一个 Key为Id,Value为Name 的Dictionary<int, string>,。由此来看这个扩展方法有很多的方式来处理IEnumerable<T> 集合或查询结果来生成一个dictionary。
注:还有一个Lookup<TKey, TValue>类和ToLookup()扩展方法,可以以类似的方式做到这一点。 他们不是完全相同的解决方案(Dictionary和Lookup接口不同,他们的没有找到索引时行为也是不同的)。
因此,在我们的Product 示例中,假设我们想创建一个Dictionary<string, List<Product>> ,Key是分类,Value是所有产品的列表。 在以前你可能自实现自己的循环:
1 // create your dictionary to hold results
2 var results = new Dictionary<string, List<Product>>();
3
4 // iterate through products
5 foreach (var product in products)
6 {
7 List<Product> subList;
8
9 // if the category is not in there, create new list and add to dictionary
10 if (!results.TryGetValue(product.Category, out subList))
11 {
12 subList = new List<Product>();
13 results.Add(product.Category, subList);
14 }
15
16 // add the product to the new (or existing) sub-list
17 subList.Add(product);
18 }
但代码应该更简单! 任何新人看着这段代码可能需要去详细分析才能完全理解它,这给维护带来了困难
幸运的是,对我们来说,我们可以利用LINQ扩展方法GroupBy()提前助力ToDictionary()和ToList():
// one line of code! var results = products.GroupBy(product => product.Category) .ToDictionary(group => group.Key, group => group.ToList());
GroupBy()是用Key和IEnumerable创建一个IGrouping的LINQ表达式查询语句。 所以一旦我们使用GroupBy() ,所有我们要做的就是把这些groups转换成dictionary,所以我们的key选择器 (group => group.Key) 分组字段(Category),使它的成为dictionary的key和Value择器((group => group.ToList()) 项目,并将它转换成一个List<Product>作为我们dictionary的Value!
这样更容易读和写,单元测试的代码也更少了! 我知道很多人会说lamda表达式更难以阅读,但他们是c#语言的一部分,高级开发人员也必须理解。我认为你会发现当你越来越多的使用他们后,代码能被更好的理解和比以前更具可读性。
译者按：我用Transmate翻译的同时，也尽量保留原文的描述，避免信息的丢失,如果这篇文章对你有一点儿用,请不要吝啬点推荐,让更多人看到,谢谢!
标签：
原文地址：http://www.cnblogs.com/Leo_wl/p/4518742.html
