Lambda表达式 ：
在C#2.0及C#1.x中，需要使用delegate来定义方法指针。如下面的代码如示：
public int[] searchArray(int[] values, Filter filter)
{
List<int> result = new List<int>();
foreach (int i in values)
{
if (filter(i))
result.Add(i);
}
return result.ToArray();
}
从上面的代码可以看出，定义了一个叫Filter的delegate类型。然后searchArray方法的第二个参数通过Filter类型将方法指针传到该方法中。 实际上，从IL可以看出，Filter被编译成了一个类，而且这个类是System.MulticastDelegate的子类。但和普通类不同的是，System.MulticastDelegate及其子类只能由编译器使用，不能直接写在源程序中。也就是说，只能在IL中使用。
如果要调用searchArray方法，需要先定义一个和Filter拥有同样参数和返回值的方法，代码如下：
{
return ((num & 1) == 0);
}
下面的代码调用了searchArray方法：
int[] evenArray = searchArray(intArray, MyFilter);
foreach (int i in evenArray)
textBox1.AppendText(i.ToString());
从C#2.0开始支持匿名方法，开发人员可以通过匿名方法用内联代码形式取代delegate，如上面的调用代码可以修改为下面的形式：
int[] evenArray = searchArray(intArray, delegate(int i) { return ((i & 1) == 0); });
foreach (int i in evenArray)
textBox1.AppendText(i.ToString());
上面的代码将匿名方法转换成了delegate。
然而，从C#3.0（.net framework3.5）开始，支持了Lambda表达式。所谓Lambda表达式就是delegate和匿名方法的简写形式，Lambda表达式的语法如下：
(param1, param2 ...,paramN) =>
{
表达式1;
表达式2;
return 返回值;
}
上面语法中的param1...paramN就表示方法的参数（不用确定类型，C#编译器会为我们做这个工作），而{...}里面的内容就和方法体中的内容完全一样。
如果delegate没有参数，可以只写()，如下面的方法所示：
public void test()
{
Method1 method1 = () => { int i = 4; i += 6; };
}
如果delegate只有一个参数，参数两边的括号可以不写，代码如下：
public void test()
{
Method2 method2 = i => { i++; i += 6; };
}
如果delegate有返回值，{...}中的最后一条语句需要使用return来返回相应的值，代码如下：
public void test()
{
Method3 method3 = (x, y) => { x++; y++; return x + y; };
}
如果使用Lambda表达式改写本文开头的例子，就会变得非常简单，代码如下：
int[] evenArray = searchArray(intArray, i => { return (i & 1) == 0; });
foreach (int i in evenArray)
textBox1.AppendText(i.ToString());
当然，我们也可以将Lamdba表达式赋给一个delegate，再进行传值，代码如下;
int[] intArray = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
int[] evenArray = searchArray(intArray, filter);
foreach (int i in evenArray)
textBox1.AppendText(i.ToString());
从本质上讲，Lamdba表达式经过C#编译器编译后，仍然会变成delegate的形式，也就是说Lamdba表达式只是在语法层次上的改进，并不是IL提供的新的指令。如下面的两行代码是等价的：
Filter filter = delegate(int i) { return ((i & 1) == 0); };
var、初始化、匿名类和扩展方法 :
一、用var定义变量
在C#3.0中提供了一种新的声明变量的方式，这就是var。通过这个关键字，在声明变量时就无需指定类型了，变量类型是在初始化时由编译器确定的。代码如下:
MessageBox.Show(ss.GetType().ToString());
上面的代码将显示System.String，从而证明C#编译器已经将ss编译成了String变量了。而在输出ss后，再输入“.”后，会看到将String类型变量的相应方法和属性也列出来了，因此可以断定，C#将ss看成了String类型，而不是Object。所以使用var定义变量同时可以拥有Object和强类型的优点。
不过大家不要将var看成是javascript的var，它们的区别是，javascript是弱类型的语言，而且javascript中的变量（也包括用var声明的变量）可以变换类型，如下面的javascript所示：
s=3;
alert(s);
上面的代码第一次给s赋了一个字符串，而第二行代码又给赋了一个整数。这样的代码在javascript中没有任何问题。但在C#3.0中，var变量一但被初始化，确定类型后，就无法改变类型了。如下面的代码是无法编译通过的：
ss = 44;
综上所述，在使用var定义变量时有以下四个特点：
1. 必须在定义时初始化。也就是必须是var s = “abcd”形式，而不能是如下形式：
s = “abcd”;
2. 一但初始化完成，就不能再给变量赋与初始化值类型不同的值了。
3. var要求是局部变量。
4. 使用var定义变量和object不同，它在效率上和使用强类型方式定义变量完全一样。但笔者建议如果事先知道变量的类型，尽量使用强类型方式来声明变量。否则，就会造成由于大量使用var，而使得开发人员很难断定某个变量是什么类型。这样不利于程序的维护和升级。
虽然var有利有弊，但笔者个人认为，如果将动态语言转换成C#语言，可以考虑使用var来定义变量。这是因为动态语言没有类型，而要将其转换成强类型的C#语言，就必须给变量指定个类型，但事先确定类型是很费劲的，不如将其指定成var，再由C#编译器去确定变量的具体类型。那么如果在转换的过程中，发现动态语言的变量改变了类型，该怎么办呢？这个可以使用第三部分要讲的“匿名类”来解决这个问题。
二、初始化
如果一个类有public字段，在建立类的对象实例时可以使用下面的代码来初始化这些字段;
{
public String field1;
public int field2;
public bool field3;
}
MyClass my = new MyClass();
my.field1 = “abcd”;
my.field2 = 44;
my.field3 = true;
在C#3.0中提供了一种更简便的方法来初始化这些public变量，代码如下：
{
field1 = “abcd”,
field2 = 44;
field3 =true;
};
上面的代码的写法有些象带参数的构造方法，但这将不是调用了MyClass的构造方法（因为MyClass并没有带三个参数的构造方法），而只是C#编译器玩的一个魔术。实际上，上面的代码在编译后，仍然和使用传统的初始化字段的方法一样。只是在语法上看起来更简单（至少不用写那么多个my）。要注意的的，使用这种方法初始化，必须是public的字段（不能是protected、private或默认修饰符的字段）。
在C#3.0中还改进了对集合类的初始化方式（使其初始化的方式类似于数组）。但遗憾的是，这种初始化方式只支持用泛型的集合类，也就是说，只有实现了System.Collections.Generic.ICollection<T>的集合类才可以使用这种初始化方法。代码如下：
foreach (string data in myList)
{
textBox1.AppendText(data);
}
三、匿名类
在C#3.0中提供了一种新的建立类的方法，代码如下：
{
field1 = "abcd",
field2 = 12
};
MessageBox.Show(my.field1);
C#编译器会自动推断my是一个有两个public字段的类的对象实例。也就是说相当于下面的代码：
{
public String field1;
public int field2;
}
var my = new MyClass();
my.field1 = "abcd";
my.field2 = 25;
MessageBox.Show(my.field1);
在第一部分讲到如果动态语言在给变量赋值的过程中改变了变量类型，如果将其转换为强类型语言。当然，一种方法是将变量声明成object类型，或是使用匿名类来解决这个问题。代码如下：
{
field_string = “abcd”
field_int = 12;
};
然后根据当前这个变量所使用的类型来决定该使用哪个类字段。
四、扩展方法
这个世界上总是存在着很多奇妙的东西。然而，在这部分所介绍的扩展方法就是其中之一。从字面上看可能读者很难猜透“扩展方法”是什么意思。然而，看了下面的例子，就会感觉到非常的奇妙。
{
public class Class1
{
public String s = "bill";
}
public class Class2 : Class1
{
}
public static class AnyClassName
{
public static String getName(this Class1 class1)
{
return class1.s + class1.s;
}
}
public partial class Form1 : Form
{
private void button1_Click(object sender, EventArgs e)
{
Class1 c = new Class1();
MessageBox.Show(c.getName());
Class2 c = new Class2();
MessageBox.Show(c.getName());
}
}
}
看到上面的代码，也许很多人会感到奇怪，在Class1和Class2中并没有getName方法，怎么在调用时出来个getName方法呢？实际上，这就是扩展方法的用法，从本质上说，扩展方法就是将静态方法（必须声明成static）插入到某个类和其子类中（也就是说，在这些类中可以使用在外部定义的静态方法）。那么要往哪个类中插入呢？这就要在定义静态方法时指定了。大家可以看看getName方法的第一个参数，使用了this关键字，这就表明这个方法是一个扩展方法，后面的类型就是要插入该方法的类，在本例中是Class1，也就是说在Class1及其子类中都可以使用getName方法。上面的调用代码也相当于下面的代码：
MessageBox.Show(AnyClassName.getName(c));
但使用c.getName可能会更好一些，而且也降低了对静态方法所在的类(AnyClassName)的依赖性。
在使用扩展方法时应注意以下几点：
1. 扩展方法所在的类名可以是任意合法的类名。
2. 扩展方法所在的类必须和使用扩展方法的代码在同一个命名空间里，否则无法编译通过。
3. 在本例中，Class1和Class2只能声明成public，因为AnyClassName被声明为public。如果AnyClassName不加修饰符，Class1和Class2也可以不加修饰符，当然，也可以被声明为public。也就是说，Class1和Class2必须有比AnyClassName具有更强的访问性。如下面代码所示：
{
public String s = "bill";
}
class Class2 : Class1
{
}
static class AnyClassName // 这时如果前面加public是无法编译通过的。
{
public static String getName(this Class1 class1)
{
return class1.s + class1.s;
}
}
4. 如果在Class1或Class2中已经有getName方法了，那么Class1或Class2中的getName优先级更高。也就是说，扩展方法是无法覆盖原类中的同名（参数名和类型也相同）的方法的。
扩展方法尤其在很多类需要同样的方法，而这些类又无法继承其它类时特别有用。当然，在要对某个类进行扩展，但我们并没有源代码时，扩展方法也可以派上用场。