.NET进阶篇-Linq、Lambda表达式

知识需要不断积累、总结和沉淀，思考和写作是成长的催化剂

内容目录

一、Lambda表达式1、匿名方法2、Lambda表达式二、Linq概述三、查询操作符1、linq初见2、常用查询操作符筛选排序分组连接合并分页聚合转换四、并行Linq五、表达式树1、认识表达式目录树2、拼装表达式树3、应用六、小结

一、Lambda表达式

1、匿名方法

使用delegate的时候很多时候没必要使用一个普通方法，因为这个方法只有delegate会用，并且只用一次，这时候使用匿名方法最合适。
匿名方法就是没有名字的方法。示例中就是用一个匿名方法创建委托实例，我们无需在写一个具名方法给委托，使代码更简洁和可读。匿名方法也是在调用时执行，在myDele(1,"test")处调用。（用反编译器看一下还是会生成一个具名方法的，只不过在编译器内部使用）。

delegate bool MyDelegate(int i, string s);
MyDelegate myDele = delegate (int i, string s)
{
    Console.WriteLine($"我是匿名方法，参数值{i}，{s}");
    return true;
};
bool b = myDele(1, "test");

2、Lambda表达式

函数式编程，在C#3.0开始，我们有了Lambda表达式代替匿名方法，它比匿名方法更加简单。Lambda运算符“=>”（发音goesto）的左边列出了需要的参数，右边是利用该参数方法的实现代码。

Action<string> a1 = delegate (string s) { Console.WriteLine(s); };
a1("匿名方法");
Action<string> a2 =  (string s)=> { Console.WriteLine(s); };
a1("Lambda表达式");
Action<string> a3 = s => { Console.WriteLine(s); };
a3("Lambda表达式，有一个参数的可以简写不要小括号，参数类型会自动推断");
Action<string> a4 = s =>  Console.WriteLine(s);
a4("Lambda表达式，方法体只有一行，连花括号也可以省略");

另一点，通过Lambda表达式可以访问Lambda表达式块外部的变量。这是一个非常好的功能，但如果未正确使用，也会非常危险。

int sommVal = 5;
Func<int, int> f = x => x + sommVal;

sommVal = 7;
Console.WriteLine(f(3));

如果外部修改了sommVol值就会影响Lambda表达式的输出，特别是在多线程中，可能无法确定当前的sommVal值。
Lambad表达式内部是如何使用外部的变量呢？首先编译器会创建一个匿名类，然后将使用到的外部变量当做匿名类的构造函数的参数，当调用时候，就创建匿名类的一个实例，并传递调用该方法时外部变量的值。

二、Linq概述

Linq（language integrated query）语言集成查询集成了C#编程语言中的查询语法，使之可以使用相同的语法访问不同的数据源。
根据数据源的不同，Linq可分为linq to object，linq to sql，linq to xml，你也可以扩展linq to excel，to everything。为不同的数据源提供相同的查询接口即可。

三、查询操作符

1、linq初见

现在我们有如下实体的集合

public class Student
{
    public int Id { get; set; }
    public int ClassId { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}
List<Student> studentLst = new List<Student>();

假设studentLst里已经有一些数据，然后需要查询出年纪小于25的学生。有很多方法，可以循环列表挑出age<25的学生，可以使用List的FindAll，Where等方法，看起来像下面这样（注意只有在访问list中数据时，才会去执行过滤条件查询，延迟查询）

var list = studentLst.Where<Student>(s => s.Age < 25); 
foreach (var item in list)
{
    Console.WriteLine("Name={0}  Age={1}", item.Name, item.Age);
}

where扩展方法的内部逻辑大概像这样，foreach循环调用过滤的委托方法，yield关键字语法糖包装了一些复杂行为，包括会初始化一个IEnumerable类，然后给添加内容。

public static IEnumerable<T> Where<T>(this IEnumerable<T> source, Func<T, bool> func)
{
    if (source == null)
    {
        throw new Exception("source is null");
    }
    if (func == null)
    {
        throw new Exception("func is null");
    }

    foreach (var item in source)
    {
        if (func.Invoke(item))
        {
            yield return item;
        }
    }
}

那么用Linq如何查询呢？

var list = from s in studentList
           where s.Age < 25
           select s;

foreach (var item in list)
{
    Console.WriteLine("Name={0}  Age={1}", item.Name, item.Age);
}

From、where、select都是预定义的关键字，查询表达式必须以from开头，以select或group子句结束，中间可以使用where、orderby、join等。from子句引入数据源studentList和范围变量s，s就像foreach循环中的迭代变量。
同样的，在运行期间定义查询表达式时，查询不会立即运行，在迭代数据项时运行。

2、常用查询操作符

筛选

最常见的查询操作就是以布尔表达式的形式应用筛选器。通过where子句筛选表达式为true的结果

var list = from s in studentList
           where s.Age < 25 && s.ClassId==1
           select s;

排序

Orderby子句根据要排序类型的默认比较器，对返回序列中的元素进行排序

var list = from s in studentList
           where s.Age < 25
           orderby s.Name ascending
           select s;

和list的以下方法类似，就是把关键字解析为方法，随着查询越来越复杂，linq这种类似sql语句就表现的更加简洁直观

var list = studentList.Where(s => s.Age < 25).OrderByDescending(s => s.Name).Select(s => s);

分组

group 子句用于对根据您指定的键所获得的结果进行分组。示例中into关键字创建进一步查询的标识，用select子句创建了一个带key和maxAge属性的匿名类型，返回每个班级中年龄小于25岁的最大年龄。

var list = from s in studentList
           where s.Age < 25
           group s by s.ClassId into sg
           select new
           {
               key = sg.Key,
               maxAge = sg.Max(t => t.Age)
           };
foreach (var item in list)
{
    Console.WriteLine($"key={item.key}  maxAge={item.maxAge}");
}

连接

使用join子句可以根据特性的条件合并两个数据源。例如通过连接查询选择相同课程的学生

List<Class> classList = new List<Class>(){
        new Class()
        {
            Id=1,
            ClassName="高数"
        },
        new Class()
        {
            Id=2,
            ClassName="毛概"
        }
};
var list = from s in studentList
           join c in classList on s.ClassId equals c.Id
           select new
           {
               Name = s.Name,
               CalssName = c.ClassName
           };
foreach (var item in list)
{
    Console.WriteLine($"Name={item.Name},CalssName={item.CalssName}");
}

合并

zip方法是.NET4新增的，允许用一个函数把两个序列合并为一个。第一个集合中的第一项会与第二个集合中的第一项合并，第一个集合中的第二项与第二个集合中的第二项合并，以此类推。如果两个集合的项目不同，zip方法就在到达较小集合的末尾时停止。

var list = from s in studentList
           where s.Age < 25
           select s;
var list2 = from s in studentList
            where s.Age < 25
            select s;
var lst = list.Zip(list2, (first, second) => first.Name + "," + second.Name);

分页

扩展方法Take()和Skip()等的分区操作用于分页。使用时把扩展方法take、skip添加到查询的最后，skip方法会忽略根据页面大小和实际页数计算出的项数，再使用take方法根据页面大小提取一定数量的项

int pageSize = 5;
int pageIdx = 0;
var list = (from s in studentList
            where s.Age < 25
            select s).Skip(pageIdx * pageSize).Take(pageSize);

聚合

聚合操作符Count()，Sum()，Min()，Average()等不返回一个序列，而返回一个值。

转换

Linq不只是检索数据。 它也是用于转换数据的强大工具。 通过使用 LINQ 查询，可以使用源序列作为输入，并通过多种方式对其进行修改，以创建新的输出序列。 通过排序和分组，你可以修改序列本身，而无需修改这些元素本身。 但也许 LINQ 查询最强大的功能是创建新类型。
以下示例将内存中数据结构中的对象转换为 XML 元素。

var studentsToXML = new XElement("Root",
            from student in studentList
            select new 
            XElement("student",
                    new XElement("name", student.Name),
                    new XElement("age", student.Age)
    )
);
Console.WriteLine(studentsToXML);

四、并行Linq

.NET4在System.Linq名称空间中包含了一个新类ParallelEnumerable，可以分解查询的工作使其分布在多个线程上。集合序列会分成多个部分，不同的线程处理，完成后合并。这对大集合，又是多核CPU的可以提高效率

var list = (from s in studentList.AsParallel()
           where s.Age < 25
           select s.Age).Sum();
var list2 = (from s in Partitioner.Create(studentList,true).AsParallel().WithDegreeOfParallelism(8)
            where s.Age < 25
            select s.Age).Sum();

可以使用Partitioner类创建分区器，WithDegreeOfParallelism指定最大并行任务数。
并行linq往往需要较多耗时使用，那应该也有取消长时间运行的任务需求。给查询添加一个WithCancellation方法，并传递一个CancellationToken令牌作为参数。该查询在单独线程中使用，主线程中触发取消命令。

var cts = new CancellationTokenSource();
new Thread(()=>
    {
        try
        {
            var sum= (from s in studentList.AsParallel().WithCancellation(cts.Token)
                      where s.Age < 25
                      select s.Age).Sum();
        }
        catch (OperationCanceledException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
).Start();
//外部动作触发取消
cts.Cancel();

五、表达式树

1、认识表达式目录树

出现在System.Linq.Expression中，就是为Linq to sql服务的。表达式树以树形数据结构表示代码，其中每一个节点都是一种表达式。它可以将我们原来直接由代码编写的逻辑存储在一个树状的结构里，然后运行的时候就去动态解析这个树。lambda表达式声明表达式目录树可以像下面这样。

Func<int, int, int> func = (m, n) => m * n + 2;// new Func<int, int, int>((m, n) => m * n + 2);
Expression<Func<int, int, int>> exp = (m, n) => m * n + 2;//lambda表达式声明表达式目录树
//Expression<Func<int, int, int>> exp1 = (m, n) =>//只能一行 不能有大括号
//    {
//        return m * n + 2;
//    };
//Queryable    //a=>a.Id>3

//表达式目录树：语法树，或者说是一种数据结构;可以被我们解析
int iResult1 = func.Invoke(12, 23);
int iResult2 = exp.Compile().Invoke(12, 23);

2、拼装表达式树

如果使用Expression类接口声明看起来会像下面这样，注意比较Lambda表达式声明和Expression类自己拼装声明的区别，最后都是需要Compile()编译后执行。

Expression<Func<int, int, int>> exp = (m, n) => m * n + 2;
ParameterExpression parameterExpression = Expression.Parameter(typeof(int), "m");
ParameterExpression parameterExpression2 = Expression.Parameter(typeof(int), "n");
var multiply = Expression.Multiply(parameterExpression, parameterExpression2);
var constant = Expression.Constant(2, typeof(int));
var add = Expression.Add(multiply, constant);

Expression<Func<int, int, int>> expression =
    Expression.Lambda<Func<int, int, int>>(
        add,
        new ParameterExpression[]
        {
             parameterExpression,
             parameterExpression2
        });

int iResult1 = exp.Compile().Invoke(11, 12);
int iResult2 = expression.Compile().Invoke(11, 12);

表达式树是由表达式的主体body、表达式的参数parameters、表达式类型Type、返回类型NodeType组成。一个树可能有很多叶子节点，复杂一点的例子像下面这样

//i*j+w*x
ParameterExpression a = Expression.Parameter(typeof(int), "i");   //创建一个表达式树中的参数，作为一个节点，这里是最下层的节点
ParameterExpression b = Expression.Parameter(typeof(int), "j");
BinaryExpression r1 = Expression.Multiply(a, b);    //这里i*j,生成表达式树中的一个节点，比上面节点高一级

ParameterExpression c = Expression.Parameter(typeof(int), "w");
ParameterExpression d = Expression.Parameter(typeof(int), "x");
BinaryExpression r2 = Expression.Multiply(c, d);

BinaryExpression result = Expression.Add(r1, r2);   //运算两个中级节点，产生终结点

Expression<Func<int, int, int, int, int>> lambda = Expression.Lambda<Func<int, int, int, int, int>>(result, a, b, c, d);

Console.WriteLine(lambda + "");   //输出‘(i,j,w,x)=>((i*j)+(w*x))’，z对应参数b，p对应参数a

Func<int, int, int, int, int> f = lambda.Compile();  //将表达式树描述的lambda表达式，编译为可执行代码，并生成该lambda表达式的委托；

Console.WriteLine(f(1, 1, 1, 1) + "");  //输出结果2

上面例子形成的表达式树就像下面这样。

3、应用

最常用的地方还是查询数据时。以往我们做一个查询，根据用户输入，去数据库中查询匹配的信息，可能去想到去拼一条带where条件的sql语句，然后去执行这条sql即可。
如果无法确定需要查询的字段，当每换一个查询条件或组合多个查询条件，我们可以用表达式目录树动态的拼装起来。

还可以用来代替反射，我们知道反射有性能问题，硬编码是最快的，但不够灵活。像泛型一样，表达式树可以动态生成硬编码，缓存后以后访问调用就相当于硬编码性能。比如示例中，我们如果需要对一个类型对象转换成另一个对象。这里可以有很多方法，硬编码、反射、序列化等都可以实现，现在我们用表达式树试一下。

People people = new People()
{
    Id = 11,
    Name = "Wang",
    Age = 31
};
PeopleCopy peopleCopy = new PeopleCopy()
{
    Id = people.Id,
    Name = people.Name,
    Age = people.Age
};

硬编码像上面这样，我们用表达式目录树就是为了能够生成这种硬编码的委托。

public class ExpressionMapper
{
    private static Dictionary<string, object> _Dic = new Dictionary<string, object>();

    /// <summary>
    /// 字典缓存表达式树
    /// </summary>
    /// <typeparam name="TIn"></typeparam>
    /// <typeparam name="TOut"></typeparam>
    /// <param name="tIn"></param>
    /// <returns></returns>
    public static TOut Trans<TIn, TOut>(TIn tIn)
    {
        string key = string.Format("funckey_{0}_{1}", typeof(TIn).FullName, typeof(TOut).FullName);
        if (!_Dic.ContainsKey(key))
        {
            ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
            List<MemberBinding> memberBindingList = new List<MemberBinding>();
            foreach (var item in typeof(TOut).GetProperties())
            {
                MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name));
                MemberBinding memberBinding = Expression.Bind(item, property);
                memberBindingList.Add(memberBinding);
            }
            foreach (var item in typeof(TOut).GetFields())
            {
                MemberExpression property = Expression.Field(parameterExpression, typeof(TIn).GetField(item.Name));
                MemberBinding memberBinding = Expression.Bind(item, property);
                memberBindingList.Add(memberBinding);
            }
            MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray());
            Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[]
            {
                parameterExpression
            });
            Func<TIn, TOut> func = lambda.Compile();//拼装是一次性的
            _Dic[key] = func;
        }
        return ((Func<TIn, TOut>)_Dic[key]).Invoke(tIn);
    }
}
var result = ExpressionMapper.Trans<People, PeopleCopy>(people);

表达式和表达式树什么关系呢？首先表达式是匿名方法生成委托实例，而表达式树是一种数据结构，本身不能执行的，需要编译成sql，然后解释执行表达式树中每个节点的表达式。

六、小结

本章认识了Lambda表达式，linq查询以及相关的常用操作符，它们不仅用于筛选数据源，给数据源排序，还用于执行分区，分组，转换，连接等操作，使用并行linq可以提高大型数据集的查询效率。另一个重要概念就是表达式目录树。表达式目录树允许在运行期间构建对数据源的查询，存储在程序集中，主要用在linq to sql中，后面学习EntityFramework框架时会用到大量的表达式目录树。

 

 

debug everything

愿一觉醒来，阳光正好

而不是，一觉醒来，天都黑了

*************转摘：https://www.cnblogs.com/xibei/p/11787730.html#h-10