两个List集合做数据对比

两个对比List数据对比(差集[Except])

List 继承了Enumerable ，Enumerable 中有一个Except方法

它有两个实现：

• 第一个实现是通过使用默认的相等比较器对值进行比较，生成两个序列的差集。
• 第二个实现是通过使用指定的 IEqualityComparer 对值进行比较，生成两个序列的差集。

这是用默认的相等对比器
这种方式一般都是用来比较简单数组或者字符串内容

double[] numbers1 = { 2.0, 2.0, 2.1, 2.2, 2.3, 2.3, 2.4, 2.5 };
double[] numbers2 = { 2.2 };

IEnumerable<double> onlyInFirstSet = numbers1.Except(numbers2);

foreach (double number in onlyInFirstSet)
    Console.WriteLine(number);

这里的输出结果：
2
2.1
2.3
2.4
2.5

---

使用指定的 IEqualityComparer 对值进行比较
这种可以用来对比对象集合

模型

namespace 测试项目.Test
{
	public class test{
		public int id{get;set;}
		public string name{get;set;}
		public string tel{get;set;}
		public int age{get;set;}
		public string clas{get;set;}
	}
  public class testComparer : IEqualityComparer<test>
    {
        public bool Equals(test x, test y)
        {
            return x.name== y.name && x.tel== y.tel;
        }

        public int GetHashCode(test obj)
        {
            return obj.name.GetHashCode() ^ obj.tel.GetHashCode();
        }
    }
}

使用方法：

List<test> list=...这是第一个对象集合
List<test> list2=...这是第二个集合


 var different = list.Except(list2,new testComparer()).ToList();
 这是查询第一个集合里有但是第二个集合里面没有的数据

List查找两个集合共有的数据（交集[Intersect]）

它和”Except“类似同样有两个实现：

• 第一个实现是通过使用默认的相等比较器对值进行比较，生成两个序列的交集。
• 第二个实现是通过使用指定的 IEqualityComparer 对值进行比较，生成两个序列的交集。

这是用默认的相等对比器
这种方式一般都是用来比较简单数组或者字符串内容

double[] numbers1 = { 2.0, 2.0, 2.1, 2.2, 2.3, 2.3, 2.4, 2.5 };
double[] numbers2 = { 2.2 };

IEnumerable<double> onlyInFirstSet = numbers1.Intersect(numbers2);

foreach (double number in onlyInFirstSet)
    Console.WriteLine(number);

这里的输出结果：
2.2

---

使用指定的 IEqualityComparer 对值进行比较
这种可以用来对比对象集合

模型

namespace 测试项目.Test
{
	public class test{
		public int id{get;set;}
		public string name{get;set;}
		public string tel{get;set;}
		public int age{get;set;}
		public string clas{get;set;}
	}
  public class testComparer : IEqualityComparer<test>
    {
        public bool Equals(test x, test y)
        {
        //这里是用于判断相同的依据字段
            return x.name== y.name && x.tel== y.tel;
        }

        public int GetHashCode(test obj)
        {
            return obj.name.GetHashCode() ^ obj.tel.GetHashCode();
        }
    }
}

使用方法：

List<test> list=...这是第一个对象集合
List<test> list2=...这是第二个集合


 var different = list.Intersect(list2,new testComparer()).ToList();
 这是查询第一个对象集合和第二个对象集合共有的对象。

List合并去除重复项（全集[Union]）

它也和”Except“类似同样有两个实现：

• 第一个实现是通过使用默认的相等比较器对值进行比较，生成两个序列的交集。
• 第二个实现是通过使用指定的 IEqualityComparer 对值进行比较，生成两个序列的交集。

这是用默认的相等对比器
这种方式一般都是用来比较简单数组或者字符串内容

double[] numbers1 = { 2.0, 2.0, 2.1, 2.2, 2.3, 2.3, 2.4, 2.5 };
double[] numbers2 = { 2.2 };

IEnumerable<double> onlyInFirstSet = numbers1.Union(numbers2);

foreach (double number in onlyInFirstSet)
    Console.WriteLine(number);

这里的输出结果：
2
2.1
2.2
2.3
2.4
2.5

---

使用指定的 IEqualityComparer 对值进行比较
这种可以用来对比对象集合

模型

namespace 测试项目.Test
{
	public class test{
		public int id{get;set;}
		public string name{get;set;}
		public string tel{get;set;}
		public int age{get;set;}
		public string clas{get;set;}
	}
  public class testComparer : IEqualityComparer<test>
    {
        public bool Equals(test x, test y)
        {
        //这里是用于判断相同的依据字段
            return x.name== y.name && x.tel== y.tel;
        }

        public int GetHashCode(test obj)
        {
            return obj.name.GetHashCode() ^ obj.tel.GetHashCode();
        }
    }
}

使用方法：

List<test> list=...这是第一个对象集合
List<test> list2=...这是第二个集合


 var different = list.Union(list2,new testComparer()).ToList();
 这是将第一个集合和第二个集合合并在一起，会根据testComparer里的字段去除重复的对象。

List合并保留重复项（全集[Concat]）

它也和”Except“类似同样有两个实现：

• 第一个实现是通过使用默认的相等比较器对值进行比较，生成两个序列的交集。
• 第二个实现是通过使用指定的 IEqualityComparer 对值进行比较，生成两个序列的交集。

这是用默认的相等对比器
这种方式一般都是用来比较简单数组或者字符串内容

double[] numbers1 = { 2.0, 2.0, 2.1, 2.2, 2.3, 2.3, 2.4, 2.5 };
double[] numbers2 = { 2.2 };

IEnumerable<double> onlyInFirstSet = numbers1.Concat(numbers2);

foreach (double number in onlyInFirstSet)
    Console.WriteLine(number);

这里的输出结果：
2
2.1
2.2
2.2
2.3
2.4
2.5

---

使用指定的 IEqualityComparer 对值进行比较
这种可以用来对比对象集合

模型

namespace 测试项目.Test
{
	public class test{
		public int id{get;set;}
		public string name{get;set;}
		public string tel{get;set;}
		public int age{get;set;}
		public string clas{get;set;}
	}
  public class testComparer : IEqualityComparer<test>
    {
        public bool Equals(test x, test y)
        {
        //这里是用于判断相同的依据字段
            return x.name== y.name && x.tel== y.tel;
        }

        public int GetHashCode(test obj)
        {
            return obj.name.GetHashCode() ^ obj.tel.GetHashCode();
        }
    }
}

使用方法：

List<test> list=...这是第一个对象集合
List<test> list2=...这是第二个集合


 var different = list.Concat(list2,new testComparer()).ToList();
 这是将第一个集合和第二个集合合并在一起，会保留重复的对象。