LINQ之延迟执行标准查询操作符(下)

操作符：Join

描述：基于匹配键对2个序列的元素进行关联，Join保留了TOuter中元素的顺序，并对于这些元素中的每一个元素，保留TInner中匹配元素的顺序.(来自msdn)

原型：2种

 

原型一：

 

public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(
	this IEnumerable<TOuter> outer,
	IEnumerable<TInner> inner,
	Func<TOuter, TKey> outerKeySelector,
	Func<TInner, TKey> innerKeySelector,
	Func<TOuter, TInner, TResult> resultSelector
)

 

Join的参数比较多，需要特别注意。举个例子：

 

            List<Category> categories = new List<Category>
                                            {
                                                new Category{Id = 1,Name = "Food"},
                                                new Category{Id = 2,Name = "Toys"},
                                                new Category{Id = 3,Name = "Fruit"}
                                            };
            List<Product> products = new List<Product>
                                         {
                                             new Product{ProductId = 201,ProductName = "Chuckit",CategoryId = 2},
                                             new Product{ProductId = 202,ProductName = "SafeMade",CategoryId = 2},
                                             new Product{ProductId = 101,ProductName = "Taste",CategoryId = 1},
                                             new Product{ProductId = 102,ProductName = "Canidae",CategoryId = 1},
                                             new Product{ProductId = 103,ProductName = "Flavor",CategoryId = 1}

                                         };

            var productList = categories.Join(products, c => c.Id, p => p.CategoryId,
                                              (c, p) => new { c.Name, p.ProductName });

            foreach (var product in productList)
            {
                Console.WriteLine("{0}----{1}", product.Name, product.ProductName);
            }

 

在这个例子中，我们将categories和products通过categories.Id和products.CategoryId进行关联，返回一个新的对象的序列。

原型二略。

---

操作符：GroupJoin

描述：基于键相等对两个序列的元素进行关联并对结果进行分组.(来自msdn)

原型：

 

public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(
	this IEnumerable<TOuter> outer,
	IEnumerable<TInner> inner,
	Func<TOuter, TKey> outerKeySelector,
	Func<TInner, TKey> innerKeySelector,
	Func<TOuter, IEnumerable<TInner>, TResult> resultSelector
)

 

 

GroupJoin和Join很类似，GroupJoin会对返回的结果给予TOuter的Key进行分组。

对于返回的结果，TOuter中的一个元素可能对应多个TInner元素。

注意：如果TInner中没有TOuter的给定元素的关联元素，则该元素的匹配序列为空，但仍将出现在结果中.

举个例子：

 

List<Category> categories = new List<Category>
                                            {
                                                new Category{Id = 1,Name = "Food"},
                                                new Category{Id = 2,Name = "Toys"},
                                                new Category{Id = 3,Name = "Fruit"}
                                            };
            List<Product> products = new List<Product>
                                         {
                                             new Product{ProductId = 201,ProductName = "Chuckit",CategoryId = 2},
                                             new Product{ProductId = 202,ProductName = "SafeMade",CategoryId = 2},
                                             new Product{ProductId = 101,ProductName = "Taste",CategoryId = 1},
                                             new Product{ProductId = 102,ProductName = "Canidae",CategoryId = 1},
                                             new Product{ProductId = 103,ProductName = "Flavor",CategoryId = 1}

                                         };

            var productList = categories.GroupJoin(products, c => c.Id, p => p.CategoryId,
                                              (c, ps) => new { c.Name,Products= ps.Select(p=>p.ProductName) });

            foreach (var product in productList)
            {
                Console.WriteLine(product.Name+":");
                foreach (var item in product.Products)
                {
                    Console.WriteLine(item);
                }
            }

 

 

打印出来的结果是：

Food:
Taste
Canidae
Flavor
Toys:
Chuckit
SafeMade
Fruit:

我们可以发现Fruit这个category没有匹配的产品，但是也被打印出来了。

 

---

操作符：GroupBy

描述：GroupBy主要用来对输入序列进行分组，并且返回IGrouping<K, T>

原型：GroupBy提供了众多的原型，我们主要关注4个：

 

原型一：

 

public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(
	this IEnumerable<TSource> source,
	Func<TSource, TKey> keySelector
)

 

            List<Product> products = new List<Product>
                                         {
                                             new Product{ProductId = 201,ProductName = "Chuckit",CategoryId = 2},
                                             new Product{ProductId = 202,ProductName = "SafeMade",CategoryId = 2},
                                             new Product{ProductId = 101,ProductName = "Taste",CategoryId = 1},
                                             new Product{ProductId = 102,ProductName = "Canidae",CategoryId = 1},
                                             new Product{ProductId = 103,ProductName = "Flavor",CategoryId = 1}

                                         };

            var productList = products.GroupBy(p => p.CategoryId).OrderBy(item=>item.Key);

            foreach (var keyGroupProducts in productList)
            {
                Console.WriteLine(keyGroupProducts.Key + ":");
                foreach (var product in keyGroupProducts)
                {
                    Console.WriteLine(product.ProductName);
                }
            }

 

输出结果：

1:
Taste
Canidae
Flavor
2:
Chuckit
SafeMade

 

原型一比较简单，主要包含2个参数，一个输入序列，另外一个是selector。

在这个例子中，我们通过对products序列进行按categoryid进行分组，然后按照分组后的key进行排序。

 

原型二：

 

public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(
	this IEnumerable<TSource> source,
	Func<TSource, TKey> keySelector,
	IEqualityComparer<TKey> comparer
)

 

原型二为我们多提供了IEqualityComparer参数用以自定义比较方法

 

public interface IEqualityComparer<in T>

 

 

这个接口提供了2个方法bool Equals(T x, T y)和int GetHashCode(T obj)2个方法

 

注意IEqualityComparer是根据Key来比较的，例如，我们可以写个comparer比较器：

 

public class ProductEqualityComparer : IEqualityComparer<int>
    {
        public bool Equals(int x, int y)
        {
            if (x == 0) return false;
            if (y == 0) return false;
            return IsSameVendor(x) == IsSameVendor(y);
        }

        public int GetHashCode(int obj)
        {
            int start = 1;
            int end = 100;
            return IsSameVendor(obj) ? start.GetHashCode() : end.GetHashCode();
        }

        public bool IsSameVendor(int id)
        {
            return id < 100;
        }
    }

 

 

ProductEqualityComparer comparer = new ProductEqualityComparer();
            List<Product> products = new List<Product>
                                         {
                                             new Product{ProductId = 201,ProductName = "Chuckit",CategoryId = 2},
                                             new Product{ProductId = 202,ProductName = "SafeMade",CategoryId = 200},
                                             new Product{ProductId = 101,ProductName = "Taste",CategoryId = 1},
                                             new Product{ProductId = 102,ProductName = "Canidae",CategoryId = 1},
                                             new Product{ProductId = 103,ProductName = "Flavor",CategoryId = 1}

                                         };

            IEnumerable<IGrouping<int, Product>> productList = products.GroupBy(p => p.CategoryId, comparer);

            foreach (var keyGroupProducts in productList)
            {
                Console.WriteLine(keyGroupProducts.Key + ":"+(comparer.IsSameVendor(keyGroupProducts.Key)?"Same Vendor":"Diff Vendor"));
                foreach (var product in keyGroupProducts)
                {
                    Console.WriteLine(product.ProductName);
                }
            }

原型三：

public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(
	this IEnumerable<TSource> source,
	Func<TSource, TKey> keySelector,
	Func<TSource, TElement> elementSelector
)

 

与原型一不一样的是，原型一返回了与输入序列同样的类型元素，原型三可以根据自己的需求，返回所需的元素类型，我们来看个例子：

 

List<Product> products = new List<Product>
                                         {
                                             new Product{ProductId = 201,ProductName = "Chuckit",CategoryId = 2},
                                             new Product{ProductId = 202,ProductName = "SafeMade",CategoryId = 2},
                                             new Product{ProductId = 101,ProductName = "Taste",CategoryId = 1},
                                             new Product{ProductId = 102,ProductName = "Canidae",CategoryId = 1},
                                             new Product{ProductId = 103,ProductName = "Flavor",CategoryId = 1}

                                         };

            var productList = products.GroupBy(p => p.CategoryId, p=>new{p.ProductId,p.ProductName}).OrderBy(p=>p.Key);

            foreach (var keyGroupProducts in productList)
            {
                Console.WriteLine("Category: "+keyGroupProducts.Key);
                foreach (var product in keyGroupProducts)
                {
                    Console.WriteLine("{0}-{1}",product.ProductId, product.ProductName);
                }
            }

 

我们返回的不再是Product，而是我们新建的一个匿名类型，包含ProductId和ProductName

 

原型四：

 

public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(
	this IEnumerable<TSource> source,
	Func<TSource, TKey> keySelector,
	Func<TSource, TElement> elementSelector,
	IEqualityComparer<TKey> comparer
)

 

原型四实际上是原型二和原型三的结合，比较简单，就不举例子了。

 

---

操作符：Distinct

描述：Distinct操作符主要用于过滤重复的元素，2个元素相等是通过GetHashCode和Equals来判断的，原型二为我们提供了自己写对等条件的方法

原型：2种

 

原型一：

 

public static IEnumerable<TSource> Distinct<TSource>(
	this IEnumerable<TSource> source
)

 

这个原型很简单，我们借用msdn的例子来说明：

 

List<int> ages = new List<int> { 21, 46, 46, 55, 17, 21, 55, 55 };

            IEnumerable<int> distinctAges = ages.Distinct();

            Console.WriteLine("Distinct ages:");

            foreach (int age in distinctAges)
            {
                Console.WriteLine(age);
            }

 

输出结果：

 

Distinct ages:
21
46
55
17

重复的46,55被过滤掉了。

 

原型二：

 

public static IEnumerable<TSource> Distinct<TSource>(
	this IEnumerable<TSource> source,
	IEqualityComparer<TSource> comparer
)

 

我们先定义一个相等比较器：

 

public class ProductEqualityComparer : IEqualityComparer<Product>
    {
        public bool Equals(Product x, Product y)
        {
            if (x == null||y==null) return false;
            return x.ProductId == y.ProductId && x.CategoryId == y.CategoryId;
        }

        public int GetHashCode(Product obj)
        {
            int productid = obj.ProductId;
            int categoryid = obj.CategoryId;
            return productid.GetHashCode() + categoryid.GetHashCode();
        }
    }

 

然后，在查询的时候，应用这个比较器：

 

ProductEqualityComparer comparer = new ProductEqualityComparer();
            List<Product> products = new List<Product>
                                         {
                                             new Product{ProductId = 201,ProductName = "Chuckit",CategoryId = 2},
                                             new Product{ProductId = 201,ProductName = "CHUCKIT",CategoryId = 2},
                                             new Product{ProductId = 101,ProductName = "Taste",CategoryId = 1},
                                             new Product{ProductId = 102,ProductName = "Canidae",CategoryId = 1},
                                             new Product{ProductId = 103,ProductName = "Flavor",CategoryId = 1}

                                         };

            var productList = products.Distinct(comparer);

            foreach (var product in productList)
            {
                Console.WriteLine("{0}:{1}:{2}",product.CategoryId,product.ProductId,product.ProductName);
            }

 

输出结果为：

2:201:Chuckit
1:101:Taste
1:102:Canidae
1:103:Flavor

可以发现，201这个product第二个ProductName为全大写的被过滤掉了，因为根据我们的相等比较器，两个201product是一样的。

 

---

操作符：Union

描述：连接2个序列，相同的元素只会保留一个

原型：2种

 

原型一：

public static IEnumerable<TSource> Union<TSource>(
	this IEnumerable<TSource> first,
	IEnumerable<TSource> second
)

 

这也是个很简单的操作符，我们还是来看个简单的例子：

 

List<int> int1 = new List<int>{12,42,3,2};
            List<int> int2 = new List<int> {24, 3 };

            var unitInts = int1.Union(int2);
            foreach (var unitInt in unitInts)
            {
                Console.WriteLine(unitInt);
            }

 

输出结果为：

12
42
3
2
24

 

int2的3被过滤掉了，因为int1已经存在3这个元素了

 

原型二为我们提供了相等比较器：

 

public static IEnumerable<TSource> Union<TSource>(
	this IEnumerable<TSource> first,
	IEnumerable<TSource> second,
	IEqualityComparer<TSource> comparer
)

 

跟上面的Distinct的原型二类似，我们就不再举例了。

 

---

操作符：Intersect

描述：返回2个序列的交集

原型：2种

 

题外话：看到这里，其实我们就很容易猜出这2种原型是什么了，无非一种是采用默认对等比较的交集操作，另一种是可以自己提供相等比较器的方法

 

原型一：

 

public static IEnumerable<TSource> Intersect<TSource>(
	this IEnumerable<TSource> first,
	IEnumerable<TSource> second
)

 

原型二：

 

public static IEnumerable<TSource> Intersect<TSource>(
	this IEnumerable<TSource> first,
	IEnumerable<TSource> second,
	IEqualityComparer<TSource> comparer
)

 

我们举个原型一的例子吧：

 

List<int> int1 = new List<int> { 12, 42, 3, 2 };
            List<int> int2 = new List<int> { 24, 3 };

            var unitInts = int1.Intersect(int2);
            foreach (var unitInt in unitInts)
            {
                Console.WriteLine(unitInt);
            }

 

结果集只会返回3。

 

---

操作符：Except

描述：该操作符返回存在于序列1但是不存在序列2的所有元素

原型：2种

 

原型一：

 

public static IEnumerable<TSource> Except<TSource>(
	this IEnumerable<TSource> first,
	IEnumerable<TSource> second
)

 

原型二：

 

public static IEnumerable<TSource> Except<TSource>(
	this IEnumerable<TSource> first,
	IEnumerable<TSource> second,
	IEqualityComparer<TSource> comparer
)

 

我们举个原型一的例子：

 

            List<int> int1 = new List<int> { 12, 42, 3, 2};
            List<int> int2 = new List<int> { 24, 3 };

            var unitInts = int1.Except(int2);
            foreach (var unitInt in unitInts)
            {
                Console.WriteLine(unitInt);
            }

 

返回的结果集为：

12
42
2

元素3在int2中，所以被过滤掉了，int2中的元素24，不在int1中，所以不会被返回回来。

 

---

操作符：Cast

描述：将非泛型的结果皆转成泛型结果集，以支持大部分的标准查询操作符。

如果我们有一个序列是在.net 2.0框架上做的，但是，我们又希望用LINQ来操作，此时，我们就可以先将该序列Cast操作后转成IEnumerable<T>.

原型：

 

public static IEnumerable<TResult> Cast<TResult>(
	this IEnumerable source
)

 

借用msdn的例子来说明：

 

System.Collections.ArrayList fruits = new System.Collections.ArrayList();
            fruits.Add("apple");
            fruits.Add("mango");

            IEnumerable<string> query =
                fruits.Cast<string>().Select(fruit => fruit);

            foreach (string fruit in query)
            {
                Console.WriteLine(fruit);
            }

 

---

操作符：OfType

描述：将可以转成某种类型的元素作为结果集输出来，跟Cast一样，OfType的输入序列也是非泛型的IEnumerable

原型：

 

public static IEnumerable<TResult> OfType<TResult>(
	this IEnumerable source
)

 

还是借用msdn的例子：

 

System.Collections.ArrayList fruits = new System.Collections.ArrayList(4);
            fruits.Add("Mango");
            fruits.Add("Orange");
            fruits.Add("Apple");
            fruits.Add(3.0);
            fruits.Add("Banana");

            // Apply OfType() to the ArrayList.
            IEnumerable<string> query1 = fruits.OfType<string>();

            Console.WriteLine("Elements of type 'string' are:");
            foreach (string fruit in query1)
            {
                Console.WriteLine(fruit);
            }

 

ArrayList的签名为：

 

public class ArrayList : IList, ICollection, 
	IEnumerable, ICloneable

 

它是没有实现IEnumerable<T>，经过OfType后，返回的结果集就支持IEnumerable了。

 

---

操作符：AsEnumerable

描述：输入一个IEnumerable<T>序列，返回一个IEnumerable<T>序列。

看到这个描述也许你会觉得很好玩：这不是多此一举吗，没有任何操作，只是为了返回跟输入序列一样的序列。

在稍后的LINQ TO SQL我们再来详细讨论这个问题。

原型：

 

public static IEnumerable<TSource> AsEnumerable<TSource>(
	this IEnumerable<TSource> source
)

 

---

操作符：DefaultIfEmpty

原型一：

 

public static IEnumerable<TSource> DefaultIfEmpty<TSource>(
	this IEnumerable<TSource> source
)

 

原型二：

 

public static IEnumerable<TSource> DefaultIfEmpty<TSource>(
	this IEnumerable<TSource> source,
	TSource defaultValue
)

 

描述：该操作符主要用来描述，如果序列中的元素为空，该返回什么样的元素。原型一采用默认的对象的构造函数来创建一个空的对象，原型二允许我们定义一个默认的元素。

 

借用msdn的例子来说明原型二：

 

    class Pet
            {
                public string Name { get; set; }
                public int Age { get; set; }
            }

            public static void DefaultIfEmptyEx2()
            {
                Pet defaultPet = new Pet { Name = "Default Pet", Age = 0 };

                List<Pet> pets1 =
                    new List<Pet>{ new Pet { Name="Barley", Age=8 },
                                   new Pet { Name="Boots", Age=4 },
                                   new Pet { Name="Whiskers", Age=1 } };

                foreach (Pet pet in pets1.DefaultIfEmpty(defaultPet))
                {
                    Console.WriteLine("Name: {0}", pet.Name);
                }

                List<Pet> pets2 = new List<Pet>();

                foreach (Pet pet in pets2.DefaultIfEmpty(defaultPet))
                {
                    Console.WriteLine("\nName: {0}", pet.Name);
                }
            }

 

输出结果为:

Name: Barley
Name: Boots
Name: Whiskers

Name: Default Pet

第二个序列为空,因此输出了我们事先定义的默认的对象.

---

操作符:Range

原型:

 

public static IEnumerable<int> Range(
	int start,
	int count
)

 

该操作符返回输入序列的一部分元素

 

---

操作符:Repeat

原型:

 

public static IEnumerable<TResult> Repeat<TResult>(
	TResult element,
	int count
)

 

对元素element循环count次数

 

---

操作符:Empty

原型：

 

public static IEnumerable<TResult> Empty<TResult>()

 

描述：这是一个静态方法，但不是一个扩展方法。

 

IEnumerable<string> strings = Enumerable.Empty<string>();
foreach(string s in strings)
Console.WriteLine(s);
Console.WriteLine(strings.Count());

 

输出结果为：

0