例子:
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字段,返回交集