ToLookUp linq使用

转：http://www.dotblogs.com.tw/dyco/archive/2010/08/25/17401.aspx

 

public class Data

{

    public decimal id { get; set; }

    public string name { get; set; }

    public string message { get; set; }

}

/// <summary>

      /// 使用ToLookUp

      /// </summary>

      private static void Method1()

      {

          string temp = "";

          List<Data> data = GenData();

          Dictionary<string, string> d = new Dictionary<string, string>();



          //使用ToLookUp

          var c = (from i in data

                   select new { i.id, i.name, i.message }).ToLookup(x => x.name);



          //置入字典檔

          foreach (var group in c)

          {

              temp = "";

              foreach (var item in group)

                  temp += item.message + ",";

              d.Add(group.Key, temp);

          }

          //顯示結果

          foreach (KeyValuePair<string, string> item in d)

          {

              Console.WriteLine(string.Format("姓名:{0}  訊息:{1}", item.Key, item.Value));

          }



          Console.Read();

      }

<img src='http://files.dotblogs.com.tw/dyco/1008/LinQToLookUp_CC24/2010-8-25%20%E4%B8%8B%E5%8D%88%2002-29-47_2.png'>

 转：http://www.cnblogs.com/multiplesoftware/archive/2011/03/31/2000528.html

C# 中奇妙的函数 -- 1. ToLookup

 

这个系列，我和大家一起来学学C#中一些非常有用函数，对于有些人来说可能它们不起眼，因此常常忽略它们。它们不会嚷嚷到：“使用我吧！我会让你节省很多的时间，而且让你的代码变得更加的简洁！” -- 但是，这些话会从对它们熟悉的程序员的脑海中涌现出来。

C#/.NET Little Wonders: The ToLookup() LINQ Extension Method

故事的背景

让我们先来创建一个简单的类来表示产品，产品有ID,类别，和价格，这个类没有什么特别:

     public sealed class Product

    {

        public int Id { get; set; }

        public string Category { get; set; }

        public double Value { get; set; }

        



        public override string ToString()

        {

            return string.Format("[{0}: {1} - {2}]", Id, Category, Value);

        }

    }

然后我们加入一个函数得到一个产品的列表，当然你也可以从数据库中读取出来：

        public static List<Product> GetList()

        {

            var products = new List<Product>

                               {

                                   new Product {Id = 1, Category = "Electronics", Value = 15.0},

                                   new Product {Id = 2, Category = "Groceries", Value = 40.0},

                                   new Product {Id = 3, Category = "Garden", Value = 210.3},

                                   new Product {Id = 4, Category = "Pets", Value = 2.1},

                                   new Product {Id = 5, Category = "Electronics", Value = 19.95},

                                   new Product {Id = 6, Category = "Pets", Value = 21.25},

                                   new Product {Id = 7, Category = "Pets", Value = 5.50},

                                   new Product {Id = 8, Category = "Garden", Value = 13.0},

                                   new Product {Id = 9, Category = "Automotive", Value = 10.0},

                                   new Product {Id = 10, Category = "Electronics", Value = 250.0},

                               };

            return products;

        }

我们有一个任务就是按类别列出一个物品清单，这个非常的容易，用GroupBy 就可以实现了:

             foreach (var group in products.GroupBy(p => p.Category))

            {

                Console.WriteLine(group.Key);

                foreach (var item in group)

                {

                    Console.WriteLine("\t" + item);

                }

            }

看起来一切都很好,没有什么问题.

当我们使用 GroupBy（） 扩展方法时，使用了延迟执行。 这意味着，当你遍历集合的时候,下一个要出现的项目可能会或者可能不会被加载。 这是一个很大的性能改进，但它会引起有趣的副作用。

在用 GroupBy（）时, 它实际上是在第一项被使用的时候创建分组,而不是在 GroupBy（） 第一次被调用时。

考虑一下：如果你从数据库中加载数据，然后想组合到一起，并存储快速查找。  看下面的一段代码：

             var groups = products.GroupBy(p => p.Category);

            //删除所有属于Garden的产品

            products.RemoveAll(p => p.Category == "Garden");



            foreach (var group in groups)

            {

                Console.WriteLine(group.Key);

                foreach (var item in group)

                {

                    Console.WriteLine("\t" + item);

                }

            }

执行后发现，所有的Garden产品都已经消失了，但是 groups 是在执行删除命令前就已经赋值了。

基于这种情况，我们不得不使用ToDictionary() 将GroupBy 后的结果储存起来，这样一来工作量就增加了，而且维护也不太方便 -- 请大家试试。

ToLookup登场

现在我们有请ToLookup。

该 ToLookup（） 方法创建一个类似 字典（Dictionary ） 的列表List, 但是它是一个新的 .NET Collection 叫做 lookup。 Lookup，不像Dictionary, 是不可改变的。 这意味着一旦你创建一个lookup, 你不能添加或删除元素。

             var productsByCategory = products.ToLookup(p => p.Category);

             foreach (var group in productsByCategory)

            {

                // the key of the lookup is in key property

                Console.WriteLine(group.Key);

                // the list of values is the group itself.

                foreach (var item in group)

                {

                    Console.WriteLine("\t" + item);

                }

            }

你还可以使用类似索引的功能得到某个项目，在本案例中是得到某个类别的所有产品:

         private static void PrintCategory(ILookup<string, Product> productsByCategory,string categoryName)

        {

            foreach (var item in productsByCategory[categoryName])

            {

                Console.WriteLine(item);

            }

        }

源代码下载

你从这里可以下载本案例的源码

结论

ToLookup（） 是一个奇妙的函数，用于对一个集合进行操作，创建一个1：n 的映射。 它可以方便的将数据分类成组，并生成一个字典供查询使用。

转贴请注明: