C# Distinct将对象按条件去重

最新推荐文章于 2025-06-25 10:59:56 发布
最新推荐文章于 2025-06-25 10:59:56 发布
阅读量2.9w 收藏 45
点赞数 15
CC 4.0 BY-SA版权
分类专栏： C# Distinct 文章标签： Distinct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lishuangquan1987/article/details/76096022
本文详细介绍了C#中Distinct方法的应用，特别是针对对象集合的去重操作，并提供了多个示例，包括根据对象的不同属性进行去重的具体实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

平时，我们将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));

运行后的结果如下：
这里写图片描述
新增：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();
        }
    }

运行的结果如下：
在这里插入图片描述
从结果可以看到，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();
        }

运行结果：

在这里插入图片描述
可以看到，数组值为1, 2, 11, 222, 3, 4 的只剩下一个了，达到了按值相同去重复的效果。
以后遇到以三个或者四个甚至更多的对象成员来决定对象是否重复的去重问题时，可以采用这种方法。
以上为个人拙见。

list的多条件排序与list对象去重、对象属性去重
灵豸
05-06 1995
重写equals和hashcode方法。
c#对象集合去重_C#黔驴技巧之去重（Distinct）
weixin_42126668的博客
01-14 2426
原标题：C#黔驴技巧之去重(Distinct)关于C#中默认的Distinct方法在什么情况下才能去重，这个就不用我再多讲，针对集合对象去重默认实现将不再满足，于是乎我们需要自定义实现来解决这个问题，接下来我们详细讲解几种常见去重方案，孰好孰歹自行判之。分组首先给出我们需要用到的对象，如下：publicclassPerson{publicstringName { get; set; }public...
C# 实现Distinct将对象按条件去重
01-19
平时，我们将c#中的Distinct大多用于对数组去重，一般数组为基础的数据类型，例如 int,string.也可以用于对象去重，我们看看C#对Distinct方法的定义： 有重载，第一个参数都加了this,是拓展方法，有关拓展方法，请百度了解。 下面我们来研究下Distinct的对象去重，假设我们现在有一个People类： public class People { public int ID { get; set; } /// /// 姓名 /// public string Name { get; set; } /
c#对象集合去重_C# 实现Distinct将对象按条件去重
weixin_33920303的博客
01-14 1340
平时，我们将c#中的Distinct大多用于对数组去重，一般数组为基础的数据类型，例如 int,string.也可以用于对象去重，我们看看C#对Distinct方法的定义：有重载，第一个参数都加了this,是拓展方法，有关拓展方法，请百度了解。下面我们来研究下Distinct的对象去重，假设我们现在有一个People类：public class People{public int ID { get...
【C#】Distinct不起作用
weixin_38792911的博客
06-25 223
摘要：C#中对自定义类型使用Distinct()时，默认无法正确去重，需要重写Equals()和GetHashCode()方法或实现IEqualityComparer<T>接口。文章展示了两种解决方法：1）在类中直接重写这两个方法；2）创建专门的比较器类。对于GetHashCode()的实现，可使用HashCode.Combine()或手动计算哈希值（如字符串哈希与数值哈希异或）。这两种方式都能使Distinct()正确识别重复的自定义对象。（150字）
Linq的Distinct太不给力了
weixin_34240657的博客
08-01 752
假设我们有一个类：Product public class Product { public string Id { get; set; } public string Name { get; set; } } Main函数如下： static void Main() { List&lt;Product&gt; products = new Lis...
lambda List实现某列去重的解决方案采用扩展方法
weixin_30535167的博客
01-22 295
public class CommonEqualityComparer<T, V> : IEqualityComparer<T> { private Func<T, V> keySelector; public CommonEqualityComparer(Func<T, V> keySelector) ...
C#---distinct
新博客：https://aping-dev.com/
10-13 918
static void Main(string[] args) { List<int> lst = new List<int>(); lst.Add(1); lst.Add(1); lst.Add(2); lst.Add(2); lst = ls
C# 实现按特定条件对对象进行去重
最新发布
08-05
其实，Distinct 也可以用于对象去重。我们先来看看 Distinct 方法的定义：它有重载版本，且第一个参数带有 this 关键字，这表明它是一个扩展方法。关于扩展方法的详细内容，可以自行查阅资料了解。 接下来，我们重点...
完美解决c# distinct不好用的问题
01-19
当一个结合中想根据某一个字段做去重方法时使用以下代码 IQueryable 继承自IEnumerable 先举例： #region linq to object List<People> peopleList = new List(); peopleList.Add(new People { UserName = zzl, ...
C#中Distinct方法详解：对象去重及People类示例
在这个场景下，`Distinct` 将基于对象的某个或某些属性进行比较，以确定是否为重复项。对于复杂对象，我们需要明确指定按哪个属性进行去重，可以通过传递一个自定义的 `IEqualityComparer<T>` 接口的实现来定义比较...
C# Distinct方法的使用笔记
热门推荐
shaopengfei的专栏
07-02 4万+
从C# 3.0开始提供了Distinct方法，这对于
Distinct自定义去重
03-01
今天遇到一个数组再分组的情况，思路是先找到分组的原则，之后再遍历一次得到分组的数据。 就是把所有重复的数据去掉，（分组依据） 重写了IEqualityComparer接口，并实现了它，但是有一点当明没有搞明白。就是第二个gethashcode的作用，后来发现
【转载】C#中通过Distinct方法对List集合进行去重
weixin_30576827的博客
06-15 1376
在C#的List集合对象中，可以使用Distinct方法来对List集合元素进行去重，如果list集合内部元素为值类型，则Distinct方法根据值类型是否相等来判断去重，如果List集合内部元素为引用类型变量，则是判断相同引用的对象为相同进行List集合元素去重操作。 （1）值类型的List<int>集合对象intList，内部元素为1,1,2,2,3,4，5等这几个元素。对int...
C#黔驴技巧之去重（Distinct）
dotNET跨平台
05-11 858
关于C#中默认的Distinct方法在什么情况下才能去重，这个就不用我再多讲，针对集合对象去重默认实现将不再满足，于是乎我们需要自定义实现来解决这个问题，接下来我们详细讲解几种常见去重方...
c#中分隔字符split，distinct()去重
qq_53217825的博客
10-19 866
去重distinct()或者GroupBy(p => p).Select(p => p.Key)，去重的对象都需要为数组，具体看代码。分隔基本语法：x.split("y")分割完会得到一个数组类型。后续可以通过for循环拼接。x————需要操作的字符串。y————分割的字符。
【C#】详解使用Enumerable.Distinct方法去重
dingjiubi7303的博客
04-16 634
Enumerable.Distinct 方法 是常用的LINQ扩展方法，属于System.Linq的Enumerable方法，可用于去除数组、集合中的重复元素，还可以自定义去重的规则。 有两个重载方法： // // 摘要: // 通过使用默认的相等比较器对值进行比较返回序列中的非重复元素。 // ...
C# 对象按条件去重(Distinct)
Edwardliuy的博客
01-09 1218
现有一个BSUserRoleResult类 public class BSUserRoleResult { /// <summary> /// 获取或者设置 角色分组编号 /// </summary> public int RoleGroupId { get; set; } /// <summary> /// 获取或者设置 角色编号 //...
C#对象去重方法
xuebiao1215
10-15 1338
今天在做项目的时候遇到从数据库中查询数据之后又重复的数据，展示在页面中需要的的是不重复的数据，所以就从网上找了看了下谢了这样的对象去重方法，结合Linq使用：            根据对象 中的属性进行比较去重： public class StuCompare : IEqualityComparer&lt;View_FBase_StuClassPlanInfo&gt; { ...
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值