ToDictionary() and ToList()

ToDictionary() and ToList()

前言:

有两个简单好用的LINQ扩展方法 ToDictionary() 和ToList(),你可能知道或不知道,但是它的的确确可以简化查询转化为集合的任务:

简介: LINQ和延迟执行

据你所认识的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才执行。

ToList() LINQ扩展方法

如果你想立即得到(存储)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()是非常方便的,你不需要担心改变原来的集合。

ToDictionary()LINQ扩展方法

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翻译的同时，也尽量保留原文的描述，避免信息的丢失,如果这篇文章对你有一点儿用,请不要吝啬点推荐,让更多人看到,谢谢!