C#中List自定义类的集合操作

例子：

    class User
    {
        public User(string a,string n)
        {
            Id = a;
            Name = n;
        }
        public string Id { get; set; }
        public string Name { get; set; }
    }
    class Program
    {
        public static void Main(string[] args)
        {
            List<User> list1 = new List<User>
            {
                new User("001","aa"),
                new User("001","aa"),
                new User("002","aa"),
                new User("003","aa"),
                new User("004","aa")
            };
            List<User> list2 = new List<User>
            {
                new User("001","aa"),
                new User("004","aa"),
                new User("005","aa"),
                new User("007","aa"),
                new User("008","aa")
            };
            List<User> list = list1.MyDistinct(s => s.Id).ToList();
            Console.WriteLine("去重：");
            foreach (var item in list)
            {
                Console.WriteLine(item.Id);
            }
            list = list1.MyExcept(list2, s => s.Id).ToList();
            Console.WriteLine("差集：");
            foreach (var item in list)
            {
                Console.WriteLine(item.Id);
            }
            list = list1.MyUnion(list2, s => s.Id).ToList();
            Console.WriteLine("并集：");
            foreach (var item in list)
            {
                Console.WriteLine(item.Id);
            }
            list = list1.MyIntersect(list2, s => s.Id).ToList();
            Console.WriteLine("交集：");
            foreach (var item in list)
            {
                Console.WriteLine(item.Id);
            }
            Console.ReadKey();
        }
    }

 

运行结果：

 

附源码：

    /// <summary>
    /// 集合帮助
    /// </summary>
    public static class SetOperationHelper
    {
        /// <summary>
        /// 去除source集合中重复的
        /// </summary>
        /// <typeparam name="T">要去重的对象类</typeparam>
        /// <typeparam name="C">自定义去重的字段类型</typeparam>
        /// <param name="source">要去重的对象</param>
        /// <param name="getfield">获取自定义去重字段的委托</param>
        /// <returns></returns>
        public static IEnumerable<T> MyDistinct<T, C>(this IEnumerable<T> source, Func<T, C> getfield)
        {
            return source.Distinct(new Compare<T, C>(getfield));
        }
        /// <summary>
        /// 差集，返回在source中存在，不在second中存在
        /// </summary>
        /// <typeparam name="T">对象类</typeparam>
        /// <typeparam name="C">字段</typeparam>
        /// <param name="source"></param>
        /// <param name="second"></param>
        /// <param name="getfield">获取自定义去重字段的委托</param>
        /// <returns></returns>
        public static IEnumerable<T> MyExcept<T, C>(this IEnumerable<T> source, IEnumerable<T> second, Func<T, C> getfield)
        {
            return source.Except(second, new Compare<T, C>(getfield));
        }
        /// <summary>
        /// 并集
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="C"></typeparam>
        /// <param name="source"></param>
        /// <param name="second"></param>
        /// <param name="getfield"></param>
        /// <returns></returns>
        public static IEnumerable<T> MyUnion<T, C>(this IEnumerable<T> source, IEnumerable<T> second, Func<T, C> getfield)
        {
            return source.Union(second, new Compare<T, C>(getfield));
        }
        /// <summary>
        /// 交集
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="C"></typeparam>
        /// <param name="source"></param>
        /// <param name="second"></param>
        /// <param name="getfield"></param>
        /// <returns></returns>
        public static IEnumerable<T> MyIntersect<T, C>(this IEnumerable<T> source, IEnumerable<T> second, Func<T, C> getfield)
        {
            return source.Intersect(second, new Compare<T, C>(getfield));
        }
    }

    public class Compare<T, C> : IEqualityComparer<T>
    {
        private readonly Func<T, C> _getField;
        public Compare(Func<T, C> getfield)
        {
            _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(_getField(obj));
        }
    }

调用：

List<Entity> list = entities1.MyDistinct(s => s.Id).ToList();//根据自定义类中的ID字段去重。
List<Entity> list = entities1.MyExcept(entities2,s => s.Id).ToList();//根据自定义类中的ID字段，返回在ntities1中存在，不在entities2中存在。
List<Entity> list = entities1.MyUnion(entities2,s => s.Id).ToList();//根据自定义类中的ID字段，返回并集
List<Entity> list = entities1.MyIntersect(entities2,s => s.Id).ToList();//根据自定义类中的ID字段，返回交集