C# Distinct方法的使用笔记

引自：http://blog.csdn.net/shaopengfei/article/details/36426763

从C# 3.0开始提供了Distinct方法，这对于集合的使用有了更为丰富的方法，经过在网上搜索相应的资源，发现有关这方面的写的好的文章还是不少的。而且为了扩展Linq的使用不方便的地方，有一些办法非常有效。由于本人工作中的需要，有一些功能暂时没有用到那么深入，现在只把最简单的一些功能分享出来，整理出来。

1. 简单一维集合的使用：

   1. List<int> ages = new List<int> { 21, 46, 46, 55, 17, 21, 55, 55 };
   2. List<string> names = new List<string> { "wang", "li", "zhang", "li", "wang", "chen", "he", "wang" };
   3. IEnumerable<int> distinctAges = ages.Distinct();
   4. Console.WriteLine("Distinct ages:");
   5. foreach (int age in distinctAges)
   6. {
   7. Console.WriteLine(age);
   8. }
   9. var distinctNames = names.Distinct();
   10. Console.WriteLine("\nDistinct names:");
   11. foreach (string name in distinctNames)
   12. {
   13. Console.WriteLine(name);
   14. }
   • 在这段代码中，是最简单的Distinct()方法的使用。使用了集合接口IEnumerable，以及隐式类型var，至于这两种用法有什么区别，没有研究出来。
   • 但是如果象下面这样的代码，是错误的！
   1. List<int> disAge = ages.Distinct();
   • 正确的方法应该是：
   1. List<int> ages = new List<int> { 21, 46, 46, 55, 17, 21, 55, 55 };
   2. List<int> disAge = ages.Distinct().ToList();
   3. foreach (int a in disAge)
   4. Console.WriteLine(a);
   • 也就是说Distinct()方法的返回集合类型是一个接口，不是具体的集合，所以需要用一个ToList()。

2. 自定义类的使用：

   • 首先我们看MSDN上给出的例子，先定义一个产品类：
   1. public class Product : IEquatable<Product>
   2. {
   3. public string Name { get; set; }
   4. public int Code { get; set; }
   5. public bool Equals(Product other)
   6. {
   7. //Check whether the compared object is null.
   8. if (Object.ReferenceEquals(other, null)) return false;
   9. //Check whether the compared object references the same data.
   10. if (Object.ReferenceEquals(this, other)) return true;
   11. //Check whether the products' properties are equal.
   12. return Code.Equals(other.Code) && Name.Equals(other.Name);
   13. }
   14. // If Equals() returns true for a pair of objects
   15. // then GetHashCode() must return the same value for these objects.
   16. public override int GetHashCode()
   17. {
   18. //Get hash code for the Name field if it is not null.
   19. int hashProductName = Name == null ? 0 : Name.GetHashCode();
   20. //Get hash code for the Code field.
   21. int hashProductCode = Code.GetHashCode();
   22. //Calculate the hash code for the product.
   23. return hashProductName ^ hashProductCode;
   24. }
   25. }
   • 在主函数里，是这样用的：
   1. static void Main(string[] args)
   2. {
   3. Product[] products =
   4. {
   5. new Product { Name = "apple", Code = 9 },
   6. new Product { Name = "orange", Code = 4 },
   7. new Product { Name = "apple", Code = 9 },
   8. new Product { Name = "lemon", Code = 12 }
   9. };
   10. //Exclude duplicates.
   11. IEnumerable<Product> noduplicates =
   12. products.Distinct();
   13. foreach (var product in noduplicates)
   14. Console.WriteLine(product.Name + " " + product.Code);
   15. }
   • 这样的输出是：
   1. /*
   2. This code produces the following output:
   3. apple 9
   4. orange 4
   5. lemon 12
   6. */
   • 但是现在的问题是，如果我们把主函数里改成这样:
   1. static void Main(string[] args)
   2. {
   3. Product[] products =
   4. {
   5. new Product { Name = "Smallapple", Code = 9 },
   6. new Product { Name = "orange", Code = 4 },
   7. new Product { Name = "Bigapple", Code = 9 },
   8. new Product { Name = "lemon", Code = 12 }
   9. };
   10. //Exclude duplicates.
   11. IEnumerable<Product> noduplicates =
   12. products.Distinct();
   13. foreach (var product in noduplicates)
   14. Console.WriteLine(product.Name + " " + product.Code);
   15. }
   • 这样的输出是：
   1. /*
   2. This code produces the following output:
   3. Smallapple 9
   4. orange 4
   5. Bigapple 9
   6. lemon 12
   7. */
   • 我们的问题是，如果想按Code来索引，想找出Code唯一的这些成员，那么这里就需要重新定义一个对Code比较的类，或者再扩展成泛型类，但是这样非常繁琐。

3. 博客鹤冲天的改进办法(以下均转自这个博客)

   • 首先，创建一个通用比较的类，实现IEqualityComparer<T>接口：
   1. public class CommonEqualityComparer<T, V> : IEqualityComparer<T>
   2. {
   3. private Func<T, V> keySelector;
   4. public CommonEqualityComparer(Func<T, V> keySelector)
   5. {
   6. this.keySelector = keySelector;
   7. }
   8. public bool Equals(T x, T y)
   9. {
   10. return EqualityComparer<V>.Default.Equals(keySelector(x), keySelector(y));
   11. }
   12. public int GetHashCode(T obj)
   13. {
   14. return EqualityComparer<V>.Default.GetHashCode(keySelector(obj));
   15. }
   16. }
   • 借助上面这个类，Distinct扩展方法就可以这样写：
   1. public static class DistinctExtensions
   2. {
   3. public static IEnumerable<T> Distinct<T, V>(this IEnumerable<T> source, Func<T, V> keySelector)
   4. {
   5. return source.Distinct(new CommonEqualityComparer<T, V>(keySelector));
   6. }
   7. }
   • 下面的使用就很简单了：
   1. Product[] products =
   2. {
   3. new Product { Name = "Smallapple", Code = 9 },
   4. new Product { Name = "orange", Code = 4 },
   5. new Product { Name = "Bigapple", Code = 9 },
   6. new Product { Name = "lemon", Code = 12 }
   7. };
   8. var p1 = products.Distinct(p => p.Code);
   9. foreach (Product pro in p1)
   10. Console.WriteLine(pro.Name + "," + pro.Code);
   11. var p2 = products.Distinct(p => p.Name);
   12. foreach (Product pro in p2)
   13. Console.WriteLine(pro.Name + "," + pro.Code);
   • 可以看到，加上Linq表达式，可以方便的对自定义类的任意字段进行Distinct的处理。