开发者社区> 杰克.陈> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

[CLR via C#]17. 委托

简介: 原文:[CLR via C#]17. 委托     回调函数是一种非常有用的编程机制,它已经存在很多年了。Microsoft .NET Framework通过委托(delegate)来提供一种回调机制。
+关注继续查看
原文:[CLR via C#]17. 委托

    回调函数是一种非常有用的编程机制,它已经存在很多年了。Microsoft .NET Framework通过委托(delegate)来提供一种回调机制。不同于其他平台(比如非托管C++)的回调机制,委托提供了多得多的功能。例如,委托确保回调方法是类型安全的(这是CLR最重要的目标之一)。委托还允许顺序调用多个方法,并支持调用静态方法和实例方法。
 
一、初识委托
    为了理解委托,先看看如何使用它。
    委托4个最基本的步骤:
    1)定义委托类型
    2)有一个方法包含要执行的代码
    3)创建一个委托实例化(包含声明委托对象)
    4)执行调用(invoke)委托实例
    具体解释如下:
    1.定义委托类型
    委托类型就是参数类型的一个列表以及一个返回类型。    
delegate void StringProcessor(string input);

    其中的StringProcessor是一个类型。

    2.定义签名相同的方法
    定义的方法要与委托有类型相同的返回值和参数。    
private void GetStringLength(object x){}  //C#2.0以后认为一致

    

  3.创建委托实例

  创建委托实例就是指定在调用委托实例时执行的方法。    
StringProcessor proc1,proc2
//GetStringLength 实例方法
proc1= new StringProcessor(GetStringLength);
//GetString 静态方法
proc2 += GetString;

  

  4.调用委托
  调用委托就是调用一个委托实例方法。  
proc1("Hello World");

  具体的示例代码:

namespace Program {
    //定义委托
    delegate void StringProcessor(string input);
 
    class Person
    {
        string name;
        public Person(string name)
        {
            this.name = name;
        }
 
        //定义与委托签名相同的"方法"
        public void Say(string message)
        {
            Console.WriteLine(name+" say:" + message);
        }
    }
 
    class BackGround
    {
        //定义与委托签名相同的"静态方法"
        public static void Note(string note)
        {
            Console.Write("{0}", note);
        }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            Person jon = new Person("Jom");
            Person tom = new Person("Tom");
            //创建委托实例(第一步)
            StringProcessor proc1, proc2, proc3;
 
            //创建委托实例:赋值(第二部)
            proc1 = new StringProcessor(jon.Say);
            proc2 = new StringProcessor(tom.Say);
            proc3 = BackGround.Note;
 
            //调用委托
            proc1("Hello jon");
            proc2("Hello tom");
            proc3("note");
 
            Console.ReadKey();
        }
    }
}

 

  书中的代码示例:
namespace Test
{
    // 1.声明委托类型
    internal delegate void Feedback(Int32 value);
 
    internal class Program
    {
        private static void Main(string[] args)
        {
            StaticDelegateDemo();
            InstanceDelegateDemo();
            ChainDelegateDemo1(new Program());
            ChainDelegateDemo2(new Program());
 
        }
 
        private static void StaticDelegateDemo()
        {
            Console.WriteLine("----- Static Delegate Demo -----");
            Counter(1, 3, null);
            // 3.创建委托实例
            Counter(1, 3, new Feedback(Program.FeedbackToConsole));
            Counter(1, 3, new Feedback(FeedbackToMsgBox));
            Console.WriteLine();
        }
 
        private static void InstanceDelegateDemo()
        {
            Console.WriteLine("----- Instance Delegate Demo -----");
            Program di = new Program();
            // 3.创建委托实例
            Counter(1, 3, new Feedback(di.FeedbackToFile));
 
            Console.WriteLine();
        }
 
        private static void ChainDelegateDemo1(Program di)
        {
            Console.WriteLine("----- Chain Delegate Demo 1 -----");
            // 3.创建委托实例
            Feedback fb1 = new Feedback(FeedbackToConsole);
            Feedback fb2 = new Feedback(FeedbackToMsgBox);
            Feedback fb3 = new Feedback(di.FeedbackToFile);
 
            Feedback fbChain = null;
            fbChain = (Feedback)Delegate.Combine(fbChain, fb1);
            fbChain = (Feedback)Delegate.Combine(fbChain, fb2);
            fbChain = (Feedback)Delegate.Combine(fbChain, fb3);
            Counter(1, 2, fbChain);
 
            Console.WriteLine();
            fbChain = (Feedback)Delegate.Remove(fbChain, new Feedback(FeedbackToMsgBox));
            Counter(1, 2, fbChain);
        }
 
        private static void ChainDelegateDemo2(Program di)
        {
            Console.WriteLine("----- Chain Delegate Demo 2 -----");
            Feedback fb1 = new Feedback(FeedbackToConsole);
            Feedback fb2 = new Feedback(FeedbackToMsgBox);
            Feedback fb3 = new Feedback(di.FeedbackToFile);
 
            Feedback fbChain = null;
            fbChain += fb1;
            fbChain += fb2;
            fbChain += fb3;
            Counter(1, 2, fbChain);
 
            Console.WriteLine();
            fbChain -= new Feedback(FeedbackToMsgBox);
            Counter(1, 2, fbChain);
        }
 
        private static void Counter(Int32 from, Int32 to, Feedback fb)
        {
            for (Int32 val = from; val <= to; val++)
            {
                // 如果指定了任何回调,就可以调用它
                if (fb != null)
                    // 4.调用委托
                    fb(val);
            }
        }
 
        // 2.声明签名相同的方法
        private static void FeedbackToConsole(Int32 value)
        {
            Console.WriteLine("Item=" + value);
        }
 
        // 2.声明签名相同的方法
        private static void FeedbackToMsgBox(Int32 value)
        {
            Console.WriteLine("Item=" + value);
        }
 
        // 2.声明签名相同的方法
        private void FeedbackToFile(Int32 value)
        {
            StreamWriter sw = new StreamWriter("Status", true);
            sw.WriteLine("Item=" + value);
            sw.Close();
        }
    }
}

 

二、用委托回调静态方法
    在上面的代码中,我们可以清楚的看到用委托如何回调静态方法。直接将静态方法绑定到委托的实例上,再通过实例进行调用。
    将一个方法绑定到一个委托时,C#和CLR都允许引用类型的协变性和逆变性。协变性是指方法能返回从委托的返回类型派生的一个类型。逆变性是指方法获取的参数可以是委托的参数类型的基类。例如下面的委托:
deleget Object MyCallback(FileStream s);

    完全可以构造该委托类型的一个实例,并和具有一下原型的一个方法绑定:

String SomeMethod(Stream s);

    在这里,SomeMethod的返回类型(String)派生自委托的返回类型(Object);这种协变性是允许的。SomeMethod的参数类型(Stream)是委托的参数类型(FileStream)的基类;这种逆变性是运行部的。

    注意,协变性和逆变性只能用于引用类型,不能作用于值类型和void。所以下面示例是错误的:
Int32 SomeMethod(Stream s);//这是错误的

    值类型和void之所以不支持协变性和逆变性,是因为它们的存储结构是变化的,而引用类型的存储结构始终是一个指针。

三、用委托回调实例方法
    使用委托回调实例方法,在上面代码中演示已经非常清楚了,就不细说了。
 
四、委托揭秘
    从表面看,委托似乎很容易使用:用C#的delegate关键字声明,用熟悉的new操作符构造委托实例,用熟悉的方法调用语法来调用回调函数。
    然而,实际情况远比前面例子演示的复杂的多。编译器和CLR在幕后做了大量工作来隐藏复杂性。本节重点讲解了编译器和CLR如何协同工作来实现委托。
    首先让我们重写审视下面的代码:
internal delegate void Feedback(Int32 value);

  看到这行代码,编译器实际会像下面这样定义一个完整的类:

internal class Feedback: System.MulticastDelegate {
    // 构造器
    public Feedback(Object object, IntPtr method);
 
    // 这个方法和源代码指定的原型一样
    public virtual void Invoke(Int32 value);
 
    // 以下方法实现了对回调方法的异步回调
    public virtual IAsyncResult BeginInvoke(Int32 value, AsyncCallback callback, Object object);
public virtual void EndInvoke(IAsyncResult result); }

  编译器定义的类有4个方法:一个构造器、Invoke、BeginInvoke和EndInvoke。本节重点解释构造器和Invoke,BeginInvoke和EndInvoke看留到后面讲解。

  事实上,可用ILDasm.exe查看生成的程序集,验证编译器真的会自动生成这个类,如图17-1所示:
 
  在这个例子中,编译器定义了一个名为Feedback的类,该类派生自FCL定义的System.MulticastDelegate类型(所有委托类型都派生自System.MulticastDelegate类型)。
  提示:System.MulticastDelegate类派生自System.Delegate,后则又派生自System.Object。之所以有两个委托类,是有历史原因的。
  从图中可知Feedback的可访问性是private,因为委托在源代码中声明为internal类。如果源代码改成使用public可见性,编译器生成的类也会是public类。要注意,委托类即可嵌套在一个类型中定义,也可以在全局范围中定义。简单地说,由于委托是类,所以凡是能够定义类的地方,都能定义委托。
  由于所有委托类型都派生自MulticastDelegate,所以它们继承了MulticastDelegate的字段、属性和方法。在这些成员中,有三个非公共字段是最重要的。
  
字段 类型 说明
_target System.Object 当委托对象包装一个静态方法时,这个字段为null。当委托对象包装一个实例方法时,这个字段引用的是回调方法要操作的对象。换言之,这个字段指出了要传给实例方法的隐式参数this的值
_methodPtr System.IntPtr 一个内部的整数值,CLR用它来标识要回调的方法
_invocationList System.Object 该字段通常为null。构造一个委托链时,它可以引用一个委托数组。
 
  注意,所有委托都有一个构造器,它要获取两个参数:一个是对象引用,另一个是引用回调方法的一个整数。然而,如果仔细看下签名的源代码,会发现传递的是Program.FeedbackToConsole和di.FeedbackToFile这样的值,这似乎不可能通过编译吧?
    然而,C#编译器知道要构造的是委托,所以会分析源代码来确定引用的是哪个对象和方法。对象引用被传给构造器的object参数,标识了方法的一个特殊IntPtr值(从MethodDef或MemberRef元数据token获得)被传给构造器的method参数。对于静态方法,会为object参数传递null值。在构造器内部,这两个实参分别保存在_target和_methodPtr私有字段中。除此之外,构造器还将_invocationList字段设为null,对这个字段的讨论推迟到后面。
  所以,每个委托对象实际都是一个包装器,其中包装了一个方法和调用该方法时要操作的一个对象。例如,在执行以下两行代码之后:
    Feedback fbStatic = new Feedback(Program.FeedbackToConsole);
    Feedback fbInstance = new Feedback(new Program.FeedbackToFile());

    fbStatic和fbInstance变量将引用两个独立的,初始化好的Feedback委托对象,如图17-2所示。

    Delegate类定义了两个只读的公共实例属性:Target和Method。给定一个委托对象的引用,可查询这些属性。Target属性返回一个引用,它指向回调方法要操作的对象。简单的说,Target属性返回保存在私有字段_target中的值。如果委托对象包装的是一个静态方法,Target将返回null。Method属性返回一个System.Reflection.MethodInfo对象的引用,该对象标识了回调方法。简单地说,Method属性有一个内部转换机制,能将私有字段_methodPtr中的值转换为一个MethodInfo对象并返回它。
  可通过多种方式利用这些属性。例如,可检查委托对象引用是不是一个特定类型中定义的实例方法:
Boolean DelegateRefersToInstanceMethodOfType(MulticastDelegate d ,Type type) {
    return ((d.Target != null) && d.Target.GetType() == type);
}

  还可以写代码检查回调方法是否有一个特定的名称(比如FeedbackToMsgBox):

Boolean DelegateRefersToInstanceMethodOfName(MulticastDelegate d ,String methodName) {
    return (d.Method.Name == methodName);
}

  知道了委托对象如何构造并了解其内部结构之后,在来看看回调方法是如何调用的。为方便讨论,下面重复了Counter方法的定义:

private static void Counter(Int32 from, Int32 to, Feedback fb) {
    for (Int32 val = from; val <= to; val++) {
        // 如果指定了任何回调,就调用它们
        if(fb != null ){
            fb(val);
        }
    }
}

  注意注释下方的那一行代码。if语句首先检查fb是否为null。如果不为null,下一行代码调用回调方法。

  这段代码看上去是在调用一个名为fb的函数,并向它传递一个参数(val)。但事实上,这里没有名为fb的函数。再次提醒你注意,因为编译器知道fb是引用了一个委托对象的变量,所以会生成代码调用该委托对象的Invoke方法。也就是说,编译器看到以下代码时:
fb(val);

  将生成以下代码,好像源代码本来就是这么写的:

fb.Invoke(val);

  为了验证编译器生成的代码来调用委托类型的Invoke方法,可利用ILDasm.exe来检查生成的IL代码:

.method private hidebysig static void  Counter(int32 from,
                                               int32 'to',
                                               class ConsoleTest.Feedback fb) cil managed
{
  // 代码大小       41 (0x29)
  .maxstack  2
  .locals init ([0] int32 val,
           [1] bool CS$4$0000)
  IL_0000:  nop
  IL_0001:  ldarg.0
  IL_0002:  stloc.0
  IL_0003:  br.s       IL_001d
  IL_0005:  nop
  IL_0006:  ldarg.2
  IL_0007:  ldnull
  IL_0008:  ceq
  IL_000a:  stloc.1
  IL_000b:  ldloc.1
  IL_000c:  brtrue.s   IL_0018
  IL_000e:  nop
  IL_000f:  ldarg.2
  IL_0010:  ldloc.0
  IL_0011:  callvirt   instance void ConsoleTest.Feedback::Invoke(int32)
  IL_0016:  nop
  IL_0017:  nop
  IL_0018:  nop
  IL_0019:  ldloc.0
  IL_001a:  ldc.i4.1
  IL_001b:  add
  IL_001c:  stloc.0
  IL_001d:  ldloc.0
  IL_001e:  ldarg.1
  IL_001f:  cgt
  IL_0021:  ldc.i4.0
  IL_0022:  ceq
  IL_0024:  stloc.1
  IL_0025:  ldloc.1
  IL_0026:  brtrue.s   IL_0005
  IL_0028:  ret
} // end of method Program::Counter

  其实,完全可以修改Counter方法来显式调用Invoke方法,如下所示:

private static void Counter(Int32 from, Int32 to, Feedback fb) {
    for (Int32 val = from; val <= to; val++) {
        // 如果指定了任何回调,就调用它们
        if(fb != null ){
            fb.Invoke(val);
        }
    }
}

  前面说过,编译器是在定义Feedback类时定义Invoke的。所以Invoke被调用时,它使用私有字段_target和_methodPtr在指定对象上调用包装好的回调方法。注意,Invoke方法的签名与委托的签名是匹配的。由于Feedback委托要获取一个Int32参数,并返回void,所以编译器生成的Invoke方法也要获取一个Int32参数,并返回void。

 
五、 用委托回调许多方法(委托链)
  委托本身就已经相当有用了,在加上对委托链的支持,它的用处就更大了!委托链是由委托对象构成的一个集合。利用委托链,可调用集合中的委托所代表的全部方法。为了理解这一点,请参考第一节中的示例代码中的ChainDelegateDemo1方法。在这个方法中,在Console.WriteLine语句之后,我构造了三个委托对象并让变量fb1、fb2和fb3引用每一个对象,如图17-3所示:
 
  随后,我定义了指向Feedback委托对象的引用变量fbChain,并打算让它引用一个委托链或者一个委托对象集合,这些对象包装了可以回调的方法。fbChain被初始化为null,表明目前没有回调的方法。使用Delegate类的公共静态方法Combine,可以将一个委托添加到链中:
Feedback fbChain = null;
fbChain = (Feedback)Delegate.Combine(fbChain, fb1);

    执行以上代码时,Combine方法会视图合并null和fb1。在内部,Combine直接返回fb1中的值,所以fbChain变量现在引用的就是fb1变量引用的那个委托对象。如图17-4所示:

 
    为了在链中添加第二个委托,再次调用了Combine方法:
fbChain = (Feedback)Delegate.Combine(fbChain, fb2);

    在内部,Combine方法发现fbChain已经引用了一个委托对象,所以Combine会构造一个新的委托对象。这个新的委托对象对它的私有字段_target和_methodPtr进行初始化,具体值对目前讨论的来说并不重要。重要的是,_invocationList字段被初始化为引用一个委托对象数组。这个数组的第一个元素(索引为0)被初始化为引用包装了FeedbackToConsole方法的委托。数组的第二个元素(索引为1)被初始化为引用包装了FeedbackToMsgBox方法的委托。最后,fnChain被设为引用新建的委托对象,如图17-5所示:

 
  为了在链中添加第三个委托,再次调用了Combine方法:
fbChain = (Feedback)Delegate.Combine(fbChain, fb3);

    同样的,Combine方法会发现fbChain已经引用了一个委托对象,于是又Combine会构造一个新的委托对象。这个新的委托对象对它的私有字段_target和_methodPtr进行初始化,具体值对目前讨论的来说并不重要。重要的是,_invocationList字段被初始化为引用一个委托对象数组。这个数组的第一个元素(索引为0)被初始化为引用包装了FeedbackToConsole方法的委托,数组的第二个元素(索引为1)被初始化为引用包装了FeedbackToMsgBox方法的委托,数组的第三个元素(索引为2)被初始化为引用包装了FeedbackToFile方法的委托。最后,fnChain被设为引用新建的委托对象。注意之前新建的委托以及_invocationList字段引用的数组已经被垃圾回收器回收了。如图17-6所示:

    在ChainDelegateDemo1方法中,用于设置委托链的所有代码已经执行完毕,我将fnChain变量交给Counte方法:
Counter(1, 2, fbChain);

    Counter方法内部的代码会在Feedback委托对象上隐式调用Invoke方法,这在前面已经讲过了。在fnChain引用的委托上调用Invoke时,该委托发现私有字段_invocationList不为null,所以会执行一个循环来遍历数组中的所有元素,并依次调用每个委托包装的方法。在本例中,首先调用的是FeedbackToConsole,然后是FeedbackToMsgBox,最后是FeedbackToFile。

  以伪代码的方式,Feedback的Invoke的基本上是向下面这样实现的:

public void Invoke(Int32 value) {
    Delegate[] delegateSet =  _invocationList as Delegate[];
    if (delegateSet != null) {
        foreach(var d in delegateSet)
            d(value);// 调用委托
    }else{//否则,不是委托链
        _methodPtr.Invoke(value);
    }    
}

    注意,还可以使用Delegate公共静态方法Remove从委托链中删除委托,如下所示。

fbChain = (Feedback)Delegate.Remove(fbChain, new Feedback(FeedbackToMsgBox));

    Remove方法被调用时,它扫描的第一个实参(本例是fbChain)所引用的那个委托对象内部维护的委托数组(从末尾向索引0扫描)。Remove查找的是其_target和_methodPtr字段与第二个实参(本例是新建的Feedback委托)中的字段匹配的委托。如果找匹配的委托,并且(在删除之后)数组中只剩下一个数据项,就返回那个数据项。如果找到匹配的委托,并且数组中还剩余多个数据项,就新建一个委托对象——其中创建并初始化_invocationList数组将引用原始数组中的所有数据项(删除的数据项除外),并返回对这个新建委托对象的引用。如果从链中删除了仅有的一个元素,Remove会返回null。注意,每次Remove方法调用只能从链中删除一个委托,它不会删除有匹配的_target和_methodPtr字段的所有委托。

    前面展示的例子中,委托返回值都是void。但是,完全可以向下面这样定义Feedback委托:
 public delegate Int32 Feedback (Int32 value);

    如果这样定义,那么该委托的Invoke方法就应该向下面这样(伪代码形式):

public Int32 Invoke(Int32 value) {
    Int32 result;
    Delegate[] delegateSet =  _invocationList as Delegate[];
    if (delegateSet != null) {
        foreach(var d in delegateSet)
           result = d(value);// 调用委托
    }else{//否则,不是委托链
        result = _methodPtr.Invoke(_target,value);
    }
    return result;    
}

1.C#对委托链的支持

    为方便C#开发人员,C#编译器自动为委托类型的实例重载了+=和-=操作符。这些操作符分别调用了Delegate.Combine和Delegate.Remove。使用这些操作符,可简化委托链的构造。

    比如下面代码:
Feedback fbChain = null;
fbChain += fb1;
fbChain += fb2;
fbChain += fb3;

 

2.取得对委托链调用更多控制
  现在我们已经理解了如何创建一个委托对象链,以及如何调用链中的所有对象。链中的所有项都会被调用,因为委托类型的Invoke方法包含了对数组中的所有项进行变量的代码。因为Invoke方法中的算法就是遍历,过于简单,显然,这有很大的局限性,除了最后一个返回值,其它所有回调方法的返回值都会被丢弃。还有吗如果被调用的委托中有一个抛出一个或阻塞相当长的时间,我们又无能为力。显然,这个算法还不够健壮。
    由于这个算法的局限,所以MulticastDelegate类提供了一个GetInvocationList,用于显式调用链中的每一个委托,同时又可以自定义符合自己需要的任何算法:
public abstract class MulticastDelegate :Delegate {
    // 创建一个委托数组,其中每个元素都引用链中的一个委托
    public sealed override Delegate[] GetInvocationList();
}

    GetInvocationList方法操作一个从MulticastDelegate派生的对象,返回一个有Delegate组成的数组,其中每一个引用都指向链中的一个委托对象。

    下面是代码演示:
public static class GetInvocationList
    {
        // 定义一个 Light 组件
        private sealed class Light
        {
            // 该方法返回 light 的状态
            public String SwitchPosition()
            {
                return "The light is off";
            }
        }
 
        // 定义一个  Fan 组件
        private sealed class Fan
        {
            // 该方法返回 fan 的状态
            public String Speed()
            {
                throw new InvalidOperationException("The fan broke due to overheating");
            }
        }
 
        // 定义一个  Speaker 组件
        private sealed class Speaker
        {
            // 该方法返回 speaker 的状态
            public String Volume()
            {
                return "The volume is loud";
            }
        }
 
        // 定义委托
        private delegate String GetStatus();
 
        public static void Go()
        {
            // 声明一个为null的委托
            GetStatus getStatus = null;
 
            // 构造三个组件,将它们的状态方法添加到委托链中
            getStatus += new GetStatus(new Light().SwitchPosition);
            getStatus += new GetStatus(new Fan().Speed);
            getStatus += new GetStatus(new Speaker().Volume);
 
            // 输出该委托链中,每个组件的状态
            Console.WriteLine(GetComponentStatusReport(getStatus));
        }
 
        // 该方法用户查询几个组件的状态
        private static String GetComponentStatusReport(GetStatus status)
        {
 
            // 如果委托链为null,则不进行任何操作
            if (status == null) return null;
 
            // 用StringBuilder来记录创建的状态报告
            StringBuilder report = new StringBuilder();
 
            // 获取委托链,其中的每个数据项都是一个委托
            Delegate[] arrayOfDelegates = status.GetInvocationList();
 
            // 遍历数组中的每一个委托
            foreach (GetStatus getStatus in arrayOfDelegates)
            {
 
                try
                {
                    // 获取一个组件的状态报告,将它添加到StringBuilder中
                    report.AppendFormat("{0}{1}{1}", getStatus(), Environment.NewLine);
                }
                catch (InvalidOperationException e)
                {
                    // 在状态报告中生成一条错误记录
                    Object component = getStatus.Target;
                    report.AppendFormat(
                       "Failed to get status from {1}{2}{0}   Error: {3}{0}{0}",
                       Environment.NewLine,
                       ((component == null) ? "" : component.GetType() + "."),
                       getStatus.Method.Name, e.Message);
                }
            }
 
            // 返回遍历后的报告
            return report.ToString();
        }
    }

执行结果为:

The light is off
 
Failed to get status from ConsoleTest.GetInvocationList+Fan.Speed
   Error: The fan broke due to overheating
 
The volume is loud
 
六、委托定义太多(泛型委托)
  许多年前,.NET Framework刚开始开发时,Microsoft引入委托的概念。开发人员在FCL中添加类时,他们在引入了回调方法的所有定法定义新的委托类型。随着时间的推移,他们定义了太多的委托。事实上,现在仅仅在MSCorLib.dll中,就有接近50个委托类型。比如:
public delegate void TryCode(Object userData);
public delegate void WaitCallback(Object state);
public delegate void TimerCallback(Object state);
...

  你发现上面几个委托的共同点了吗?它们其实全是一样的:这些委托类型的变量引用的方法都是获取一个Object,并且返回void。没有理由定义这么多委托类型,定义一个就好了!

  现在,.NET Framewoke现在支持泛型,所以实际上只需要几个泛型委托就可以表示获取多达16个参数的方法:
public delegate void Action(); //这不是泛型
public delegate void Action<T>(T obj);
public delegate void Action<T1,T2>(T1 obj1,T2 obj2);
public delegate void Action<T1,T2,T3>(T1 obj1,T2 obj2,T3 obj3);
...
public delegate void Action<T1,...,T16>(T1 obj1,...,T16 obj16);

  所以,.NET Framework现在提供17个Action委托,它们从无参数一直到最多16个参数。如果方法需要获取16个意思、上的参数,就必须定义自己的委托类型,但这种情况应该是极其罕见的。除了Action委托,.NET Framewoke还提供了17个Func函数,它们允许回调方法方法返回一个值:

public delegate TResult Func<TResult>();
public delegate TResult Func<T,TResult>(T1 arg);
public delegate TResult Func<T1,T2,TResult>(T1 arg1,T2 arg2);
...
public delegate TResult Func<T1,...,T16,TResult>(T1 arg1,...,T16 arg16);

  建议尽量使用这些委托类型,而不是在代码中定义更多的委托类型。这样可以减少系统中的类型数目,同时简化编码。然而,如果需要使用ref或out关键字,以引用的方式传递一个参数,就可能不得不定义自己的委托:

delegate void Bar(ref Int32 z);

  使用获取泛型实参和返回值的委托时,可利用逆变和协变,而且建议你总是利用这些功能,因为它们内有副作用,而且是你的委托适用于更多情形。

 
七、C#为委托提供的简化语法
  许多开发人员认为和委托打交道很麻烦。因为它的语法很奇怪。例如以下代码:
button1.Click += new EventHandle(button1_Click);

    其中的button1_Click是一个方法,它看起来像下面这样:

void button1_Click(Object sender, EventArgs e) {
    // 按钮单击后要做的事情....
}

  第一行代码的思路是向按钮控件登记button1_Click方法的地址,以便在该按钮被单击时,可以调用方法。许多开发人员认为,仅仅为了指定button1_CLick方法的地址,就构造一个EventHandle委托对象,这显得有点不可思议。然而,构造EventHandle委托对象是CLR要求的,因为这个对象提供了一个包装器,可确保(被包装的)方法只能以类型安全的方式调用。这个包装器还支持调用实例方法和委托链。但是很多开发人员不想研究这些细节,更喜欢像下面这样的写代码:

button1_Click += button1_Click;

  幸好,C#编译器为开发人员提供了一些用于处理委托的简化方法。后文描述的实际上可归为C#的语法糖(syntactical sugar);

    1.简化语法1:不需要构造委托对象
  如前所示,C#允许指定回调方法的名称,不必构造一个委托对象包装器。例如:
    public sealed class AClass
    {
        private static void CallbackWithoutNewingADelegateObject(){                
            ThreadPool.QueueUserWorkItem(SomeAsyncTask,5);
        }
        
        private static void SomeAsyncTask(Object o) {
            Console.WriteLine(o);
        }
    }

  这里,ThreadPool类的静态方法QueueUserWorkItem期望接受对一个WaitCallback委托对象的引用,委托对象中包装的是对SomeAsyncTask方法的一个引用。由于C#编译器能够自己进行推断,所以可以省略构造WaitCallback委托对象的代码,使整个代码的可读性更强,也更容易理解。当然,当代码编译时,C#编译器会生成IL代码来构建WaitCallback委托对象——我们只是在语法上得到了简化而已。

    2.简化语法2:不需要定义回调方法
  在前面的代码中,是将回调方法SomeAsyncTask传给ThreadPool的QueueUserWorkItem方法。C#允许我们以内联的方式写回调方法的代码。不必再另外定义方法写。例如,前面的代码可以重写为下面这样:
    public sealed class AClass
    {
        private static void CallbackWithoutNewingADelegateObject(){                
            ThreadPool.QueueUserWorkItem(obj => Console.WriteLine(obj),5);
        }
    }

  注意,传给QueueUserWorkItem方法的第一个实参其实是一个lambda表达式。通过C# limbda表达式操作符=>,可以很容易地识别这种表达式。lambda表达式可在编译器预计需要一个委托的地方使用。编译器看到这个lambda表达式之后,会在类中自动创建一个新的私有方法。这个新方法成为匿名函数(anonymous function),因为方法的名称是编译器自动创建的,开发人员一般不知道这个名称。通过ILDasm.exe查看C#编译器将该方法命名为了<CallbackWithoutNewingADelegateObject>b__0,它获取一个Object参数,返回void.

  编译器选择的方法名以<符号开头,这是因为在C#中,标识符是不能包含<符号的;这就确保了你不会碰巧定义一个编译器自动选择的名称。顺便说一句,虽然C#禁止标识符包含<符号,但是CLR允许,这也就是为什么编译不会出错的原因了。另外注意,虽然可将方法名作为一个字符串来传递,通过反射来访问方法,但是C#语言规范指出,编译器生成名称的方式是没有任何保证的。例如,每次编译代码,编译器生成的方法都可能是一个不同的名称。
  通过ILDasm.exe,我们还注意到C#编译器向这个方法应用了一个名为System.Runtime.CompilerServices.CompilerGeneratedAttribute的attribute,指出方法是编译器生成的,而非开发人员定义的。=>操作符右侧的代码被放入这个编译器生成的方法中。
  提示:lambda表达式的主要优势在于,它从你的源代码中移除了一个"间接层"。
  注意:C#2.0面世时,它引入了一个称为匿名方法的功能。和C#3.0引入的lambda表达式相似,匿名方法描述的也是用于创建匿名函数的一个语法。C#语言规范建议开发人员使用新的lambda表达式,而不要使用旧的匿名方法语法,因为lambda表达式语法更简洁,代码更容易写、读和维护。
    3.简化语法3:局部变量不需要手动包装到类中即可传给回调方法
  前面展示了回调代码如何引用类中定义的其他成员。但有时候,还希望回调代码引用存在于方法中的局部参数或变量。下面有个有趣的例子:
internal sealed class AClass2
    {
        internal static void UsingLocalVariablesInTheCallbackCode(Int32 numToDo)
        {
 
            // 一些局部变量
            Int32[] squares = new Int32[numToDo];
            AutoResetEvent done = new AutoResetEvent(false);
 
            // 在其它线程上执行一系列任务
            for (Int32 n = 0; n < squares.Length; n++)
            {
                ThreadPool.QueueUserWorkItem(
                   delegate(Object obj)
                   {
                       Int32 num = (Int32)obj;
 
                       // 耗时任务
                       squares[num] = num * num;
 
                       // 如果是最后一个任务,则让主线程继续执行
                       if (Interlocked.Decrement(ref numToDo) == 0)
                           done.Set();
                   }, n);
            }
 
            // 等待其他所有线程执行完毕
            done.WaitOne();
 
            // 显示任务
            for (Int32 n = 0; n < squares.Length; n++)
                Console.WriteLine("Index {0}, Square={1}", n, squares[n]);
        }
    }

    这个例子实际演示了C#如何简单的实现一个非常复杂的任务。以上方法定义了一个参数numToDo和两个局部变量aquares和done,而且lambda表达式的主题引用了这些变量。现在,想象以下lambda表达式主体中的代码在一个单独的方法中(事实上,也的确如此)。变量的值如何传递给这个单独的方法呢?唯一的方法就是定义一个新的辅助类,这个类要为我们打算传给回调代码的每一个值都定义一个字段。此外,回调代码还必须定义这个辅助类中的一个实例方法。然后,UsingLocalVariablesInTheCallbackCode方法必须构造辅助类的一个实例,用方法定义的局部变量的值来初始化这个实例中的字段。然后,构造绑定到辅助对象/实例方法的委托对象。

  注意:当lambda表达式造成编译器生成一个类时,而且参数/局部变量被转变成该类的字段后,变量引用的对象的生存周期被延长了。正常情况下,在方法中最后一次使用参数/局部变量之后,这个参数/局部变量就会"操作作用于",结束其生命周期。但是,将变量转变成另一个类的字段后,只要包含字段的那个对象不"死",字段引用的对象也不会"死"。这在大多数应用程序中不是大的问题,但有时需要注意一下。
  提示:毫无疑问,C#的lambda表达式功能很容易被开发人员滥用。我给自己设定了一个规则:如果需要在回调放方法中包含3行以上代码,就不适用lambda表达式。相反的,我会手动写一个方法,并为其分配一个自己的名称。
 
八、 委托和反射
  到本节为止,为了使用委托,开发人员必须实现知道要回调的那个方法的原型。例如,如果fb是引用了一个Feedback委托的变量(第一节第二个示例程序),那么为了调用这个委托,代码应该这样写:
fb(item);   //item为Int32类型

  可以看出,在编码的时候,开发人员必须知道回调方法需要多少个参数,以及这些参数的具体类型。还好,开发人员几乎总是知道这些信息,所以像前面那样写代码是没有问题的。

  不过在个别情况下,开发人员在编译时并不知道这些信息。在11章"事件"讨论EventSet类型时,曾经展示过一个例子。这个例子用一个字典来维护一组不同的委托类型。在运行时,为了引发事件,要在字典中查找并调用委托。但在编译时,我们不能准确地知道要调用哪个委托,哪些参数必须传给委托的回调方法。
  System.Delegate提供了几个方法。在编译时不知道委托的这些必要信息时,可利用这个方法来创建并调用一个委托。以下是Dela\egate定义的这几个方法:
    
public abstract class Delegate {
    // 构造用于包装指定静态方法的一个"type"委托
    public static Delegate CreateDelegate(Type type, MethodInfo method);
    public static Delegate CreateDelegate(Type type, MethodInfo method,Boolean throwOnBindFailure);
    
    // 构造用于包装指定实例方法的一个"type"委托
    public static Delegate CreateDelegate(Type type,Object firstArgument, MethodInfo method); //firstArgument指的是this
    public static Delegate CreateDelegate(Type type,Object firstArgument, MethodInfo method,Boolean throwOnBindFailure);
 
    // 调用委托并传递参数
    public Object DynamicInvoke(params Object[] args);
 
}

  所有CreateDelegate方法构造的都是从Delegate派生的一个类型新对象,具体类型由第一个参数type来标识。MethodInfo参数指出应该回调的方法;要用反射来获取这个值。如果希望委托包装一个实例方法,还要向CreateDelegate传递一个firstArgument参数,指定应作为this参数(第一个参数)传给实例方法的对象。最后,如果委托不能绑定到method参数指定的方法,CreateDelegate通常应该抛出一个异常。

  System.Delegate的DynamicInvoke方法允许调用委托对象的回调方法,传递一组在运行时确定的参数。调用DynamicInvoke时,它会在内部保证传递的参数与回调方法期望的参数兼容。如果兼容,就调用回调方法;否则抛出一个异常。DynamicInvoke返回回调方法所返回的对象。
  下面代码展示了如何使用CreateDelegate和DynamicInvoke方法:
internal static class DelegateReflection
    {
        // 下面是一些不同的委托定义
        private delegate Object TwoInt32s(Int32 n1, Int32 n2);
        private delegate Object OneString(String s1);
 
        public static void Go(String[] args)
        {
            if (args.Length < 2)
            {
                String fileName = Path.GetFileNameWithoutExtension(Assembly.GetEntryAssembly().Location);
 
                String usage =
                   @"Usage:" +
                   "{0}{1} delType methodName [Arg1] [Arg2]" +
                   "{0}   where delType must be TwoInt32s or OneString" +
                   "{0}   if delType is TwoInt32s, methodName must be Add or Subtract" +
                   "{0}   if delType is OneString, methodName must be NumChars or Reverse" +
                   "{0}" +
                   "{0}Examples:" +
                   "{0}   {1} TwoInt32s Add 123 321" +
                   "{0}   {1} TwoInt32s Subtract 123 321" +
                   "{0}   {1} OneString NumChars \"Hello there\"" +
                   "{0}   {1} OneString Reverse  \"Hello there\"";
                Console.WriteLine(usage, Environment.NewLine, fileName);
                return;
            }
 
            // 将delType参数转换为一个委托类型
            Type delType = Type.GetType(args[0]);
            if (delType == null)
            {
                Console.WriteLine("Invalid delType argument: " + args[0]);
                return;
            }
 
            Delegate d;
            try
            {
                // 将Arg1参数转换为一个方法
                MethodInfo mi = typeof(Program).GetMethod(args[1], BindingFlags.NonPublic | BindingFlags.Static);
 
                // 创建包装了静态方法的一个委托对象
                d = Delegate.CreateDelegate(delType, mi);
            }
            catch (ArgumentException)
            {
                Console.WriteLine("Invalid methodName argument: " + args[1]);
                return;
            }
 
            // 创建一个数组,其中只包含要通过委托对象传给方法的参数
            Object[] callbackArgs = new Object[args.Length - 2];
 
            if (d.GetType() == typeof(TwoInt32s))
            {
                try
                {
                    // 将String类型的参数转换为Int32类型的参数
                    for (Int32 a = 2; a < args.Length; a++)
                        callbackArgs[a - 2] = Int32.Parse(args[a]);
                }
                catch (FormatException)
                {
                    Console.WriteLine("Parameters must be integers.");
                    return;
                }
            }
 
            if (d.GetType() == typeof(OneString))
            {
                // 只复制String参数
                Array.Copy(args, 2, callbackArgs, 0, callbackArgs.Length);
            }
 
            try
            {
                // 调用委托并显示结果
                Object result = d.DynamicInvoke(callbackArgs);
                Console.WriteLine("Result = " + result);
            }
            catch (TargetParameterCountException)
            {
                Console.WriteLine("Incorrect number of parameters specified.");
            }
        }
 
        // 这个回调方法获取2个Int32类型的参数
        private static Object Add(Int32 n1, Int32 n2)
        {
            return n1 + n2;
        }
 
        // 这个回调方法获取2个Int32类型的参数
        private static Object Subtract(Int32 n1, Int32 n2)
        {
            return n1 - n2;
        }
 
        // 这个回调方法获取1个String类型的参数
        private static Object NumChars(String s1)
        {
            return s1.Length;
        }
 
        // 这个回调方法获取1个String类型的参数
        private static Object Reverse(String s1)
        {
            Char[] chars = s1.ToCharArray();
            Array.Reverse(chars);
            return new String(chars);
        }
    }

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
JS:CDN方式引入Vue-Router
JS:CDN方式引入Vue-Router
18 0
JS:CDN方式引入Vue-Router
JS:CDN方式引入Vue-Router
18 0
JS:CDN方式引入Vue-Router
JS:CDN方式引入Vue-Router
216 0
C# 委托
一、简介   委托是一种类型,由关键字delegate声明。确切的说,委托是一种可用于封装命名或者匿名方法的引用类型。  它类似于 C++ 中的函数指针,而且是类型安全和可靠的。   委托类型的声明与方法签名相似,有一个返回值和任意数目任意类型的参数。
885 0
c# 委托
c# 委托 类似于C++中的函数指针。
746 0
c# 委托
引用:http://xtuhuajx.blog.163.com/blog/static/25504754200851210120611/ using System;using System.Collections.
601 0
+关注
杰克.陈
一个安静的程序猿~
文章
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载