委托 事件 协变 逆变

一个匿名函数：传入一个数据，调用这个函数时可以通过再传入一个数据实现两个数据的交互
    System.Action<int> DoPlus(int a)
    {
        return delegate (int b) {
            print(a + b);
        };
    }

    System.Func<int, int> DoPlus2(int a)
    {
        return delegate (int b) {
            return a + b;
        };
    }

 

协变（out）和逆变（in），用来修饰泛型替代符的，只能修饰接口和委托中的泛型

    delegate T DoFunc<out T>(int a);// out 修饰的泛型智能作为返回类型
    DoFunc<string> doFunc;

调用：
        doFunc = delegate (int d) {
            return "input value is: " + d;
        };
        print(doFunc(5));

 

    delegate void DoFunc1<in TR>(TR tr); // void不能改为TR，in修饰符只能作为参数类型
    DoFunc1<string> doFunc1;

调用：
        doFunc1 = delegate (string d) {
            print("input value is: " + d); // 这里就不能用return了
        };
        print(doFunc(5));

 

    delegate T DoFunc2<out T, in TR>(TR tr);
    DoFunc2<string, string> doFunc2;
调用：
        doFunc2 = delegate (string e) {
            return "print string: " + e;
        };
        print(doFunc2("输出一个字符串"));

 

以下资料来源：https://www.bilibili.com/video/BV1Ar4y1K7AK?p=18

out 和 in在修饰泛型时，out 只能作为返回类型，in 智能作为参数类型

遵循里氏替换原则，何以相互装载有父子关系的泛型（协变：父类泛型委托装子类泛型委托，逆变相反）

delegate T Out<out T>();
delegate void In<in T>(T t);

class IBase { }

class ICase : IBase { }

class ITest
{
    ITest()
    {
        // 协变
        Out<ICase> oic = () => { return new ICase(); };
        Out<IBase> oib = oic; // 这就是用父类装载子类
        IBase ib = oib();

        // 逆变
        In<IBase> iib = (value) => { };
        In<ICase> iic = iib;    // 看上去是用子类装载父类
        iic(new ICase());
    }
}