C#（二十一）：委托 - 组合委托、匿名函数、Lambda、回调

特点

• 是方法类型
• 事件是属于类的成员，所以是要放在类的内部的。而委托，属于一个定义。其实是和类、接口类似的。通常是放在外部的。因为大多数委托都是要被重用的。
• 实例化委托对象需要传入方法来实例化
• 这个方法的​​返回值类型​​​和​​参数列表​​需要和委托保持一致

delegate void FunA();       // 委托的声明

class MainClass
{
    public static void Main(string[] args)
    {
        // 方法类型 - 委托
        // 实例化委托对象需要传入方法来实例化
        // 这个方法的返回值类型和参数列表需要和委托保持一致
        FunA a = new FunA(FunDemo); // => FunA a = FunDemo;
        a(); // FunDemo Show ~
    }

    public static void FunDemo() {
        Console.WriteLine("FunDemo Show ~");
    }
}

委托的使用情景

存在不同角色，每个角色都存在一个F技能，但是每个角色的F技能的表现形式不同

class MainClass
{
    public static void Main(string[] args)
    {
        Hero mengya = new Hero();
        mengya.F = Skill.Jibu;
        mengya.F(); // Jibu - 疾步～

        Hero guiguzi = new Hero();
        guiguzi.F = new SkillDelegate(Skill.Zhiliao);
        guiguzi.F(); // Zhiliao - 治疗～

        Hero dianwei = new Hero
        {
            F = Skill.Chengjie
        };
        dianwei.F(); // Chengjie - 惩戒～
    }
}

delegate void SkillDelegate();          // 声明技能委托

// 英雄类
class Hero {
    public SkillDelegate F;
}

// 技能类
static class Skill {
    public static void Jibu()
    {
        Console.WriteLine("Jibu - 疾步～");
    }

    public static void Chengjie()
    {
        Console.WriteLine("Chengjie - 惩戒～");
    }

    public static void Zhiliao()
    {
        Console.WriteLine("Zhiliao - 治疗～");
    }
}

组合委托 ​​相当于按了一个按键施展多个技能​​

public delegate void SkillDelegate();
    
class MainClass
{
    public static void Main(string[] args)
    {
        SkillDelegate ab = MethodA;

        ab += MethodB;
        ab(); // MethodA Show ~  MethodB Show ~

        ab -= MethodA;
        ab(); // MethodB Show ~

        ab -= MethodA;
        ab(); // MethodB Show ~

        ab -= MethodB;
        Console.WriteLine(ab == null); // True

        ab -= MethodB;
        Console.WriteLine(ab == null); // True
    }

    public static void MethodA()
    {
        Console.WriteLine("MethodA Show ~");
    }

    public static void MethodB()
    {
        Console.WriteLine("MethodB Show ~");
    }
}

匿名函数

class MainClass
{
    delegate int NumberChanger(int n);

    public static void Main(string[] args)
    {

        NumberChanger nc = delegate (int x)
        {
            Console.WriteLine("Anonymous Method: {0}", x);
            return x;
        };

        nc(123);

    }
}

Lambda ​​=>​​

class MainClass
{
    delegate void NumberChanger(int n);

    public static void Main(string[] args)
    {

        // 写法一
        NumberChanger nc1 = delegate (int x)
        {
            Console.WriteLine("Anonymous Method: {0}", x);
        };
        nc1(123);

        // 写法二
        NumberChanger nc2 = (int x) =>
        {
            Console.WriteLine("Anonymous Method: {0}", x);
        };
        nc2(123);

        // 写法三
        NumberChanger nc3 = (int x) => Console.WriteLine("Anonymous Method: {0}", x);
        nc3(123);

        // 写法四
        NumberChanger nc4 = x => Console.WriteLine("Anonymous Method: {0}", x);
        nc4(123);

    }

}

回调

public delegate int Callback(int res);

class MainClass
{
    public static void Main(string[] args)
    {
        FunA(1, 2, Result);
    }

    public static int FunA(int x, int y, Callback callback) {
        int res = x + y;
        return callback(res);
    }

    public static int Result(int res) {
        Console.WriteLine(res);
        return res;
    }

}