C# 底层委托问题

Question

在阅读 SO 中的以下问题后，我正在深入研究委托方差： Delegate.CreateDelegate() 和泛型：绑定到目标方法时出错

我在 Barry kelly 找到了一段非常好的代码 https://www.blogger.com/comment.g?blogID= 8184237816669520763&postID=2109708553230166434

这是（以加糖的形式:-）

using System;

namespace ConsoleApplication4
{
    internal class Base
    {
    }

    internal class Derived : Base
    {
    }

    internal delegate void baseClassDelegate(Base b);

    internal delegate void derivedClassDelegate(Derived d);


    internal class App
    {
        private static void Foo1(Base b)
        {
            Console.WriteLine("Foo 1");
        }

        private static void Foo2(Derived b)
        {
            Console.WriteLine("Foo 2");
        }

        private static T CastDelegate<T>(Delegate src)
            where T : class
        {
            return (T) (object) Delegate.CreateDelegate(
                                    typeof (T),
                                    src.Target,
                                    src.Method,
                                    true); // throw on fail
        }

        private static void Main()
        {
            baseClassDelegate a = Foo1; // works fine

            derivedClassDelegate b = Foo2; // works fine

            b = a.Invoke; // the easy way to assign delegate using variance, adds layer of indirection though

            b(new Derived());

            b = CastDelegate<derivedClassDelegate>(a); // the hard way, avoids indirection

            b(new Derived());
        }
    }
}

除了这一行（看起来很简单）之外，我理解所有内容。

b = a.调用； // 使用方差分配委托的简单方法，增加了间接层，但

谁能告诉我：

1. 如何在不传递静态函数所需的参数的情况下调用调用。
2. 当您分配调用调用的返回值时，什么时候会发生
3. Barry 的额外间接含义是什么（在他的评论中）

Answer 1

他没有调用 Invoke（请注意缺少 ()），而是使用隐式委托创建将 b 设置为等于新的 >衍生类代理实例，指向a的Invoke方法。额外的间接是，当调用 b 时，它会调用 a.Invoke(new Derived()) 而不仅仅是 a(new Derived())代码>.

为了使实际发生的情况更加明确：

baseClassDelegate a = Foo1; // works fine 

derivedClassDelegate b = Foo2; // works fine 

b = new derivedClassDelegate(a.Invoke); // the easy way to assign delegate using variance, adds layer of indirection though 

b(new Derived());

b = CastDelegate<derivedClassDelegate>(a); // the hard way, avoids indirection 

b(new Derived());

第一次调用 b 会产生这样的链（为简单起见，省略了参数）：

b() -> a.Invoke() -> Foo1()

第二次调用 b 会产生这样的结果：

b() -> Foo1()

<然而，

仅当您需要一个签名的委托来调用另一个（限制较少的）签名的委托时，才需要这样做。在他的示例中，您只需设置 b = Foo1 即可编译，但这并不能说明问题。