在C# 2.0中，通過方法組轉換和匿名方法，使委托的實現得到了極大的簡化。但是，匿名方法仍然有些臃腫，而且當代碼中充滿了匿名方法的時候，可讀性可能就會受到影響。C# 3.0中出現的Lambda表達式在不犧牲可讀性的前提下，進一步簡化了委托。
LINQ的基本功能就是創建操作管道，以及這些操作需要的任何狀態。這些操作表示了各種關於數據的邏輯，例如數據篩選，數據排序等等。通常這些操作都是用委托來表示。Lambda表達式是對LINQ數據操作的一種符合語言習慣的表示方式。
Lambda表達式不僅可以用來創建委托實例，C#編譯器也能夠將他們轉換成表達式樹。
下面我們就先看看Lambda表達式。
作為委托的Lambda表達式
Lambda表達式可以看作是C# 2.0的匿名方法的進一步演變，所以匿名方法能做的幾乎一切事情都可以用Lambda表達式來完成（注意，匿名方法可以忽略參數，Lambda表達式不具備這個特性）。
跟匿名方法類似，Lambda表達式有特殊的轉換規則：表達式的類型本身並非委托類型，但它可以通過隱式或顯式的發那個是轉換為一個委托實例。匿名函數這個術語同時涵蓋了匿名方法和Lambda表達式。
下面看看使用Lambda表達式獲得字符串長度的例子，通過Lambda將得到更見簡潔、易讀的代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
static void Main(string[] args)
{
//使用C# 2.0中的匿名方法獲取字符串長度
Func<string, int> strLength = delegate(string str) { return str.Length; };
Console.WriteLine(strLength("Hello World!"));
//使用Lambda表達式
//（顯式類型參數列表）=> {語句}，lambda表達式最冗長版本
strLength = (string str) => { return str.Length; };
Console.WriteLine(strLength("Hello World!"));
//單一表達式作為主體
//（顯式類型參數列表）=> 表達式
strLength = (string str) => str.Length;
Console.WriteLine(strLength("Hello World!"));
//隱式類型的參數列表
//（隱式類型參數列表）=> 表達式
strLength = (str) => str.Length;
Console.WriteLine(strLength("Hello World!"));
//單一參數的快捷語法
//參數名 => 表達式
strLength = str => str.Length;
Console.WriteLine(strLength("Hello World!"));
}
|
“=>”是C# 3.0新增的，告訴編譯器我們正在使用Lambda表達式。”=>”可以讀作”goes to”，所以例子中的Lambda表達式可以讀作”str goes to str.Length”。從例子中還可以看到，根據Lambda使用的特殊情況，我們可以進一步簡化Lambda表達式。
Lambda表達式大多數時候都是和一個返回非void的委托類型配合使用（例如Func<TResult>）。在C# 1.0中，委托一般用於事件，很少會返回什么結果。在LINQ中，委托通常被視為數據管道的一部分，接受輸入並返回結果，或者判斷某項是否符合當前的篩選 器等等。
Lambda表達式本質
通過ILSpy查看上面的例子，可以發現Lambda表達式就是匿名方法，是編譯器幫我們進行了轉換工作，使我們可以直接使用Lambda表達式來進一步簡化創建委托實例的代碼。
在List<T>中使用Lambda表達式
前面簡單的介紹了什么是Lambda表達式，下面通過一個例子進一步了解Lambda表達式。
在前面的文章中，我們也提到了一下List<T>的方法，例如FindAll方法，參數是Predicate<T>類型的 委托，返回結果是一個篩選后的新列表；Foreach方法獲取一個Action<T>類型的委托，然后對每個元素設置行為。下面就看看在 List<T>中使用Lambda表達式：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
public class Book
{
public string Name { get; set; }
public int Year { get; set; }
}
class Program
{
static void Main(string[] args)
{
var books = new List<Book>
{
new Book{Name="C# learning guide",Year=2005},
new Book{Name="C# step by step",Year=2005},
new Book{Name="Java learning guide",Year=2004},
new Book{Name="Java step by step",Year=2004},
new Book{Name="Python learning guide",Year=2003},
new Book{Name="C# in depth",Year=2012},
new Book{Name="Java in depth",Year=2014},
new Book{Name="Python in depth",Year=2013},
};
//創建一個委托實例來表示一個通用的操作
Action<Book> printer = book => Console.WriteLine("Name = {0}, Year = {1}", book.Name, book.Year);
books.ForEach(printer);
//使用Lambda表達式對List<T>進行篩選
books.FindAll(book => book.Year > 2010).ForEach(printer);
books.FindAll(book => book.Name.Contains("C#")).ForEach(printer);
//使用Lambda表達式對List<T>進行排序
books.Sort((book1, book2) => book1.Name.CompareTo(book2.Name));
books.ForEach(printer);
Console.Read();
}
}
|
從上面例子可以看到，當我們要經常使用一個操作的時候，我們最好創建一個委托實例，然后反復調用，而不是每次使用的時候都使用Lambda表達式（例如例子中的printer委托實例）。
相比C# 1.0中的委托或者C# 2.0的匿名函數，結合Lambda表達式，對List<T>中的數據操作變得簡單，易讀。
表達式樹
表達式樹也稱表達式目錄樹，將代碼以一種抽象的方式表示成一個對象樹，樹中每個節點本身都是一個表達式。表達式樹不是可執行代碼，它是一種數據結構。
下面我們看看怎么通過C#代碼建立一個表達式樹。
構建表達式樹
System.Linq.Expressions命名空間中包含了代表表達式的各個類，所有類都從Expression派生，我們可以通過這些類中的靜態方法來創建表達式類的實例。Expression類包括兩個重要屬性：
- Type屬性代表求值表達式的.NET類型，可以把它視為一個返回類型
- NodeType屬性返回所代表的表達式的類型
下面看一個構建表達式樹的簡單例子：
|
1
2
3
4
5
6
7
8
9
10
|
Expression numA = Expression.Constant(6);
Console.WriteLine("NodeType: {0}, Type: {1}", numA.NodeType, numA.Type);
Expression numB = Expression.Constant(3);
Console.WriteLine("NodeType: {0}, Type: {1}", numB.NodeType, numB.Type);
BinaryExpression add = Expression.Add(numA, numB);
Console.WriteLine("NodeType: {0}, Type: {1}", add.NodeType, add.Type);
Console.WriteLine(add);
Console.Read();
|
代碼的輸出為：
通過例子可以看到，我們構建了一個(6+3)的表達式樹，並且查看了各個節點的Type和NodeType屬性。
Expression有很多派生類，有很多節點類型。例如，BinaryExpression就代表了具有兩個操作樹的任意操作。這正是NodeType屬性重要的地方，它能區分由相同的類表示的不同種類的表達式。其他的節點類型就不介紹了，有興趣可以參考MSDN。
對於上面的例子，可以用下圖描述生成的表達式樹，值得注意的是，”葉子”表達式在代碼中是最先創建的，，表達式是自下而上構建的。表達式是不易變的，所有可以緩存和重用表達式。
將表達式編譯成委托
LambdaExpression是從Expression派生的類型之一。泛型類型Expression<TDelegate>又是從LambdaExpress派生的。
Expression和Expression<TDelegate>的區別在於，泛型類以靜態類型的方式標志了它是什么種類的表達式，也就是說，它確定了返回類型和參數。例如上面的加法例子，返回值是一個int類型，沒有參數，所以我們可以使用簽名Func<int>與之匹配，所以可以用Expression<Func<int>>以靜態類型的方式來表示該表達式。
這樣做的目的在於，LambdaExpression有一個Compile方法，該方法能創建一個恰當類型的委托。 Expression<TDelegate>也有一個同名方法，該方法可以返回TDelegate類型的委托。獲得了委托之后，我們就可以使 用普通委托實例調用的方式來執行這個表達式。
接着上面加法的例子，我們把上面的加法表達式樹轉換成委托，然后執行委托：
|
1
2
|
Func<int> addDelegate = Expression.Lambda<Func<int>>(add).Compile();
Console.WriteLine(addDelegate());
|
從這個例子中我們看到怎么構建一個表達式樹，然后把這個對象樹編譯成真正的代碼。在.NET 3.5中的表達式樹只能是單一的表達式，不能表示完整的類、方法。這在.NET 4.0中得到了一定的改進，表達式樹可以支持動態類型，我們可以創建塊，為表達式賦值等等。
將Lambda表達式轉換為表達式樹
Lambda表達式不僅可以創建委托實例，C# 3.0對於將Lambda表達式轉換成表達式樹提供了內建的支持。我們可以通過編譯器把Lambda表達式轉換成一個表達式樹，並創建一個Expression<TDelegate>的一個實例。
下面的例子中我們將一個Lambda表達式轉換成一個表達式樹，並通過代碼查看表達式樹的各個部分：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
static void Main(string[] args)
{
//將Lambda表達式轉換為類型Expression<T>的表達式樹
//expression不是可執行代碼
Expression<Func<int, int, int>> expression = (a, b) => a + b;
Console.WriteLine(expression);
//獲取Lambda表達式的主體
BinaryExpression body = (BinaryExpression)expression.Body;
Console.WriteLine(expression.Body);
//獲取Lambda表達式的參數
Console.WriteLine(" param1: {0}, param2: {1}", expression.Parameters[0], expression.Parameters[1]);
ParameterExpression left = (ParameterExpression)body.Left;
ParameterExpression right = (ParameterExpression)body.Right;
Console.WriteLine(" left body of expression: {0}{4} NodeType: {1}{4} right body of expression: {2}{4} Type: {3}{4}", left.Name, body.NodeType, right.Name, body.Type, Environment.NewLine);
//將表達式樹轉換成委托並執行
Func<int, int, int> addDelegate = expression.Compile();
Console.WriteLine(addDelegate(10, 16));
Console.Read();
}
|
代碼的輸出為：
表達式樹的用途
前面看到，通過Expression的派生類中的各種節點類型，我們可以構建表達式樹；然后可以把表達式樹轉換成相應的委托類型實例，最后執行委托實例的代碼。但是，我們不會繞這么大的彎子來執行委托實例的代碼。
表達式樹主要在LINQ to SQL中使用，我們需要將LINQ to SQL查詢表達式（返回IQueryable類型）轉換成表達式樹。之所以需要轉換是因為LINQ to SQL查詢表達式不是在C#代碼中執行的，LINQ to SQL查詢表達式被轉換成SQL，通過網絡發送，最后在數據庫服務器上執行。
這里只做個簡單的介紹，后續會介紹LINQ to SQL相關的內容。
編譯器對Lambda表達式的處理
前面我們了解到，Lambda可以用來創建委托實例，也可以用來生成表達式樹，這些都是編譯器幫我們完成的。
編譯器如何決定生成可執行的IL還是一個表達式樹：
- 當Lambda表達式賦予一個委托類型的變量時，編譯器生成與匿名方法同樣的IL（可執行的委托實例）
- 當Lambda表達式賦予一個Expression類型的變量時，編譯器就將它轉換成一個表達式樹
下圖展示了LINQ to Object和LINQ to SQL中Lambda表達式的不同處理方式：
總結
本文中介紹了Lambda表達式，在匿名方法的基礎上進一步簡化了委托實例的創建，編寫更加簡潔、易讀的代碼。匿名函數不等於匿名方法，匿名函數包含了匿名方法和lambda表達式這兩種概念
Lambda不僅可以創建委托實例，還可以由編譯器轉換成表達式樹，使代碼可以在程序之外執行（參考LINQ to SQL）。
