List对象去重碎碎念之神叨叨

 

现在distinct集合中就只有一个Man对象了,成功实现了去重。

class Program
    {
        static void Main(string[] args)
        {

            List<UserInfo> list = new List<UserInfo>()
            {
                new UserInfo() {  Id="1", UserName="111"},
                new UserInfo() {  Id="1", UserName="111"}
            };

            // 用拉姆达表达式一句话即可实现去重
            var result = list.Where((x,i)=>list.FindIndex(y=>y.Id==x.Id)==i);

            result.ToList().ForEach(item=> 
            {
                Console.WriteLine($"Id:{item.Id}  UserName:{item.UserName}");
            });

            Console.ReadKey();
        }

        class UserInfo
        {
            public string Id { get; set; }
            public string UserName { get; set; }
        }

    }

实际上,由于直接获取对象的HashCode,用HashCode进行比较的速度比 Equals
方法更快,

public static class DistinctHelper
    {
        /// <summary>
        /// 自定义Distinct扩展方法
        /// </summary>
        /// <typeparam name="T">要去重的对象类</typeparam>
        /// <typeparam name="C">自定义去重的字段类型</typeparam>
        /// <param name="source">要去重的对象</param>
        /// <param name="getfield">获取自定义去重字段的委托</param>
        /// <returns></returns>
        public static IEnumerable<T> DistinctEx<T, C>(this IEnumerable<T> source, Func<T, C> getfield)
        {
            return source.Distinct(new Compare<T, C>(getfield));
        }
    }

    public class Compare<T, C> : IEqualityComparer<T>
    {
        private Func<T, C> _getField;
        public Compare(Func<T, C> getfield)
        {
            this._getField = getfield;
        }
        public bool Equals(T x, T y)
        {
            return EqualityComparer<C>.Default.Equals(_getField(x), _getField(y));
        }
        public int GetHashCode(T obj)
        {
            return EqualityComparer<C>.Default.GetHashCode(this._getField(obj));
        }
    }
public class ManComparerNew : IEqualityComparer<Man>
        {
            public bool Equals(Man x, Man y)
            {
                return x.Age == y.Age
                    && x.Name == y.Name
                    && x.Adress == y.Adress
                    && x.Weight == y.Weight
                    && x.Height == y.Height;
            }

            public int GetHashCode(Man obj)
            {
                return 1;
            }
        }

var distinct = list.Distinct(new ManComparerNew());

 

然而去重得到的distinct集合的Count依然为二,集合里依然存在两个Adam。

我们再来写一个通用的扩展方法

public class ManComparer : IEqualityComparer<Man>
        {
            public bool Equals(Man x, Man y)
            {
                return x.Age == y.Age
                    && x.Name == y.Name
                    && x.Adress == y.Adress
                    && x.Weight == y.Weight
                    && x.Height == y.Height;
            }

            public int GetHashCode(Man obj)
            {
                return obj.GetHashCode();
            }
        }

 var distinct = list.Distinct(new ManComparer());

利用HashSet去重,在实体类里重写Equals和GetHashCode方法

因此我们对对象集合使用Distinct方法时要使用重载Distinct<TSource>(this
IEnumerable<TSource> source, IEqualityComparer<TSource>
comparer);

 

而当两个对象HashCode不相同时, Equals
方法就会被调用,对要比较的对象进行判断。

权责申明

由于在上例中list中的两个引用实际上是两个不同的对象,因此HashCode必定不相同

一、方法一

所以要触发Equlas方法,我们需要改 GetHashCode
,让它返回相同的常量

List集合操作去除重复数据的这种情况经常会碰到,博客园里面也有很多大神们做过,在这里主要是借鉴然后自己整理了一下,主要是为了方便自己,以后再次碰到这种去重问题,直接打开自己的链接拿起键盘就是干,,,,

实际上,Distinct方法内进行比较的是声明的引用,而不是对象属性,就和对两个属性一模一样的对象使用Equals()方法得到的是False一样。

class Program
    {
        static void Main(string[] args)
        {

            UserInfo info = new UserInfo();
            List<UserInfo> list = new List<UserInfo>()
            {
                new UserInfo() {  Id="1", UserName="111"},
                new UserInfo() {  Id="1", UserName="111"}
            };

            list.Distinct(new DistinctCompare()).ToList().ForEach(item =>
            {

                Console.WriteLine($"Id:{item.Id}  UserName:{item.UserName}");
            });

            Console.ReadKey();
        }


        class UserInfo
        {
            public string Id { get; set; }
            public string UserName { get; set; }
        }


        class DistinctCompare : IEqualityComparer<UserInfo>
        {
            public bool Equals(UserInfo x, UserInfo y)
            {
                return x.Id == y.Id;//可以自定义去重规则,此处将Id相同的就作为重复记录
            }
            public int GetHashCode(UserInfo obj)
            {
                return obj.Id.GetHashCode();
            }
        }
    }
class Man
        {
            public int Age { get; set; }
            public string Name { get; set; }
            public string Adress { get; set; }
            public decimal Weight { get; set; }
            public decimal Height { get; set; }
        }

List<Man> list = new List<Man>()
            { 
            new Man(){Age=21,Name="Adam",Adress="Shenzhen",Weight=60,Height=170},
            new Man(){Age=21,Name="Adam",Adress="Shenzhen",Weight=60,Height=170}
            };
            var distinct = list.Distinct();

 实现

然而,再一次,distinct集合内依然有两个对象。

前言

因此IEqualityComparer内部会在使用 Equals 前先使用
GetHashCode 方法,在两个对象的HashCode都相同时即刻判断对象相等。

发表评论

电子邮件地址不会被公开。 必填项已用*标注