LINQ 常规实践总结

1.Linq 执行多列排序

OrderBy的意义是按照指定顺序排序，连续两次OrderBy，后面一个有可能会打乱前面一个的排序顺序，可能与预期不符。

要实现sql中的order by word,name类似效果; LINQ 有ThenBy可以紧接使用， ThenBy记住原本排序的值，然后再排其他值，正因如此，ThenBy是针对IOrderEnumerable 进行调用的。

2. Linq主外键连接查询

group join操作符常用于返回‘主键对象-外键对象集合’的查询，例如‘产品类别-此类别下所有的产品’的模式。

  // 查询语法 var query =        from c in db.Categories        join p in db.Products on c.CategoryID equals p.CategoryID into r        select  new        {            c.CategoryName,            Products = r        }; // 方法语法 var q =        db.Categories        .GroupJoin        (           db.Products,           c => c.CategoryID,           p => p.CategoryID,           (c, p) => new           {               c.CategoryName,               Products = p           }        );  这样就可以结合 DefaultIfEmpty 理解 left outer join的linq写法。

group join生成的sql接近于：

select Categories.*, Products.* from Categoriesleft join Products on  Categories.Id = Products.CateIdorder by Categories.Id  // group join 有点类似于 left join 数据膨胀的效果

https://docs.microsoft.com/en-us/dotnet/csharp/linq/perform-grouped-joins

3.linq2sql 指定形成sql左右连接

linq2sql join语法默认得到的是inner join

 Model1Container model = new Model1Container();            //内连接            var query = from s in model.Student                        join c in model.Course on s.CourseCno equals c.Cno                        select new                        {                            ClassID = s.CourseCno,                            ClassName = c.Cname,                            Student = new                            {                                Name = s.Sname,                                ID = s.Sno                            }                        };    foreach (var item in query)    {        Response.Write("ClassID:" + item.ClassID + "ClassName:" + item.ClassName + "Name:" + item.Student.Name);    }

在sql profile里面监控到与上面Linq2sql 对应的sql是

SELECT [t0].[CourseCno] AS [ClassID], [t1].[Cname] AS [ClassName], [t0].[Sname] AS [Name], [t0].[Sno] AS [ID]FROM [Student] AS [t0]INNER JOIN [Course] AS [t1] ON [t0].[CourseCno] = [t1].[Cno]WHERE [t1].[Cno] = @p0

linq2sql 左连接

Model1Container model = new Model1Container();            var query = from s in model.Student                        join c in model.Course on s.CourseCno equals c.Cno into gc                        from gci in gc.DefaultIfEmpty()                        select new                        {                            ClassID = s.CourseCno,                            ClassName = gci ==null ?String.Empty: gci.Cname,                            Student = new                            {                                Name = s.Sname,                                ID = s.Sno                            }                        };    //Outer join时必须将join后的表into到一个新的变量gc中，然后要用gc.DefaultIfEmpty()表示外连接(没有匹配的记录字段设为NULL)    foreach (var item in query)    {        Response.Write("ClassID:" + item.ClassID + "ClassName:" + item.ClassName + "Name:" + item.Student.Name);    }   // 上例中使用了DefaultIfEmpty操作符，它能够为Empty序列(注意是Empty序列而不是Null序列)返回一个默认元素序列，DefaultIfEmpty使用了泛型中的default关键字。    gc.DefaultIfEmpty(new Course { Cname = "",Cperiod="" } )    //设置为空时的默认值

与以上Linq2sql对应的sql 是

SELECT [t0].[CourseCno] AS [ClassID], [t1].[Cname] AS [ClassName], [t0].[Sname] AS [Name], [t0].[Sno] AS [ID]FROM [Student] AS [t0]LEFT OUTER JOIN [Course] AS [t1] ON [t0].[CourseCno] = [t1].[Cno]

https://docs.microsoft.com/en-us/dotnet/csharp/linq/perform-left-outer-joins

4. 忽略Linq 检索某元素异常

在日常Linq实践中，按照某种预期写定的Linq，在执行检索时某些元素会爆出异常，导致整个检索失败；如果我们能容忍某些元素的异常，继续完成整个Linq检索，可以写一个扩展方法，忽略报错元素。

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace Enumerable {    public static class EnumerableExtension {        /// <summary>        /// 在IEnumerable<T> 循环或者变为内存序列之前 忽略掉序列中存在的元素异常        /// </summary>        /// <typeparam name="T"></typeparam>        /// <param name="values"></param>        /// <returns></returns>        public static IEnumerable<T> SkipException<T> (this IEnumerable<T> values) {            using(var enumerator = values.GetEnumerator()) {                var next = true;                while(next) {                    try{                        // 如果枚举器成功推进到下一个元素，MoveNext为true；枚举数越过集合结尾，则为false，也就是说返回值只确定后续是否有值                        next = enumerator.MoveNext();                    } catch{                        // catch到异常，忽略当前元素，继续循环                        LogHelper.Write("cause exception", LogHelper.LogMessageType.Error);                        continue;                    }                    // yield 返回枚举器指向的当前元素                    if(next)                        yield  return enumerator.Current;                }            }        }    }}

这个扩展方法的思路是重写foreach语法糖的默认逻辑：

能够使用foreach语法的序列必定实现IEnumerable接口，此处我们重写了该接口的默认迭代器使用方式。

作者：Julian_酱

感谢您的认真阅读，如有问题请大胆斧正，如果您觉得本文对你有用，不妨右下角点个或加关注。