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

前言

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

一、方法一

利用hashset去重，在实体类里重写equals和gethashcode方法

 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"}
            };

            // 因为我们通常操作的是list集合，所以我在这里把list转成了hashset类型来接受
            hashset<userinfo> hs = new hashset<userinfo>(list); 
            foreach (var item in hs)
            {
                console.writeline($"id:{item.id}  username:{item.username}");
            }
           
            console.readkey();
        }

        class userinfo
        {
            public string id { get; set; }
            public string username { get; set; }

            public override bool equals(object obj)
            {
                userinfo user = obj as userinfo;
                return this.id == user.id ;
            }
            public override int gethashcode()
            {
                return this.id.gethashcode();
            }
        }
    }

二、方法二

利用拉姆达表达式distinct方法，我们转到定义可以看到两个重载的distinct方法，如图

我们再转到定义看看iequalitycomparer接口里面到底是个啥玩意，原来有两个方法

这时候我们来实现iequalitycomparer接口里面的方法

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();
            }
        }
    }

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

帮助类

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));
        }
    }

 实现

 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.distinctex(x => x.id).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 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; }
        }
        
    }

 

 

 

 

权责申明

作者：sportsky 出处： 
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。如果觉得还有帮助的话，可以点一下右下角的【推荐】，希望能够持续的为大家带来好的技术文章！想跟我一起进步么？那就【关注】我吧。