<NET CLR via c# 第4版>笔记 第17章 委托

17.1 初识委托

• .net 通过委托来提供回调函数机制.
• 委托确保回调方法是类型安全的.
• 委托允许顺序调用多个方法.

17.2 用委托回调静态方法

• 将方法绑定到委托时,C# 和 CLR 都允许引用类型的 协变性(covariance) 和 逆变性(contravariance).
• 协变性是指方法能返回从委托的返回类型派生的一个类型.
• 逆变性是方法获取的参数可以是委托的参数类型的基类.
• 只有引用类型才支持协变性与逆变性,值类型或 void 不支持

    delegate object MyCallback(FileStream s);

    //可以应用于委托 MyCallback
    string SomeMethod(Stream s);

    //返回值是值类型,不能应用于委托 MyCallback
    int SomeOtherMethod(Stream s)

17.3 用委托回调实例方法

17.4 委托揭秘

• 编译器看到委托后,会生成一个同名的类,并继承于 System.MulticastDelegate
• System.MulticastDelegate 派生自 System.Delegate
• System.MulticastDelegate的三个重要的非公共字段:
  • target System.Object 当委托对象包装一个静态方法时,这个字段为 null .当委托对象包装一个实例方法时,这个字段引用的是回调方法要操作的对象.
  • methodPtr System.IntPtr 一个内部的整数值, CLR 用它标识要回调的方法.
  • invocationList System.Object 该字段通常为 null, 构造委托链时它引用一个委托数组.

17.5 用委托回调多个方法( 委托链 )

• 使用 Delegate 类的公共静态方法 Combine 将委托添加到链中:

    fbChain=(Feedback) Delegate.Combine(fbChain, fb1);

• 使用 Delegate 类的公共静态方法 Remove 从链中删除委托. 每次 Remove 方法调用只能从链中删除一个委托.

    fbChain=(Feedback) Delegate.Combine(fbChain, fb1);

• 委托public delegate int Feedback(int value) 的 Invoke 的伪代码:

    public int Invoke(int value) {
        int result;
        Delegate[] delegateSet = _invocationList as Delegate[];
        if (delegateSet != null)
        {
            // 这个委托数组指定了应该调用的委托
            foreach (Feedback d in delegateSet)
                result = d(value);  //调用每个委托
        }
        else {  //否则就不是委托链
            //该委托标识了要回调的单个方法,
            //在指定的目标对象上调用这个回调方法
            result = _methodPtr.Invoke(_target,value);
            //上面这行代码接近实际的代码
            //实际发生的事情用C#是表示不出来的
        }
        return result;
    }

17.5.1 C# 对委托链的支持

• c#编译器自动为委托类型的实例重载了+=和-=操作符.这些操作符分别调用 Delegate.Combine 和 Delegate.Remove.

    fbChain += fb1;
    fbChain += fb2;
    fbChain -= fb1;

17.5.2 取得对委托链调用的更多控制

• 可以通过实例方法 GetInvocationList 获取委托链中委托的集合,然后通过自定义算法,显式调用这些委托.

17.6 委托定义不要太多( 泛型委托 )

• 尽量使用 Action<T> 和 Func<T> 委托.需要使用 ref ,out ,params 关键字的地方除外.

17.7 C# 为委托提供的简化语法

• 后面描述的这些只是 C# 的语法糖.

17.7.1 简化语法1: 不需要构造委托对象

• 由于c#编译器能自己进行推断,所以可以省略构造 ThreadPool.QueueUserWorkItem 方法中 WaitCallback 委托对象的代码.

    static void Main(string[] args)
    {
        ThreadPool.QueueUserWorkItem(SomeAsyncTask, 5);
    }

    private static void SomeAsyncTask(object o) {
        Console.WriteLine(o);
    }

17.7.2 简化语法2: 不需要定义回调方法( lambda表达式 )

• C# 允许使用 Lambda 表达式写回调代码,如:

    static void Main(string[] args)
    {
        ThreadPool.QueueUserWorkItem(obj =>Console.WriteLine(obj), 5);
    }

• C# 编译器看到这个 lambda 表达式之后,会在类中自动定义一个新的私有方法,称为匿名函数,如下:

class Program
{
    //创建该私有字段是为了缓存委托对象,
    //优点: 不会每次调用都新建一个对象
    //缺点: 缓存的对象永远不会被垃圾回收
    [CompilerGenerated]
    private static WaitCallback <>9_xxxDelegate1;

    static void Main(string[] args)
    {
        if(<>9_xxxDelegate1==null)
            <>9_xxxDelegate1 = new WaitCallback(<Main>.b_0);

        ThreadPool.QueueUserWorkItem(<>9_xxxDelegate1,5);
    }

    [CompilerGenerated]
    private static void <Main>.b_0(object obj) {
        Console.WriteLine(obj);
    }
}

• 如果调用方法不是静态的,但其内部的 匿名函数 不包含实例成员引用,编译器仍会生成静态匿名函数,因为它的效率比实例方法高; 但如果 匿名函数 的代码确实引用了实例成员,编译器就会生成非静态匿名函数.
• 下面是一些 lambda 表达式的使用范例:

    //如果委托不获取任何参数,就使用()
    Func<string> f = () => "Jeff";

    //如果委托获取一个或更多参数,可显式指定类型
    Func<int, string> f2 = (int n) => n.ToString();
    Func<int, int, string> f3 = (int n1, int n2) => (n1 + n2).ToString();

    //如果委托获取一个或更多参数,编译器可推断类型
    Func<int, string> f4 = (n) => n.ToString();
    Func<int, int, string> f5 = (n1, n2) => (n1 + n2).ToString();

    //如果委托获取一个参数,可省略 ( 和 )
    Func<int, string> f6 = n => n.ToString();

    //如果委托有 ref/out 参数,必须显式指定 ref/out 和类型
    Bar b = (out int n) => n = 5;

    //Bar的定义
    delegate void Bar(out int z);

• 如果主体由两个或多个语句构成,必须用大括号将语句封闭.在用了大括号的情况下,如果委托期待返回值,还必须在主体中添加 return 语句.

17.7.3 简化语法3: 局部变量不需要手动包装到类中即可传给回调方法

示例代码:

    static void Main(string[] args)
    {
        //一些局部变量
        int numToDo = 20;
        int[] squares = new int[numToDo];
        AutoResetEvent done = new AutoResetEvent(false);
        //在其他线程上执行一系列任务
        for (int n = 0; n < squares.Length; n++)
        {
            ThreadPool.QueueUserWorkItem(obj =>
            {
                int num = (int)obj;
                //该任务通常更耗时
                squares[num] = num * num;
                //如果这是最后一个任务,就让主线程继续运行
                if (Interlocked.Decrement(ref numToDo) == 0)
                    done.Set();
            }, n);
        }

        done.WaitOne();

        for (int n = 0; n < squares.Length; n++)
        {
            Console.WriteLine("Index {0} ,Square={1}", n, squares[n]);
        }
    }

• 对于上面代码,C#编译器会定义一个新的辅助类,这个类要为打算传给 回调代码 的每个值都定义一个字段.
• 此外,回调代码 还必须定义成辅助类中的实例方法.
  C#编译器会像下面这样重写代码:

    class Program
    {
        static void Main(string[] args)
        {
            //一些局部变量
            int numToDo = 20;
            WaitCallback callback1 = null;

            //构造辅助类的实例
            <>c_DisplayClass2 class1 = new <>c_DisplayClass2();

            //初始化辅助类的字段
            class1.numToDo = numToDo;
            class1.squares = new int[class1.numToDo];
            class1.done = new AutoResetEvent(false);

            //在其他线程上执行一系列任务
            for (int n = 0; n < class1.squares.Length; n++) {
                if (callback1 == null) {
                    //新建的委托对象绑定到辅助对象及其匿名实例方法
                    callback1 = new WaitCallback(class1.<Main>b_0);
                }

                ThreadPool.QueueUserWorkItem(callback1,n);
            }

            //等待其他所有线程结束运行
            class1.done.WaitOne();

            //显示结果
            for (int n = 0; n < class1.squares.Length; n++) {
                Console.WriteLine("Index {0} ,Square={1}", n, class1.squares[n]);
            }
        }

        //为避免冲突,辅助类被指定了一个奇怪的名称.
        //而且被指定为私有的,禁止从Program类外部访问
        [CompilerGenerated]
        private sealed class <>c_DisplayClass2:Object{
            //回调代码要使用的每个局部变量都有一个对应的公共字段
            public int[] squares;
            public int numToDo;
            public AutoResetEvent done;

            //公共无参构造器
            public <>c_DisplayClass2{}
            
            //包含回调代码的公共实例方法
            public void <Main>b_0(object obj) {
                int num = (int)obj;
                squares[num] = num * num;
                if (Interlocked.Decrement(ref numToDo) == 0)
                    done.Set();
            }
        }
    }

• 作者给自己定了个规则:如果需要在回调方法中包含3行以上的代码,就不使用 lambda 表达式,而是手写一个方法,并为其分配自己的名称.

17.8 委托和反射

可以通过 System.Reflection.MethodInfo 提供的 CreateDelegate 方法,创建一个 Delegate 对象,然后调用该对象的 DynamicInvoke 方法,以实现在运行时动态调用委托.

//下面是一些不同的委托定义
internal delegate object TwoInt32s(int n1, int n2);
internal delegate object OneString(String s1);
static class Program
{
    static void Main(string[] args)
    {
        //如果委托在命名空间下,第一个参数一定要是带命名空间的完全限定名
        //args = new[] { "TwoInt32s", "Add", "1", "11" };

        if (args.Length < 2)
        {
            Console.WriteLine("Usage: TwoInt32s Add 123 321");
            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).GetTypeInfo().GetDeclaredMethod(args[1]);
            //创建包装了静态方法的委托对象
            d = mi.CreateDelegate(delType);
        }
        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 (int a = 2; a < args.Length; a++)
                    callbackArgs[a - 2] = int.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.");
        }
    }


    private static object Add(int n1, int n2)
    {
        return n1 + n2;
    }
    private static object Subtract(int n1, int n2)
    {
        return n1 - n2;
    }
    private static object NumChars(string s1)
    {
        return s1.Length;
    }
    private static object Reverse(string s1)
    {
        return new String(s1.Reverse().ToArray());
    }
}