求两个集合的交集，并集，差集

1.  取交集 (A和B都有)

List A : { 1 , 2 , 3 , 5 , 9 }

List B : { 4 , 3 , 9 }

var intersectedList = list1.Intersect(list2);

結果 : { 3 , 9 }

判斷A和B是否有交集

bool isIntersected = list1.Intersect(list2).Count() > 0

2. 取差集 (A有，B沒有)

List A : { 1 , 2 , 3 , 5 , 9 }

List B : { 4 , 3 , 9 }

var expectedList = list1.Except(list2);

結果 : { 1 , 2 , 5 }

判斷A和B是否有差集
bool isExpected = list1.Expect(list2).Count() > 0

3.  取聯集 (包含A和B)

List A : { 1 , 2 , 3 , 5 , 9 }

List B : { 4 , 3 , 9 }

    public static class ListExtensions
    {
        public static List<T> Merge<T>(this List<T> source, List<T> target)
        {
            List<T> mergedList = new List<T>(source);
            mergedList.AddRange(target.Except(source));
            return mergedList;
        }
    }

var mergedList = list1.Merge(list2);

結果 : { 1 , 2 , 3 , 5 ,9 , 4 }

举例2个集合A,B. 

 List<int> listA = new List<int> {1,2,3,5,7,9};

 List<int> listB = new List<int> {13,4,17,29,2}; 

 listA.AddRange(listB );把集合A.B合并

 List<int> Result = listA.Union(listB).ToList<int>();          //剔除重复项 

 List<int> Result = listA.Concat(listB).ToList<int>();        //保留重复项

 listA.BinarySearch("1");//判断集合中是否包含某个值.如果包含则返回0

举例两个数组

 int[] i=new int[]{1,2};

  int[] j=new int[]{2,3};

  List<int> r = new List<int>();  

  r.AddRange(i);

  r.AddRange(j);

  int[] c = r.ToArray(); 合并数组

  int[] x=i.Union(j).ToArray<int>(); //剔除重复项 

  int[] x=i.Concat(j).ToArray<int>(); //保留重复项

  int n = Array.BinarySearch(i,3);//判断数组中是否包含某个值.如果包含则返回0

一个集合中去除另一个集合

                                List<string> listold = itemtocheck.AuidtSearchWord.Split(',').ToList(); //旧的搜索词
                                List<string> listnew = NewsearchWords.Split(',').ToList(); //新的搜索词
                                listold.RemoveAll(c => listnew.Contains(c));
                                tempmixwords = string.Join(",", listold.Distinct());

IEqualityComparer接口实现

private static IEnumerable<TSource> ExceptIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
{
  Set<TSource> set = new Set<TSource>(comparer);
  foreach (TSource source in second)
    set.Add(source);
  foreach (TSource source in first)
  {
    if (set.Add(source))
      yield return source;
  }
}

public interface IEqualityComparer<in T>
{
  /// <summary>确定指定的对象是否相等。</summary>
  /// <returns>如果指定的对象相等，则为 true；否则为 false。</returns>
  /// <param name="x">要比较的第一个类型为 <paramref name="T" /> 的对象。</param>
  /// <param name="y">要比较的第二个类型为 <paramref name="T" /> 的对象。</param>
  [__DynamicallyInvokable]
  bool Equals(T x, T y);
 
  /// <summary>返回指定对象的哈希代码。</summary>
  /// <returns>指定对象的哈希代码。</returns>
  /// <param name="obj">
  /// <see cref="T:System.Object" />，将为其返回哈希代码。</param>
  /// <exception cref="T:System.ArgumentNullException">
  /// <paramref name="obj" /> 的类型为引用类型，<paramref name="obj" /> 为 null。</exception>
  [__DynamicallyInvokable]
  int GetHashCode(T obj);
}

public class DeliverySchedulerComparer : IEqualityComparer<DeliverySchedulerDO>
{
    private static readonly DeliverySchedulerComparer _comparer = new DeliverySchedulerComparer();
 
    public static DeliverySchedulerComparer Instance()
    {
        return _comparer;
    }
 
    public bool Equals(DeliverySchedulerDO x, DeliverySchedulerDO y)
    {
        return x.DeliveryLineId == y.DeliveryLineId &&
               x.DeliveryManId == y.DeliveryManId;
    }
 
    public int GetHashCode(DeliverySchedulerDO obj)
    {
        string code = obj.DeliveryLineId.ToString() + obj.DeliveryManId.ToString();
 
        return code.GetHashCode();
    }

//var invalidSchedulers = existsSchedulers.Except(dmsSchedulers, DeliverySchedulerComparer.Instance()).ToList();

zip操作符

int[] numbers = { 3, 5, 7 };
string[] words = { "three", "five", "seven", "ignored" };
IEnumerable<string> zip = numbers.Zip (words, (n, w) => n + "=" + w);
 
// 产生的sequence包含如下元素
// 3=three
// 5=five
// 7=seven

 参考：http://www.cnblogs.com/lifepoem/archive/2011/11/29/2267243.html

EqualityHelper

using System;
using System.Collections.Generic;

namespace Common
{
    public static class EqualityHelper<T>
    {
        public static IEqualityComparer<T> CreateComparer<V>(Func<T, V> keySelector)
        {
            return new CommonEqualityComparer<V>(keySelector);
        }
        public static IEqualityComparer<T> CreateComparer<V>(Func<T, V> keySelector, IEqualityComparer<V> comparer)
        {
            return new CommonEqualityComparer<V>(keySelector, comparer);
        }

        class CommonEqualityComparer<V> : IEqualityComparer<T>
        {
            private Func<T, V> keySelector;
            private IEqualityComparer<V> comparer;

            public CommonEqualityComparer(Func<T, V> keySelector, IEqualityComparer<V> comparer)
            {
                this.keySelector = keySelector;
                this.comparer = comparer;
            }
            public CommonEqualityComparer(Func<T, V> keySelector)
                : this(keySelector, EqualityComparer<V>.Default)
            { }

            public bool Equals(T x, T y)
            {
                return comparer.Equals(keySelector(x), keySelector(y));
            }
            public int GetHashCode(T obj)
            {
                return comparer.GetHashCode(keySelector(obj));
            }
        }
    }
}

 var comparer = EqualityHelper<TestPropertyEntity>.CreateComparer(x => new { x.PropertyCode,x.PropertyType });

//求差集
                var needExcuteDifferList = allPropertyList.Except(existedPropertyList, comparer).ToList();

//去重
result = result.Distinct(comparer).ToList();