C#中Linq和Lambda表达式的使用整理

痛定思痛。 2024-03-26 22:07 12阅读 0赞

#### 文章目录 ####

*  C\#中Linq和Lambda表达式的使用整理
 *   *  1. Linq和Lambda简介
     *  2. Lambda表达式
     *  3. Lambda常用的扩展方法
     *   *  3-1 Where方法：筛选满足条件的数据
         *  3-2 Count()方法：获取数据条数
         *  3-3 Any()方法：是否至少有一条数据
         *  3-4 排序：OrderBy()、OrderByDescending()、ThenBy()、ThenByDescending()
         *  3-5 限制结果集，取部分数据： 去重--groupby/distinct、 截取--skip(n)、Task(n)
         *  3-6 聚合函数: Max()、Min()、Average()、Sum()、Count()等
         *  3-7 分组 GroupBy()
         *  3-8 取首条记录 top(1)
         *  3-9 投影 Select，类似Java中Steam的map/flatmap
         *  3-10 链式调用
     *  4. Linq和Lambda具体代码示例参考：
     *   *  4-1 简单的查询语句
         *  4-2 带where的查询
         *  4-3 简单的函数计算（count，min，max，sum）
         *  4-4 排序order by desc/asc
         *  4-5 top(1)
         *  4-6 跳过前N条取余下的数据 Skip
         *  4-7 截取指定长度的数据 Take
         *  4-8 分页查询： Skip、Take组合使用
         *  4-9 包含Contains ， 类似like '%%'
         *  4-10 分组group by
         *  4-11 Sql中的In -- 通过Contains实现
         *  4-12 内连接 Inner Join
         *  4-13 Linq和Lambda实现 左链接、右链接、内链接参考：
         *   *  4-13-1 先准备个数据类
             *  4-13-2 Linq：左连接、右连接、内连接
             *  4-13-3 Lambda：左连接、右连接、内连接 \[ 推荐使用上方Linq写法 \]
         *  4-14 扩展：交集、并集、差集的用法 \[了解，使用不多\]
         *   *  4-14-1 简单类型的交集、并集、差集用法：
             *  4-14-2 对象类型：List<XxxModel>的交集、并集、差集用法
             *   *  4-14-2-1 先定义Model
                 *  4-14-2-2 定义Model间如何比较
                 *  4-14-2-3 实例代码参考：
         *  4-15 一些使用的实例代码：

## C\#中Linq和Lambda表达式的使用整理 ##

**扩展**：  
**可以使用 var 让编译器的“类型推断”来简化类型的声明，  
在linq中常用 C\#的var ， 和javaScript的var不一样，  
它仍然是强类型的！！！**

### 1. Linq和Lambda简介 ###

Linq: 
    	语言集成查询（ Language Integrated Query，缩写：Linq）,发音"link"，是微软的一项技术，新增一种自然查询的SQL语法到.NET Framework的编程语言中
    
    Lambda:
    	Lambda 表达式，是一种简化的匿名函数，可用于创建委托或表达式目录树。其次，也可以将 Lambda 表达式作为参数进行传递，或者将它作用于函数调用值调用后返回的一个函数来使用。经常在 Linq 中使用 Lambda 表达式

### 2. Lambda表达式 ###

1.  匿名方法可以写成Lambda表达式:
    Func<int, int, string> f1 = (i1,i2) =>{
        
        return $"{
          i1}+{
          i2}={
          i1 + i2}";
    };
    
    2.  可以省略参数数据类型，因为编译器根据委托类型推断出参数类型用=>引出来方法体
    	如果委托没有返回值，且方法体只有一行代码，可省略{
        }
    Action<int, string> f1 = (age, name) => Console.WriteLine($"年龄{
          age},姓名{
          name}");
    f1 (18, "yzk");
    
    3. 如果=>之后的方法体中只有一行代码，且方法有返回值，那么可以省略方法体的{
        }以及return
    Func<int, int, string> f1 = (i1, i2) => $"{
          i1}+{
          i2}={
          i1 + i2}";
    
    4. 如果只有一个参数，参数的()可以省略
    Action<string> f1 = s => Console.WriteLine(s);
    Func<int, bool> f2 = i => i > 5;
    
    5. 配合lambda能简化数据处理，如：Where
    int[] nums = new int[]
     {
         3,99,88,77,7,8,9,66,15,7};
    IEnumerable<int> items = nums.Where(i=>i>10);//using System.Linq;

### 3. Lambda常用的扩展方法 ###

#### 3-1 Where方法：筛选满足条件的数据 ####

where方法：	集合的每一项数据都会经过predicate的测试，
    			如果针对一个元素，predicate执行的返回值为true，
    			那么这个元素就会放到返回值中。
    			where参数是一个lambda表达式格式的匿名方法，
    			方法的参数e表示当前判断的元素对象。参数的名字可以自定义，如p,m等
    // 使用实例：			
    //1 Linq
    var ss = from r in db.Am_recProScheme
             where r.rpId > 10
             select r;
    //2 Lamba 
    var ss1 = db.Am_recProScheme.Where(p => p.rpId > 10);
    //3 等价的Sql
    string sssql = "select * from Am_recProScheme where rpid>10";

#### 3-2 Count()方法：获取数据条数 ####

// 直接使用count
    int count1 = list.Count(e => e.Salary > 5000 || e.Age < 30);
    // 先使用where再调用count
    int count2 = list.Where(e => e.Salary > 5000 || e.Age < 30).Count();

#### 3-3 Any()方法：是否至少有一条数据 ####

// 检查是否符存在符合条件的数据时，Any效率会高些  如：有可能比Count()实现效率高
    
    // 	直接使用Any
    bool b1 = list.Any(e => e.Salary > 8000);
    // 	先使用where再调用Any
    bool b2 = list.Where(e => e.Salary > 8000).Any();

#### 3-4 排序：OrderBy()、OrderByDescending()、ThenBy()、ThenByDescending() ####

order()对数据正序排序 
    orderByDescending()倒序排序 
    	对于简单类型排序，也许不用lambda表达式。
    	特殊案列：按照最后一个字符排序；
    	用Guid或者随机数进行排序 多规则排序：
    		可以在OrderBy()、OrderByDescending()后继续写ThenBy()、ThenByDescending() 
    
    案例：优先按照Age排序，如果Age相同再按照Salary排序
    list.OrderBy(e => e.Age).ThenByDescending(e => e.Salary)
    //  错误写法：  千万不要下方写法，会以最后一个进行排序的
    list.OrderBy(e => e.Age). OrderByDescending (e => e.Salary)

#### 3-5 限制结果集，取部分数据： 去重–groupby/distinct、 截取–skip(n)、Task(n) ####

【去重 groupby/distinct ==> 参考：】
    // Linq语法：
    // 		使用group关键字进行表数据去重
      var data= from a in db.orderInfo group p by new {
        a.orderTypeId} into _group select _group.FirstOrDefault(); 
    // 		使用group关键字对多个字段进行表数据去重
      var data= from a in db.orderInfo group p by new {
        a.orderTypeId,...} into _group select _group.FirstOrDefault(); 
    //  Lamda语法：
    //		单个去重：  	使用GroupBy关键字进行表数据去重
      var data=db.orderInfo.GroupBy(t=>t.orderTypeId).Select(r => r.First()).ToList(); 
    //						使用DistinctBy关键字进行表数据去重  
      var data=db.orderInfo.DistinctBy(t=>t.orderTypeId).ToList(); 
    //		多个字段去重： 	使用GroupBy关键字对多个字段进行表数据去重
      var data=db.orderInfo.GroupBy(t=>new{
        t.orderTypeId,...}).Select(r => r.First()).ToList(); 
    // 						使用DistinctBy关键字对多个字段进行表数据去重  
      var data=db.orderInfo.DistinctBy(t=>new{
        t.orderTypeId,...}).ToList(); 
      
    //  sql语法：
    //		使用DISTINCT关键字进行表数据去重
      string sqlStr="SELECT DISTINCT orderTypeId  FROM orderInfo";
    //		使用GROUP BY关键字进行表数据去重  
      string sqlStr="SELECT orderTypeId FROM orderInfo GROUP BY orderTypeId";
    
    
    【截取 skip/Task ==> 参考：】
    skip(n)跳过n条数据，
    Task(n)获取n条数据 
    	案例：获取从第2条开始获取3条数据
    var items = list.Skip(2).Take(3);

#### 3-6 聚合函数: Max()、Min()、Average()、Sum()、Count()等 ####

// 如取最小值：年龄>30岁中薪水最小的数据
    list.Where(e => e.Age > 30).Min(e=>e.Salary)

#### 3-7 分组 GroupBy() ####

返回值为IGrouping<TKey,TSource>类型的泛型IEnumerable,
    	每一组以一个IGrouping对象的形式返回。
    	IGrouping是一个继承自IEnumerable的接口，
    	IGrouping中Key属性表示这一组的分组数据的值。
    
    // 类似如下Sql的效果：
    //		string sql = "select recType,min(rpId) from Am_recProScheme group by recType";
    var ss = db.Am_recProScheme.GroupBy(p => p.recType);
    foreach (var t in ss )
    {
        
    	// t.Key==分组的字段(p.recType) , 
        Response.Write(t.Key + "--" + t.Min(p => p.rpId));
    }

#### 3-8 取首条记录 top(1) ####

// 如 取最后一个可以按倒叙排列再取值
    //		Linq写法
    var ss = (from r in db.Am_recProScheme
              select r).FirstOrDefault();
              
    //		Lambda写法
    var ss1 = db.Am_recProScheme.FirstOrDefault();

#### 3-9 投影 Select，类似Java中Steam的map/flatmap ####

效果： 把集合中的每一项转换为另外一种类型
    // 实例：
    IEnumerable<int> 	ages = list.Select(e => e.Age);
    IEnumerable<string> names = list.Select(e=>e.Gender?"男":"女");
    var dogs = list.Select(p=>new Dog{
        NickName=e.Name,Age=e.Age});
    
    // 匿名类型：
    var p  = new {
        Name="tom",Id=1};
    var p1 = new {
        name,Id=1,p.Age};
    
    var items = list.Select(e=>new {
        e.Name,e.Age,XingBie= e.Gender ? "男" : "女"});
    var items = list.GroupBy(e => e.Gender).Select(g=>new {
         Gender=g.Key,Count=g.Count(),AvgSalary= g.Average(e => e.Salary),MinAge= g.Min(e => e.Age)});

#### 3-10 链式调用 ####

集合转换：
    	有一些地方需要数组类型或者List类型的变量，
    	可以用ToArray()方法和ToList()， 分别把IEnumerable<T>，转换为Array和List<T>
    
    链式调用：
    	Where、Select、OrderBy、GroupBy、Task、Skip等返回值都是IEnumerable<T>类型，
    	所以可以链式调用

### 4. Linq和Lambda具体代码示例参考： ###

#### 4-1 简单的查询语句 ####

// Linq语法：
      var data=from a in db.Areas select a ;
    // Lamda语法：
      var data=db.Areas;
    // sql语法：
      string sqlStr=" SELECT * FROM Areas  ";

#### 4-2 带where的查询 ####

// Linq语法：
      var data=from a in db.orderInfo where a.orderId > 20 select a ;
    // Lamda语法：
      var data=db.orderInfo.Where( t=>t.orderId > 20 ) ;
    // sql语法：
      string sqlStr=" SELECT * FROM orderInfo WHERE orderId > 20 ";

#### 4-3 简单的函数计算（count，min，max，sum） ####

// Linq语法：
      var data=( from a in db.orderInfo select a ).Max( p=>p.orderId ) ;//查询该表中最大编号Id
      var data=( from a in db.orderInfo select a ).Min( p=>p.orderId ) ;//查询该表中最小编号Id
      var data=( from a in db.orderInfo select a ).Count() ;//查询该表数据总条数
      var data=( from a in db.orderInfo select a ).Sum( p=>p.orderMoney ) ;//查询该表中所有消费额的总数（求和）
      
    // Lamda语法：
      var data=db.orderInfo.Max( t=>t.orderId );//查询该表中最大编号Id
      var data=db.orderInfo.Min( t=>t.orderId );//查询该表中最小编号Id
      var data=db.orderInfo.Count();//查询该表数据总条数
      var data=db.orderInfo.Sum( t=>t.orderMoney );//查询该表中所有消费额的总数（求和）
      
    // sql语法：
      string sqlStr=" SELECT MAX(orderId) FROM orderInfo ";
      string sqlStr=" SELECT MIN(orderId) FROM orderInfo ";
      string sqlStr=" SELECT COUNT(*) FROM orderInfo ";
      string sqlStr=" SELECT SUM(orderMoney ) FROM orderInfo ";

#### 4-4 排序order by desc/asc ####

// Linq语法：
      var data=from a in db.orderInfo where a.orderId > 20 orderby a.orderId descending select a ;//倒序排序，升序可用ascending关键字
      
    // Lamda语法：
      // 情况一，根据单字段排序： OrderByDescending
      var data=db.orderInfo.OrderByDescending( t=>t.orderId ).Where( t=>t.orderId > 20 ) .ToList();// 升序可用OrderBy关键字
      // 情况二，根据多字段主次排序：OrderBy == ThenBy
      var priceMonthEntities = priceMonthApp.GetList().OrderBy(t => t.F_Year).ThenBy(t => t.F_Month).ToList();//先按年升序，再按月升序
      
    // sql语法：
      string sqlStr=" SELECT * FROM orderInfo WHERE orderId > 20 ORDER BY orderId DESC  ";//倒序排序，升序可用ASC关键字

#### 4-5 top(1) ####

// Linq语法：  取集合中第一个记录
    var ss = (from r in db.Am_recProScheme
              select r).FirstOrDefault();
    // Lamda语法： 
    var ss1 = db.Am_recProScheme.FirstOrDefault();
    //var ss1 = db.Am_recProScheme.First();   
    // Sql语法：       
    string sssql = "select top(1) * from Am_recProScheme";
    
    
    //	取最后一个记录，先倒序排列再取值 ，实例如下：
    lists.Reverse();  // 先对集合进行倒序
    var s2 = lists.FirstOrDefault();
    MessageBox.Show(s2.ToString());

#### 4-6 跳过前N条取余下的数据 Skip ####

//1 Linq语法：
    var ss = (from r in db.Am_recProScheme
              orderby r.rpId descending
              select r).Skip(10); //跳过前10条数据，取10条之后的所有数据   
    //2 Lamda语法：  
    var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Skip(10).ToList();
    //3 Sql语法：
    string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10";

#### 4-7 截取指定长度的数据 Take ####

//1 Linq语法：
    var ss = (from r in db.Am_recProScheme
              orderby r.rpId descending
              select r).Take(10); // 截取前10条数据  
    //2 Lamda语法：  
    var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Take(10).ToList();
    //3 Sql语法：
    string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum<=10";

#### 4-8 分页查询： Skip、Take组合使用 ####

【参考1：】
    // Linq语法：
      var data=( from a in db.orderInfo select a ) .Skip((pageIndex-1) * pageSize).Take(pageSize).ToList();
    // Lamda语法： pageIndex:当前页码，pageSize：分页数据显示条数
      var data=db.orderInfo.Skip((pageIndex-1)* pageSize).Take(pageSize).ToList();  
    // sql语法：
      string sqlStr="SELECT TOP pageSize * FROM orderInfo WHERE orderId NOT IN(SELECT TOP( ( pageIndex - 1) * pageSize) orderId FROM orderInfo)";
    
    【参考2：】
    // 1 Linq语法：
    var ss = (from r in db.Am_recProScheme
              where r.rpId > 10
              orderby r.rpId descending
              select r).Skip(10).Take(10); //取第11条到第20条数据
              
    //2 Lamda语法：   Take(10): 数据从开始获取，获取指定数量（10）的连续数据
    var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Where(p => p.rpId > 10).Skip(10).Take(10).ToList();
    //3 Sql语法：
    string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10 and rowNum<=20";

#### 4-9 包含Contains ， 类似like ‘%%’ ####

// Linq语法：  使用Contains关键字进行模糊匹配
      var data= from a in db.orderInfo where a.orderId.Contains(1) select a;
    // Lamda语法：  使用Contains关键字进行模糊匹配
      var data=db.orderInfo.Where(t=>t.F_UserId.Contains("1")).ToList();
    // sql语法：   使用like关键字进行模糊匹配
      string sqlStr="SELECT * FROM orderInfo WHERE orderId LIKE '%12%'";

#### 4-10 分组group by ####

【参考1：】
    // Linq语法：
      var data= from a in db.orderInfo orderby a.orderId descending 
                group a by a.orderType into s select new{
        
                s.key,//分组字段
                s.sMoney=s.Sum(a=>a.orderMoney),//分组后算出总的消费额
                s.maMoney=s.Max(a=>a.orderMoney),//分组后算出最大的消费额
                s.miMoney=s.Min(a=>a.orderMoney)//分组后算出最小的消费额
                };
    // Lamda语法：
      //使用GroupBy关键字进行分组查询（单个字段）
      var data=db.orderInfo.GroupBy(p => p.recType).Select(t=>t.Key).ToList();
      //使用GroupBy关键字进行分组查询（多个字段）
      var data=db.orderInfo.GroupBy(p =>new{
         p.recType,p.orderId}).Select(t=>new{
         recType=t.Key.recType,orderId=t.Key.orderId}).ToList();
      
    // sql语法：
      string sqlStr="SELECT orderType , SUM(orderMoney), MAX(orderMoney), MIN(orderMoney) FROM orderInfo GROUP BY orderType";
    
    
    【参考2】
    //1 Linq语法：
    var ss = from r in db.Am_recProScheme
             orderby r.rpId descending
             group r by r.recType into n
             select new
             {
        
                 n.Key,  //这个Key是recType
                 rpId = n.Sum(r => r.rpId), //组内rpId之和
                 MaxRpId = n.Max(r => r.rpId),//组内最大rpId
                 MinRpId = n.Min(r => r.rpId), //组内最小rpId
             };
    foreach (var t in ss)
    {
        
        Response.Write(t.Key + "--" + t.rpId + "--" + t.MaxRpId + "--" + t.MinRpId);
    }
    //2 Linq语法：
    var ss1 = from r in db.Am_recProScheme
             orderby r.rpId descending
             group r by r.recType into n
             select n;
    foreach (var t in ss1)
    {
        
        Response.Write(t.Key + "--" + t.Min(p => p.rpId));
    }
    //3 Lamda语法：
    var ss2 = db.Am_recProScheme.GroupBy(p => p.recType);
    foreach (var t in ss2)
    {
        
        Response.Write(t.Key + "--" + t.Min(p => p.rpId));
    }
    //4 sql语法：
    string sssql = "select recType,min(rpId),max(rpId),sum(rpId) from Am_recProScheme group by recType";

#### 4-11 Sql中的In – 通过Contains实现 ####

【实例1：】
    // Linq语法：
      var data= from a in db.orderInfo where (new int?[2213,43311,32422]).Contains(a.orderId) select a ; 
    // Lamda语法：
      var data=db.orderInfo.Where(t=>(new int?[2213,43311,32422]).Contains(t.orderId)).ToList();
    // sql语法：
      string sqlStr="SELECT * FROM orderInfo WHERE orderId IN (2213,43311,32422)";
    
    【实例2：】
    // Linq语法：
    var ss = from p in db.Am_recProScheme
                      where (new int?[] {
         24, 25,26 }).Contains(p.rpId)
                      select p;
    foreach (var p in ss)
    {
        
        Response.Write(p.Sorts);
    }
    
    // sql语法：
    string st = "select * from Am_recProScheme where rpId in(24,25,26)";

#### 4-12 内连接 Inner Join ####

【参考1】
    // Linq语法：
    var ss = from r in db.Am_recProScheme
             join w in db.Am_Test_Result on r.rpId equals w.rsId
             orderby r.rpId descending
             select r;
    // Lamda语法：
    var ss1 = db.Am_recProScheme.Join(db.Am_Test_Result, p => p.rpId, r => r.rsId, (p, r) => p).OrderByDescending(p => p.rpId).ToList();
    // sql语法：
    string sssql = "SELECT r.* FROM Am_recProScheme AS r INNER JOIN Am_Test_Result AS t ON r.[rpId] = t.[rsId] ORDER BY r.[rpId] DESC";
    
    
    【参考2】
    //Linq
    var ss = from r in db.Am_recProScheme
             join w in db.Am_Test_Result on r.rpId equals w.rsId
             orderby r.rpId descending
             select r;
             
    //Lambda
    var ss1 = db.Am_recProScheme.Join(db.Am_Test_Result, p => p.rpId, r => r.rsId, (p, r) => p).OrderByDescending(p => p.rpId).ToList();
    
    //SQL
    string sssql = "select r.* from  [Am_recProScheme] as r inner join [dbo].[Am_Test_Result] as t on r.[rpId] = t.[rsId] order by r.[rpId] desc";

#### 4-13 Linq和Lambda实现 左链接、右链接、内链接参考： ####

##### 4-13-1 先准备个数据类 #####

//客户类
    public class Customer
        {
        
            public int id {
         get; set; }
            public string name {
         get; set; }
            public string email {
         get; set; }
        }
        //联系方式类
      public class CustomerContact
        {
        
            public int ccid {
         get; set; }
            public int CustomerId {
         get; set; }//客户的id，外键
            public string Phone {
         get; set; }
            public string Address {
         get; set; }
        }
       //模拟数据
               public static List<Customer> GetCustomer()//客户
            {
        
                List<Customer> list = new List<Customer>();
                list.Add(new Customer {
         id = 1, name = "刘德华",  email = "ldh@net.cn" });
                list.Add(new Customer {
         id = 2, name = "张学友",  email = "zxy@net.cn" });
                list.Add(new Customer {
         id = 3, name = "黎明",  email = "lm@net.cn" });
                list.Add(new Customer {
         id = 4, name = "郭富城",  email = "gfc@net.cn" });
                list.Add(new Customer {
         id = 4, name = "古天乐",  email = "gtl@net.cn" });
                return list;
            }
            public static List<CustomerContact> GetCustomerContact()//联系人
            {
        
                List<CustomerContact> list = new List<CustomerContact>();
                list.Add(new CustomerContact {
         ccid = 1,CustomerId=1, Phone="13566769988",Address="北京"});
                list.Add(new CustomerContact {
         ccid = 2, CustomerId = 1, Phone = "13566769986", Address = "天津" });
                list.Add(new CustomerContact {
         ccid = 3, CustomerId =2, Phone = "13677889900", Address = "香港" });
                list.Add(new CustomerContact {
         ccid = 4, CustomerId = 8, Phone = "13677889332", Address = "上海" });
                return list;
            }

##### 4-13-2 Linq：左连接、右连接、内连接 #####

// 1. 左连接
    var LeftJoin = from cusetomer in GetCustomer()
                    join cc in GetCustomerContact()
                    on cusetomer.id equals cc.CustomerId 
                    // 内连接的基础上， 加入这行代码就实现类左连接
                    into JoinCC from cc in JoinCC.DefaultIfEmpty()
                    select new
                    {
        
                        CustomerName = cusetomer.name,
                        phone = cc != null ? cc.Phone : null
                    };
    
    // 2. 右连接：
    // 		右链接跟左链接相反，只需要改一下顺序就可以了。
     var LightJoin = from cc in GetCustomerContact()
                     join cusetomer in GetCustomer()
                     on cc.CustomerId equals cusetomer.id 
                     // 内连接的基础上， 加入这行代码就实现类左连接
                     into JoinCC from cusetomer in JoinCC.DefaultIfEmpty()
                    select new
                    {
        
                        phone = cc.Phone,
                        CustomerName =cusetomer != null ? cusetomer.name : null,
                    };
    // 3. 内连接：
    var InnerJoin = from cc in GetCustomerContact()
                     join cusetomer in GetCustomer()
                     on cc.CustomerId equals cusetomer.id 
                     select new
                     {
        
                         phone = cc.Phone,
                         CustomerName = cusetomer.name
                     };
    // 3-2 内连接：  多个条件关联的join 
    var whiteDiagList = (from r1 in diagControlList
            where r1.ControlRelation == 1
            join r2 in args.DiagList on new {
         code = r1.DiagCode, name = r1.DiagName }
            equals new{
        code=r2.DiagCode,name=r2.DiagName}
            select r1).ToList<DiagControlModel>();

##### 4-13-3 Lambda：左连接、右连接、内连接 \[ 推荐使用上方Linq写法 \] #####

// 1. 左连接：
    var LMLeftJoin = GetCustomer().GroupJoin(GetCustomerContact(), 
     a => a.id, b => b.CustomerId, (a, b) =>new {
         a,b })
         .SelectMany(c=>c.b.DefaultIfEmpty(), (c, b) 
         =>new {
         CustomerName= c.a.name,Phone=b!=null?b.Phone:null });
    
    // 2. 右连接：参考左连接，两个集合对调位置就行了
    
    // 3. 内连接：
    var LMInnerJoin = GetCustomer().Join(GetCustomerContact(), a => a.id, b => b.CustomerId
    , (a, b) => new {
         CustomerName = a.name, Phone = b.Phone });

#### 4-14 扩展：交集、并集、差集的用法 \[了解，使用不多\] ####

##### 4-14-1 简单类型的交集、并集、差集用法： #####

List<string> ListA = new List<string>();
    List<string> ListB = new List<string>();
    List<string> ListResult = new List<string>();
    
    ListResult = ListA.Distinct().ToList();//去重
    ListResult = ListA.Except(ListB).ToList();//差集
    ListResult = ListA.Union(ListB).ToList();  //并集
    ListResult = ListA.Intersect(ListB).ToList();//交集

##### 4-14-2 对象类型：List的交集、并集、差集用法 #####

若上面的例子不是List类型，  
而是List，则需要对XXXModel进行处理。  
步骤如下：

###### 4-14-2-1 先定义Model ######

public class ItemModel
        {
        
            public string ItemCode {
         get; set; }
            public string ItemName {
         get; set; }
        }

###### 4-14-2-2 定义Model间如何比较 ######

说明： 若不定义，比较的是两个引用

public class ItemModelComparer : IEqualityComparer<ItemModel>
    {
        
            //比较
            public bool Equals(ItemModel x, ItemModel y)
            {
        
                bool checkFlag = true;
    
                if (Object.ReferenceEquals(x, y))
                {
        
                    checkFlag = true;
                }
                else if (Object.ReferenceEquals(x, null) || Object.ReferenceEquals(y, null))
                {
        
                    checkFlag = false;
                }
                else
                {
        
                    if (x.ItemCode == y.ItemCode) //若Model有多个条件则需要添加。例如 if(x.ItemCode==y.ItemCode && x.Other==y.Other)
                    {
        
                        checkFlag = true;
                    }
                    else
                    {
        
                        checkFlag = false;
                    }
                }
    
                return checkFlag;
    
            }
        
            //实现获取哈希值
            public int GetHashCode(ItemModel model)
            {
        
                if (Object.ReferenceEquals(model, null)) return 0;
                int hashNurse = model.ItemCode.GetHashCode(); 
    
    //			若两个集合有多个关联条件，则哈希值也需要进行计算
    //			int hashOther=model.Other.GetHashCode();
    //   		int resultHash=hashNurse^hashOther;
    //			return resultHash;
    
                return hashNurse;
            }
        
        }

###### 4-14-2-3 实例代码参考： ######

List<ItemModel> ListA = new List<ItemModel>();
    List<ItemModel> ListB = new List<ItemModel>();
    List<ItemModel> ListResult = new List<ItemModel>();
    
    ListResult = ListA.Distinct(new ItemModelComparer()).ToList();//去重
    ListResult = ListA.Except(ListB, new ItemModelComparer()).ToList();//差集
    ListResult = ListA.Union(ListB, new ItemModelComparer()).ToList();  //并集
    ListResult = ListA.Intersect(ListB, new ItemModelComparer()).ToList();//交集

#### 4-15 一些使用的实例代码： ####

//数据库 + 自定义名称 =new 数据库
    mydbDataContext con = new mydbDataContext();
    //模糊查询表达式中用.Contains
    con.car.Where(r=>r.name.Contains(TextBox1.Text.Trim())).ToList(）;
    //开头查用.StartWith
    con.car.Where(r => r.name.StartsWith(TextBox1.Text)).ToList();
    //结尾查用.EndWith
    con.car.Where(r => r.name.EndsWith(TextBox1.Text)).ToList();
    //最大值
    con.car.Max(r => r.price * r.oil).ToString();
    //最小值
    con.car.Min(r => r.price).ToString();
    //求和
    con.car.Sum(r => r.price).ToString();
    //平均值
    con.car.Average(r => r.price).ToString();
    //升序：
    con.car.OrderBy(r => r.price).ToList();
    //降序：
    con.car.OrderByDescending(r => r.price).ToList();
    
    //上一页，下一页，组合查询：
    int PageCount = 5;//每页显示条数
    //上一页，PageCount_Label.Text为当前页码
    int pageNum = Convert.ToInt32(PageCount_Label.Text) - 1;
    Repeater1.DataSource = con.car.Skip((pageNum - 1) * PageCount).Take(PageCount);
    Repeater1.DataBind(); 
    PageCount_Label.Text = pageNum.ToString();
    //下一页
    int pageNum = Convert.ToInt32(PageCount_Label.Text) + 1;
    Repeater1.DataSource = con.car.Skip((pageNum - 1) * PageCount).Take(PageCount);
    Repeater1.DataBind();
    PageCount_Label.Text = pageNum.ToString();
    //组合查询的点击事件
    List<car> list = con.car.ToList();
    if (TextBox2.Text != "")
    {
        
        List<car> list1 = con.car.Where(r => r.name.Contains(TextBox2.Text)).ToList();
        list = list.Intersect(list1).ToList();
    }
    if (TextBox3.Text != "")
    {
        
        List<car> list1 = con.car.Where(r => r.oil == Convert.ToDecimal(TextBox3.Text)).ToList();
        list = list.Intersect(list1).ToList();
    }
    if (TextBox4.Text != "")
    {
        
        List<car> list1 = con.car.Where(r => r.powers == Convert.ToInt32(TextBox4.Text)).ToList();
        list = list.Intersect(list1).ToList();
    }
    Repeater1.DataSource = list;
    Repeater1.DataBind();