变体接口中的变体委托。使困惑

早些时候我对接口的差异有了很好的理解。现在我对变体接口中委托的差异有点困惑。方法、属性、索引器和事件可以在接口中定义。变体接口中的方法、属性和索引器的签名是直接的。而事件却发生了逆转。

我不明白为什么返回值方法可以在协变接口中工作，但类似的委托签名却不起作用。不应该返回任何内容的逆变委托有效。逆变接口也是如此。

代码如下：

namespace ConsoleApp1
{
    delegate T MyDelegateReturn<out T>();
    delegate void MyDelegateTake<in T>(T t);

    interface IMyInterfaceReturn<out T>
    {
        T MyMethodReturn(); //signature with return value and interface with keyword out - ok

        //event MyDelegateReturn<T> MyEventReturn; //delegate signature with return value but is error CS1961

        event MyDelegateTake<T> MyEventTake; //delegate signature with take parameter but why it is work?
    }

    interface IMyInterfaceTake<in T>
    {
        void MyMethodTake(T t); //signature with take argument and interface with keyword in - ok

        //event MyDelegateTake<T> MyEventTake; //delegate signature with take parameter but is  error CS1961

        event MyDelegateReturn<T> MyEventReturn; //delegate signature with return value but why it is work?
    }

    class MyClass<T> : IMyInterfaceReturn<T>, IMyInterfaceTake<T>
    {
        public event MyDelegateTake<T> MyEventTake;
        public event MyDelegateReturn<T> MyEventReturn;

        public T MyMethodReturn()
        {
            return default;
        }

        public void MyMethodTake(T t)
        {

        }
    }

    class A
    {

    }

    class B : A
    {

    }

    class Program
    {
        static void Main(string[] args)
        {
            B MyMethodReturn()
            {
                return default;
            }

            void MyMethodTake(A i)
            {

            }

            MyClass<B> myClass1 = new MyClass<B>();
            myClass1.MyEventTake += MyMethodTake;

            MyClass<A> myClass2 = new MyClass<A>();
            myClass2.MyEventReturn += MyMethodReturn;
        }
    }
}

规则是事件的类型必须是输入安全。这与方法参数相同。这是有道理的，因为当您在界面减速中声明事件时，您实际上是在声明一对add and remove访问器，看起来像这样：

void add_MyEventTake(MyDelegateTake<T> value);
void remove_MyEventTake(MyDelegateTake<T> value);

当你使用时这些将会被调用+= and -=关于活动。

因此，为了简化事情，我们将考虑接受的方法MyDelegateTake and MyDelegateReturn.

interface IMyInterfaceReturn<out T>
{
    T Get();
    void add_MyEventTake(MyDelegateTake<T> t);

}

有一个section https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/interfaces#variance-safety在描述规则的 C# 规范中。如果您愿意，您可以查看规则，但我会尝试更直观地解释这一点。

在本节的最后，描述了如何直观地解释“输入安全”和“输出安全”：

直观地，在输出位置禁止输出不安全类型，并且在输入位置禁止输入不安全类型。

如果类型不是输出不安全，则它是输出安全的；如果它不是输入不安全，则它是输入安全。

In IMyInterfaceReturn, T是协变的，因此输出安全，因此只能在“输出位置”使用。我现在将显示该参数MyDelegateTake<T>确实是一个“输出位置”。

假设你有一个实现IMyInterfaceReturn<string> called Foo:

class Foo : IMyInterfaceReturn<string>
{
    public void add_MyEventTake(MyDelegateTake<string> t)
    {
        t(Get());
    }

    public string Get()
    {
        return "Something produced by Foo";
    }
}

您可以使用Foo像这样：

var foo = new Foo();
foo.add_MyEventTake(str => /* do something with str */);

你不同意吗str是某种“输出”Foo？上面的代码实际上就是以下内容，但以一种更间接的方式：

var foo = new Foo();
var str = foo.Get();
// do something with str...

因此，可以得出T处于输出位置，您可以安全地执行诸如分配之类的操作foo到一个类型的变量IMyInterfaceReturn<object>.

If add_MyEventTake took a MyDelegateReturn然而，add_MyEventTake将是一个consumer of T, and T将处于输入位置。Foo可以这样使用：

var foo = new Foo();
foo.add_MyEventTake(() => "Some Input For Foo!");
// this is just a roundabout way of doing:
foo.add_MyEventTake("Some Input Fo Foo!");

并假设Foo是这样实现的：

class Foo : IMyInterfaceReturn<string>
{
    private string s;

    public void add_MyEventTake(MyDelegateReturn<string> t)
    {
        s = t();
    }

    public string Get()
    {
        return s.ToUpper();
    }
}

那么这段代码就会崩溃：

IMyInterfaceReturn<object> foo = new Foo();
foo.add_MyEventTake(() => new object());
foo.Get(); // what would this do? object has no ToUpper!?