Lambda表达式和Lambda表达式树

LINQ的基本功能就是创建操作管道，以及这些操作需要的任何状态。

为了富有效率的使用数据库和其他查询引擎，我们需要一种不同的方式表示管道中的各个操作。即把代码当作可在编程中进行检查的数据。

Lambda表达式不仅可以用他们创建委托实例，而且C#编译器也能将他们转换成表达式树——用于表示Lambda表达式逻辑的一种数据结构。简言之——Lambda表达式用符号语言习惯的方法来表示LINQ数据管线中的操作。

作为委托的Lambda表达式

Lambda有特殊转换规则：表达式的类型本身并非委托类型，但它可以通过多种方式隐式或显示的转换成一个委托实例。

匿名函数这个术语同时涵盖了匿名方法和Lambda表达式

转换成Lambda表达式

#region 9-1用匿名方法来创建委托实例

Func<string, int> returnLength;//等价public delegate int SomeDelegate(string arg1)。当返回void时，使用Action<>系列委托

returnLength = delegate(string text) { return text.Length; };

Console.WriteLine(returnLength("Holle"));

#endregion

#region 9-2冗长的第一个Lambda表达式

Func<string, int> returnLength;

returnLength = (string text) => { return text.Length; };

returnLength = (string text) => text.Length;//用单一表达式做为主体

returnLength = (text) => text.Length;//隐式类型的参数列表

returnLength = text => text.Length;//单一参数的快捷语法

Console.WriteLine(returnLength("Holle"));

#endregion

匿名方法中控制返回语句的规则同样不适用于Lambda表达式：不能从Lambda表达式返回void类型，如果有一个非void的返回类型，那么每个代码路径都必须返回一个兼容值。

Lambda表达式的主体可以包含另一个Lambda表达式，表达式参数可以是另一个委托。

使用List<T>和事件的简单例子

#region 9-4用Lambda处理一个电影列表

var films = new List<Film>

{

new Film{Name="Jaws1",Year=1975},

new Film{Name="Jaws2",Year=1975},

new Film{Name="Jaws5",Year=1975},

new Film{Name="Jaws4",Year=1976},

};

Action<Film> print = film => Console.WriteLine("Name={0},Year={1}", film.Name, film.Year);

 

films.ForEach(print);//打印全部元素

 

films.FindAll(film => film.Year > 1975).ForEach(print);//过滤打印

 

films.Sort((f1, f2) => f1.Name.CompareTo(f2.Name));//排序打印

films.ForEach(print);

 

#endregion

在事件处理程序中进行记录

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

Button button = new Button { Text = "Click me" };

button.Click += (src, e) => Log("Click", src, e);

button.KeyPress += (src, e) => Log("KeyPress", src, e);

button.MouseClick+=(src,e)=>Log("MouseClick",src,e);

 

Form form = new Form { AutoSize = true, Controls = { button } };

Application.Run(form);

}

 

static void Log(string title, object sender, EventArgs e)

{

Console.WriteLine("Event:{0}", title);

Console.WriteLine("Sender:{0}", sender);

Console.WriteLine("Argument:{0}", e);

foreach (PropertyDescriptor prop in TypeDescriptor.GetProperties(e))

{

string name = prop.DisplayName;

object value = prop.GetValue(e);

Console.WriteLine(" {0}={1}", name, value);

}

}

static void Log(string title, object sender)

{

Console.WriteLine("Event:{0}", title);

Console.WriteLine("Sender:{0}", sender);

 

}

}

表达式树

表达式树是对象构成的树，树中每个节点本身都是一个表达式。不同的表达式类型代表能在代码中执行的不通操作：二元操作（加法）一元操作（获取一个数字长度），方法调用，构造函数等。

Expressions命名空间代表表达式各个类，它们都继承至Expressions

Expressions类两个属性：

• Type属性代表表达式求值后的.NET类型
• NodeType属性返回所代表的表达式种类

#region 9-6一个非常简单的表达式树

//System.Linq.Expressions命名空间包含了代表表达式的各个类，他们都继承至Expression

Expression firstArg = Expression.Constant(2);

Expression secondArg = Expression.Constant(3);

Expression add = Expression.Add(firstArg, secondArg);

Console.WriteLine(add);

#endregion

“叶”表达式在代码中最先创建：你自下而上构建了这些表达式。这是由于“表达式不易变”这一事实决定的——创建好表达式后，它就永远不会改变。

                                                                                       表达式图形化表示

将表达式树编译成委托

LambdaExpression是从Expression派生的类型之一。泛型类Expression<TDelegate>又是从LambdaExpression派生的。

                  从Expression<TDelegate>上溯至Expression的层次结构

Expression和Expression<TDelegate>类区别在于，泛型类以静态类型的方法标识了它是什么种类的表达式，也就是说，它确定了返回类型和参数。

#region 9-7编译并执行一个表达式

Expression firstArg = Expression.Constant(2);

Expression secondArg = Expression.Constant(3);

Expression add = Expression.Add(firstArg, secondArg);

 

Func<int> compiled = Expression.Lambda<Func<int>>(add).Compile();

Console.WriteLine(compiled());

#endregion

将C#Lambda表达式转换成表达式树

Lambda表达式能隐式或显示的转换成恰当的委托实例。还可以要求编译器通过你的Lambda表达式构建一个表达式树，在执行时创建Expression<TDelegate>的一个实例。

#region 9-8用Lambda表达式转换成表达式树

Expression<Func<int>> return5 = () => 5;//Lambda表达式

Func<int> compiled1 = return5.Compile();

Console.WriteLine(compiled1());

#endregion

并非所有得Lambda表达式都能转换成表达式树。不能将带有一个语句块的Lambda转换成表达式树——只有对单个表达式进行求值的Lambda才可以。表达式中海不能包含赋值操作，在表达式树中表达不了这种操作。

#region 9-9演示一个更复杂的表达式树

Expression<Func<string, string, bool>> expression = (x, y) => x.StartsWith(y);

var compiled = expression.Compile();

 

Console.WriteLine(compiled("First", "Second"));

Console.WriteLine(compiled("First", "Fir"));

#endregion

#region 9-10用代码来构造一个方法调用表达式树

MethodInfo method = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });//获取方法名为StartsWith，参数为string的公共方法

var target = Expression.Parameter(typeof(string), "x");

var methodArg = Expression.Parameter(typeof(string), "y");

Expression[] methodArgs = new[] { methodArg };

 

//Call(Expression instance, MethodInfo method, params Expression[] arguments)

Expression call = Expression.Call(target, method, methodArgs);//x.StartsWith(y),以上部件创建CallExpression

 

var lambdaParameters = new[] { target, methodArg };//这里使用的参数顺序就是调用委托所使用的参数顺序

var lambda = Expression.Lambda<Func<string, string, bool>>(call, lambdaParameters);//(x,y)=>x.StartsWith(y),lambdaParameters填充call集合

var compiled = lambda.Compile();//生成lambda表达式的委托

 

Console.WriteLine(compiled("First", "csend"));

Console.WriteLine(compiled("First", "Fir"));

#endregion

 

位于LINQ核心的表达式树

Lambda表达式提供了编译时检查的能力，而表达式可以将执行模型从你所需要的逻辑中提取出来。进程外的LINQ提供器的中心思想在于，我们可以从一个熟悉的源语言（C#）生成一个表达式树，将结果作为一个中间格式，在将其转换成目标平台的本地语言（SQL）

类型推断和重载决策的改变

精简泛型方法调用

用一个Lambda表达式调用一个泛型方法，同时传递一个隐式类型的参数列表，编译器就必须推断出你想要的是什么类型，然后才能检查出Lambda表达式主体

#region 9-11 需要新的类型推断规则例子（用Lambda表达式调用一个泛型方法）

static void PrintConvertedValue<TInput, TOutput>(TInput input, Converter<TInput, TOutput> converter)

{

Console.WriteLine(converter(input));

}

#endregion

#region 9-11

PrintConvertedValue("I'm a string", x => x.Length);//C#2中，编译将失败，C#2类型推断单独针对每一个实参来进行的，从一个实参无法推断出另一个实参

#endregion

推断匿名函数的返回类型

#region 9-13根据一天当中的时间来选择返回int或object

delegate T MyFunc<T>();

 

static void WriteResult<T>(MyFunc<T> function)

{

Console.WriteLine(function());

}

#endregion

#region 9-13

WriteResult(delegate

{

if (DateTime.Now.Hour < 22)//int

{

return 10;

}

else//object

{

return new object();

}

});//编译器采用处理隐式数组的逻辑处理返回类型，对int进行了装箱，返回类型为object

#endregion

分两阶段进行类型推断

#region 9-14综合来自多个实参的信息，灵活地进行类型推断

static void PrintType<T>(T first, T second)//被强制转换为具体类型参数的最终固定变量类型

{

Console.WriteLine(typeof(T));

}

#endregion

#region 9-14

PrintType(1,new object());//返回类型推断为object类型

#endregion

类型推断分两阶段进行：第一阶段处理的是普通的实参，其类型是一开始便知道的，这包括那些参数列表是显示类型的匿名函数

第二阶段是推断隐式类型的Lambda表达式和方法组的类型，其思想是，根据以拼凑的信息，判断是否足够推断出Lambda表达式的参数类型。

#region 9-15多级类型推断

static void ConvertTwice<TInput, TMiddle, TOutput>(TInput input, Converter<TInput, TMiddle> firstConversion, Converter<TMiddle, TOutput> secondConversion)

{

TMiddle middle = firstConversion(input);

TOutput output = secondConversion(middle);

Console.WriteLine(output);

}

#endregion

#region 9-15

//第一阶段，编译器处理普通实参，得到TInput类型string，第一次执行阶段二，TInput固定为string类型，推断TMiddle为int，再次执行第二阶段，TMiddle固定为int，TOutput为double，推断结束

//lambda表达式主体只有在输入参数的类型已知后才能进行检查

ConvertTwice("Another string", text => text.Length, length => Math.Sqrt(length));

#endregion

选择正确的被重载方法

#region 9-16委托返回类型影响了重载选择

//如果一个匿名函数能转换成参数列表相同，但返回类型不同的两个委托类型，就根据从“推断的返回类型”到“委托的返回类型”的转换来判断哪个委托转换好

static void Execute(Func<int> action)

{

Console.WriteLine("action return an int:" + action());

}

static void Execute(Func<double> action)

{

Console.WriteLine("action return a douban:" + action());

}

#endregion

#region 9-16

Execute(() => 1);

#endregion