Linq操作之Except,Distinct,Left Join

     最近项目中用到了Linq中Except，Distinct，Left Join这几个运算，这篇简单的记录一下这几种情形。

Except

     基础类型使用Linq的运算很简单，下面用来计算两个集合的差

           int[] a = {1, 2, 3, 4};
         int[] b = {2, 3, 4, 5};
         var reslut = a.Except(b);

    result 用来返回a有，b没有的值，计算结果是1。

    自定义类型实现Except

        class Employee
       {
        public int ID { get; set; }
       }

    对于引用类型，若需要根据属性进行Except运算，则看下面简单的例子

          List<Employee> employeeA = new List<Employee>() { new Employee { ID = 1 }, new Employee { ID = 2 }};
          List<Employee> employeeB = new List<Employee>() { new Employee { ID = 2 }, new Employee { ID = 3 } };
            //var reslut = employeeA.Except(employeeB);
          var reslut = (from a in employeeA
                          select a.ID).Except
                       (from b in employeeB
                           select b.ID );

    对于集合的操作，Linq中还提供了Union，Intersect等常见的几个运算，都是关系数据库中常用的运算

Distinct

     Distict是用来排除相同序列中元素的，对于基础类型，可以直接使用Distinct

       int[] a = {1, 2, 2, 3, 3, 3, 4};
       var reslut = a.Distinct();

    结果是1,2,3,4，但是对于自定义类型，则需要额外的一些操作，方式有多种，这里选择其中一种，即实现IEquatable<>

        class Employee : IEquatable<Employee>
      {
        public int ID { get; set; }
        public string Name { get; set; }
        public bool Equals(Employee other)
        {
            if (Object.ReferenceEquals(other, null))
                return false;
            if (ReferenceEquals(this, other))
                return true;
            return ID.Equals(other.ID);
        }
        public override int GetHashCode()
        {
            return ID.GetHashCode();
        }
    }

    这里重写了GetHashCode，Equals根据ID相同过滤对象，看简单的例子

        List<Employee> employees = new List<Employee>
                                           {
                                               new Employee {ID = 1, Name = "Ringgo"},
                                               new Employee {ID = 2, Name = "Rex"},
                                               new Employee {ID = 1, Name = "Ringgo"}
                                           };
        var reslut = employees.Distinct();

    这样就实现了对自定义类型的Distinct操作。    
  
Left Join    

     Linq查询表达式中提供了join运算，比较常见的是join.. on ..equals,也就是内联接运算

        int[] array1 = {1, 2, 3, 4};
        int[] array2 = {1, 2,3,5};
        var reslut = from a in array1
                     join i in array2 on a equals i into  c
                     from o in c
                     select o;

    这里要说的是Left Join，这里为了方便，仅列出表达式的语法

         var result = from a in employees
                            join b in _biddingBase
                            on a.EmployeeId equals b.EmployeeId into  temp
                            from t in temp.DefaultIfEmpty()
                            select new 
                            {
                                Name = a.Name,
                                OrganizationName = a.OrganizaionName,
                                EmployeeId = a.AgentId,
                                Id = a.EmployeeId,
                                OrganizationId = a.OrganizaionId,
                                DayOffValue  = t==null?0:t.DayOffValue,
                                TimeOffValue = t==null?0:t.TimeOffValue
                            }; 

    这段代码主要是用到DefaultIfEmpty()，那么在右集合为null时，注意DayOffValue = t==null?0:t.DayOffValue这种语法即可。

    如果你对数据库的表的各种联接运算理解的话，我想用LINQ这种语法会更方便。

    以上即是这段时间项目中遇到的一些问题，为了之后再遇到这种问题时不必花时间，这里自己把这些问题提取出来，也希望对你有所帮助。