数据去重

平时，我们将c#中的Distinct大多用于对数组去重，一般数组为基础的数据类型，例如 int,string.也可以用于对象去重，我们看看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方法，不带任何参数，运行结果如下：
 
可以看到，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));

运行结果如下：
 
达到了我们以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));

运行后的结果如下：
 
达到了我们想要的效果。
以后遇到以三个或者四个甚至更多的对象成员来决定对象是否重复的去重问题时，可以采用这种方法。
以上为个人拙见。