方法组转换和匿名方法

前面的文章介绍过，C# 1.0中出现委托这个核心概念，在C# 2.0中，委托获得了很大的改进。C# 2.0中委托的改进为C# 3.0中的新特性提供了铺垫，当咱们了解了匿名方法后，Lambda的学习就会变得相对容易。

下面就看看C# 2.0中委托的改进。

方法组转换

在C# 1.0中，若是要建立一个委托实例，就必须同时指定委托类型和符合委托签名的方法。可是，在C# 2.0中，支持了方法组转换，也就是说咱们能够从方法组到一个兼容委托类型的隐式转换。所谓"方法组"（method group），其实就是一个方法名。

看一个例子：

class Program
{
    public delegate void ReverseStringHandler(string str);

    private static void ReverseString(string str)
    {
        char[] charArray = str.ToCharArray();
        Array.Reverse(charArray);
        Console.WriteLine(charArray);
    }

    static void Main(string[] args)
    {
        //C# 1.0中建立委托实例
        ReverseStringHandler reverseStringHandler = new ReverseStringHandler(ReverseString);
        reverseStringHandler("Hello World");

        //C# 2.0中经过方法组转换建立委托实例
        reverseStringHandler = ReverseString;
        reverseStringHandler("Good morning");
    }
}

经过方法组转换，繁琐的委托实例建立获得了简化。

匿名方法

根据C# 1.0中了解到的知识，当咱们建立一个委托实例的时候，咱们须要找到一个跟委托类型签名一致的方法，用这个方法来实例化一个委托对象。

看看前面的字符串反转的例子，可能"ReverseString"这个方法在程序中只会使用一次，可是为了建立委托实例，这个方法必需要存在。

在C# 2.0中引入了匿名方法，因此有了更简单的方式实现上面的例子：

public delegate void ReverseStringHandler(string str);

static void Main(string[] args)
{
    ReverseStringHandler reverseStringHandler = delegate(string str)
    {
        char[] charArray = str.ToCharArray();
        Array.Reverse(charArray);
        Console.WriteLine(charArray);
    };
    reverseStringHandler("Hello World");

    Console.Read();
}

从上面能够看到，匿名方法就是经过delegate关键字以及参数列表和具体语句块的实现。

因此说，若是用来实例化委托的方法比较简单，而且这个方法在其余地方使用的频率很低时，这时候就能够考虑用匿名方法来进行简化。

匿名方法工做原理

若是你对匿名方法仍有疑惑，建议你看看上面例子的IL代码。

在Main函数的IL代码中，能够看到编译器为咱们生成了一个名为"<Main>b__0"的方法，方法接受一个string类型的参数。

.method private hidebysig static 
    void Main (
        string[] args
    ) cil managed 
{
    ……
    IL_0009: ldftn void AnonymousMethod.Program::'<Main>b__0'(string)
    ……
} // end of method Program::Main

当咱们查看"<Main>b__0"方法的IL代码后，能够看到这个方法就是咱们在匿名方法的语句块中定义的操做。

.method private hidebysig static 
    void '<Main>b__0' (
        string str
    ) cil managed 
{
    .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = (
        01 00 00 00
    )
    // Method begins at RVA 0x2050
    // Code size 23 (0x17)
    .maxstack 1
    .locals init (
        [0] char[] charArray
    )

    IL_0000: nop
    IL_0001: ldarg.0
    IL_0002: callvirt instance char[] [mscorlib]System.String::ToCharArray()
    IL_0007: stloc.0
    IL_0008: ldloc.0
    IL_0009: call void [mscorlib]System.Array::Reverse(class [mscorlib]System.Array)
    IL_000e: nop
    IL_000f: ldloc.0
    IL_0010: call void [mscorlib]System.Console::WriteLine(char[])
    IL_0015: nop
    IL_0016: ret
} // end of method Program::'<Main>b__0'

匿名方法的实现原理就是：编译器将在匿名方法所在的类，为每一个匿名方法都建立了一个方法。编译器建立的这些方法只在IL代码中有效，在C#代码中是无效的，因此C#代码不能直接使用这些方法。

其实，匿名方法更经常使用的地方是把匿名方法看成一个参数传递给另外一个方法。你们确定都知道List有一个FindAll的方法来查找符合条件的item，这里FindAll的参数就是一个过滤条件的委托。

List<int> numList = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
foreach(int num in numList.FindAll(delegate(int n){return n>6;}))
{
    Console.WriteLine(num);
}

说到了这里，咱们就看看系统帮咱们定义的委托，在C#中，Action、Func和Predicate是系统定义的委托，咱们能够直接使用。上面的FindAll的参数就是一个Predicate<T>的泛型委托。

Action委托

Action<T>是无返回值的泛型委托，Action委托能够支持至少0个参数，至多16个参数。

例如：

• Action 表示无参，无返回值的委托
• Action<int,string> 表示有传入参数int,string无返回值的委托
• Action<int,string,bool> 表示有传入参数int,string,bool无返回值的委托

对于前面的字符串反转的例子，咱们可使用Action委托进一步简化，这样咱们连"ReverseStringHandler"这个委托也省略了：

static void Main(string[] args)
{
   Action<string> reverseString = delegate(string str)
    {
        char[] charArray = str.ToCharArray();
        Array.Reverse(charArray);
        Console.WriteLine(charArray);
    };
   reverseString("Hello World");

    Console.Read();
}

Func委托

前面看到Action委托是没有返回值的，为了解决咱们有时可能须要返回值的问题，系统中又出现了Func委托。

Func<TResult>是有返回值的泛型委托，其中TResult就表明返回值的类型（）。Func委托能够支持至少0个参数，至多16个参数（Func<T1,T2,…,T16,TResult>）。

例如：

• Func<int> 表示无参，返回值为int的委托
• Func<object,string,int> 表示传入参数为object, string 返回值为int的委托
• Func<object,string,int> 表示传入参数为object, string 返回值为int的委托

看个简单的例子：

Func<int, int, int> addOperation = delegate(int numA, int numB) { return numA + numB; };
Console.WriteLine(addOperation(3,4));

Predicate委托

predicate 是返回bool型的泛型委托，经常结合集合类的查询使用；Predicate有且只有一个参数，返回值固定为bool。

Predicate原型：public delegate bool Predicate<T> (T obj)

• T： 要比较的对象的类型。
• obj： 要按照由此委托表示的方法中定义的条件进行比较的对象。
• 返回值：若是 obj 符合由此委托表示的方法中定义的条件，则为 true；不然为 false。

在前面结合查询的例子中，咱们直接把匿名方法"delegate(int n){return n>6;}"传给了FindAll方法。

其实也能够写成，

Predicate<int> checkNum = delegate(int n) { return n > 6; };
foreach (int num in numList.FindAll(checkNum)) {……}

忽略委托参数

在有些状况下，咱们并不须要委托参数，那么匿名方法能够进一步省略参数列表，只须要使用一个delegate关键字，加上做为方法的操做使用的代码块。

看一个简单的代码段：

Action printer = delegate { Console.WriteLine("Hello world"); };
printer();

注意，这个"参数通配"（paremeter wildcarding）的特性并不能适用全部的状况，若是匿名方法可以转换成多个委托类型，那么咱们就须要给编译器提供更多的信息。

举个例子，线程的构造函数设计两个委托类型，一个有参数，一个无参数。

public delegate void ParameterizedThreadStart(object obj)

public delegate void ThreadStart()

因此，当咱们经过下面的语句建立线程的时候，前两条语句没有问题，可是第三条语句会有一个错误。

由于第三条语句中的匿名方法能够转换成多个委托类型，编译器就不知道怎么处理了，因此，咱们须要显示给出参数列表。

Thread t1 = new Thread(delegate() { Console.WriteLine("this is t1"); });
Thread t2 = new Thread(delegate(object o) { Console.WriteLine("this is t2"); });
Thread t3 = new Thread(delegate { Console.WriteLine("this is t3"); });

总结

本篇文章介绍了C# 2.0中委托的改进，经过方法组转换和匿名方法，能够简化程序。

同时，看到了系统定义的三个委托类型，因此有些时候咱们能够不用建立本身的委托；可是要这个权衡，若是咱们要常常使用一个特定类型的委托，那仍是建议定义一个有意义更加明显的委托类型。

下一篇咱们将一块儿看看匿名方法中的变量。