C# 实现Distinct将对象按条件去重_C#

平时，我们将c#中的Distinct大多用于对数组去重，一般数组为基础的数据类型，例如 int,string.也可以用于对象去重，我们看看C#对Distinct方法的定义：

C# 实现Distinct将对象按条件去重

有重载，第一个参数都加了this,是拓展方法，有关拓展方法，请百度了解。

下面我们来研究下Distinct的对象去重，假设我们现在有一个People类：

 public class People
 {
  public int ID { get; set; }
  /// <summary>
  /// 姓名
  /// </summary>
  public string Name { get; set; }
  /// <summary>
  /// 所属省份
  /// </summary>
  public string Province { get; set; }
  /// <summary>
  /// 年龄
  /// </summary>
  public int Age { get; set; }
  public override string ToString()
  {
   return string.Format("ID:{0} Name:{1} Province:{2} Age:{3}", ID, Name, Province, Age);
  }
 }

我们声明一个ListPeole对象集合：

People p = new People() { ID = 100, Name = "liu", Province = "广东", Age = 100 };
People p1 = p;
People p2 = p1;
IEnumerable<People> ListPeople = new List<People>()
{
 p,
 p1,
 p2,
 new People(){ID=0,Name="li",Province="湖北",Age=20},
 new People(){ID=0,Name="li",Province="湖北",Age=20},
 new People(){ID=1,Name="li",Province="湖北",Age=20},
 new People(){ID=1,Name="li",Province="湖南",Age=20},
 new People(){ID=2,Name="li",Province="湖北",Age=20},
 new People(){ID=3,Name="li",Province="湖南",Age=21},
 new People(){ID=4,Name="li",Province="湖北",Age=22},
};

我们来对ListPeople使用Distinct方法，不带任何参数，运行结果如下：

C# 实现Distinct将对象按条件去重

可以看到，Distinct方法没有带参数的话，将对象集合中p,p1,p2进行去重，而对于对象的成员值是一样的不同对象没有去重，说明Distinct方法不加参数的话，去重的规则是比较对象集合中对象的引用是否相同，如果相同，则去重，否则不去重。

现在我们有个需求，对于ID相同的People，我们算做同一个人，要输出集合中不重复的人（对于ID相同的随便输出一个即可），这时，我们用到了Distinct的第二个方法，方法要求传入的参数是IEqualityComparer类型，继承一个泛型接口，我们加入如下代码：

 public class PeopleCompareByID : IEqualityComparer<People>
 {
  public bool Equals(People x, People y)
  {
   if (x == null || y == null)
    return false;
   if (x.ID == y.ID)
    return true;
   else
    return false;
  }

  public int GetHashCode(People obj)
  {
   if (obj == null)
    return 0;
   else
    return obj.ID.GetHashCode();
  }
 }

继承IEqualityComparer接口必须实现Equals和GetHashCode方法。

我们比较的时候，传入一个PeopleCompareByID 的实体即可：

ListPeople.Distinct(new PeopleCompareByID()).ToList().ForEach(x => Console.WriteLine(x));

运行结果如下：

C# 实现Distinct将对象按条件去重

达到了我们以ID去重的效果。

现在需求又变，ID和省份相同的算同一个人，要输出人的信息（相同的随便输出一个即可），这个时候，我们看到ID=0和Province="湖北"的存在重复，要将其去重，我们再来一个类，还是继承自IEqualityComparer：

 public class PeopleCompareByIDAndProvince : IEqualityComparer<People>
 {
  public bool Equals(People x, People y)
  {
   if (x == null || y == null)
    return false;
   if (x.ID == y.ID&&x.Province==y.Province)
    return true;
   else
    return false;
  }

  public int GetHashCode(People obj)
  {
   if (obj == null)
    return 0;
   else
    return obj.ID.GetHashCode()^obj.Province.GetHashCode();
  }
 }

同样，使用Distinct方法的时候，传入PeopleCompareByIDAndProvince 的实例：

ListPeople.Distinct(new PeopleCompareByIDAndProvince()).ToList().ForEach(x => Console.WriteLine(x));

运行后的结果如下：

C# 实现Distinct将对象按条件去重

新增：1.类的某个属性是list数组，按照这个list的引用是否相同来判断是否是同一个对象

我们再来修改一下上面的代码如下：

 class Program
 {
  static void Main(string[] args)
  {
   List<int> list = new List<int>() { 1, 2, 11, 222, 3, 4 };
   List<int> list1 = new List<int>() { 1, 2, 11, 222, 3, 4 };
   People p1 = new People() { Name = "Tony1", ID = 1, Age = 18, Members = list };
   People p2 = new People() { Name = "Tony2", ID = 2, Age = 19, Members = list };
   People p3 = new People() { Name = "Tony3", ID = 3, Age = 20, Members = list1 };
   People p4 = new People() { Name = "Tony4", ID = 4, Age = 21, Members = new List<int>() };
   List<People> personList = new List<People>() { p1, p2,p2,p3,p4 };
   personList.Distinct(new PeopleComparedByList()).ToList().ForEach(x => Console.WriteLine(x));
   Console.Read();
  }
 }
 public class People
 {
  public int ID { get; set; }
  /// <summary>
  /// 姓名
  /// </summary>
  public string Name { get; set; }
  /// <summary>
  /// 所属省份
  /// </summary>
  public string Province { get; set; }
  /// <summary>
  /// 年龄
  /// </summary>
  public int Age { get; set; }
  private List<int> members = new List<int>();
  public List<int> Members
  {
   get { return members; }
   set { members = value; }
  }
  public override string ToString()
  {
   return string.Format("ID:{0} Name:{1} Province:{2} Age:{3},Members:{4}", ID, Name, Province, Age,string.Join("-",this.Members.ToList()));
  }
 }
 public class PeopleComparedByList : IEqualityComparer<People>
 {
  public bool Equals(People x, People y)
  {
   if (x.Members == y.Members)
    return true;
   else
    return false;
  }

  public int GetHashCode(People obj)
  {
   return obj.Members.GetHashCode();
  }
 }

运行的结果如下：

C# 实现Distinct将对象按条件去重

从结果可以看到，Tony1,Tony2的Members属性是一个同一个引用的list，所以去重复的时候把Tony2给去掉了

达到了我们想要的效果。

新增：2.类的某个属性是list数组，按照这个list的各元素的值是否相同来判断是否是同一个对象

我们来新增加一个比较器：

public class PeopleComparedByListValue : IEqualityComparer<People>
 {
  public bool Equals(People x, People y)
  {
   if (x.Members == null && y.Members == null)
    return true;
   if (x.Members == null || y.Members == null)
    return false;
   if (x.Members.Count != y.Members.Count)
    return false;
   //循环比较值
   for (int i = 0; i < x.Members.Count; i++)
   {
    if (x.Members[i] != y.Members[i])
     return false;
   }
   return true;
  }

  public int GetHashCode(People obj)
  {
   var hashCode = 1;
   if (obj.Members == null)
    return 0;
   if (obj.Members.Count == 0)
    return 1;
   obj.Members.ForEach(x => hashCode ^= x);
   return hashCode;   
  }
 }

使用这个比较器：

static void Main(string[] args)
  {
   List<int> list = new List<int>() { 1, 2, 11, 222, 3, 4 };
   List<int> list1 = new List<int>() { 1, 2, 11, 222, 3, 4 };
   People p1 = new People() { Name = "Tony1", ID = 1, Age = 18, Members = list };
   People p2 = new People() { Name = "Tony2", ID = 2, Age = 19, Members = list };
   People p3 = new People() { Name = "Tony3", ID = 3, Age = 20, Members = list1 };
   People p4 = new People() { Name = "Tony4", ID = 4, Age = 21, Members = new List<int>() };
   List<People> personList = new List<People>() { p1, p2,p2,p3,p4 };
   personList.Distinct(new PeopleComparedByListValue()).ToList().ForEach(x => Console.WriteLine(x));
   Console.Read();
  }

运行结果：

C# 实现Distinct将对象按条件去重