委托

委托的作用

1. 指定函数的类型，当作参数传入另一个函数。
   这时的作用与C++函数指针的作用有所不同。此时委托虽然表示函数类型，把对应类型的函数当作参数传入，但是不能利用委托来创建函数。
2. 用于函数与对象的动态绑定函数。

一。当作函数的类型

注意此处的函数类型就是指函数的参数类型

我们先利用枚举写一段代码，再想想如何优化它。

1.代码的作用：实现用不同的语言对一个人打招呼。枚举定义了它有多少种语言类型。

enum language //枚举类型，列出所有的可能出现的语言情况
    {
        Chinese,
        American,
        Japanese
    };
    class Class1
    {
        public static void Greet(string name, language lan)//传入语言类型
        {

            if (lan == language.Chinese)
                ChineseGreet(name);
            else if (lan == language.American)
                AmericanGreet(name);
            else if (lan == language.Japanese)
                JapaneseGreet(name);
        }
        public static void ChineseGreet(string name)
        { Console.WriteLine("你好!{0}", name); }
        public static void AmericanGreet(string name)
        { Console.WriteLine("Hello!{0}", name); }
        public static void JapaneseGreet(string name)
        { Console.WriteLine("こんにちは！{0}", name); }

        static void Main(string[] args)
        {
            //为什么需要用枚举，而不是传入一个字符串，根据字符串来判断
            //若把语言参数类型改成字符串，无法控制传入的字符串是否有效。
            //枚举把可用的语言都列举出来，从而保证了传入参数的有效性。
            Greet("李华",language.Chinese);
            Greet("Sam", language.American);
            Greet("きとう ももな", language.Japanese);
            Console.ReadLine();

        }

2. 通过if else语句对传入的语言类型进行判断，代码太长了吧。我们再来看看python语法中的一个例子。通过高阶函数，对应的函数名作为参数传入。

#实现使用不同国家的语言，进行打招呼
#利用高阶函数，把函数作为Greet函数的参数
def Greet(name,fun):#高阶函数
    fun(name)

def ChineseGreet(name):#中文
    print("你好！{0}".format(name))
def AmericanGreet(name):#英语
    print("Hello!{0}".format(name))
def JapaneseGreet(name):#日文
    print("こんにちは！{0}".format(name))

def main():
    Greet("王工",ChineseGreet)
    Greet("Sam",AmericanGreet)
    Greet("きとう ももな", JapaneseGreet)

if __name__=="__main__":
    main()

3这种方法看着要简单的多也自然的多，在打招呼函数直接传入了用什么函数来打招呼，把函数作为参数传入另一个函数，这叫做高阶函数
<1>python可以这样做是因为他们对于函数的参数类型没有要求
可以传入任意类型的变量作为函数参数。
<2>然而C#却不能以此类推，C#函数的参数在定义时就必须给定类型，对于普通的字段可以有int，double等等或者自定义类型，但是对于函数在我们认知的领域没有办法作为参数传入，即使有办法当成参数使用也必须规定他的类型。
4.委托的作用之一就是规定函数的类型，不同的函数除了函数名如何能把它们归类呢？没错函数参数类型、数量和返回类型可以区分函数。（注意此处返回类型也参与到函数类型的规定中，与函数重载时的函数类型有差别）
5.语法
<1>修饰符 delegate 返回类型 委托名（参数1的类型，参数2的类型,…） 可以直接在命名空间中使用，不一定必须要在类中。
<2>**函数名（参数1类型 形参1，…,委托名 形参）**用来把一个函数当作另一个函数的参数。

    class Program
    {
        public delegate void Language(string name);//定义委托，一种函数的类型
        public static void Greet(string name, Language language)
        {
            language(name);//langeuage函数必须是以strng作为参数，并且返回值为void
        }
        public static void ChineseGreet(string name)
        { Console.WriteLine("你好!{0}", name); }
        public static void AmericanGreet(string name)
        { Console.WriteLine("Hello!{0}", name); }
        public static void JapaneseGreet(string name)
        { Console.WriteLine("こんにちは！{0}", name); }
        static void Main1(string[] args)
        {
            Greet("李华",ChineseGreet);
            Greet("Sam", AmericanGreet);
            Greet("きとう ももな", JapaneseGreet);
            Console.ReadLine();
            
        }
    }

这种方法增加了代码的可扩展性。如果哪天有更多的语言类型加进来了，我们不需要像第一次的代码一样进行判断并且输入，只需要再写一个像ChineseGreet，AmericanGreet一样的方法传入就行了。

二。用委托为对象动态绑定函数

以上的层面都是基于函数层面，如果我们要创建一个People对象，用来表示一个人。不同国家的人有不同 的打招呼方式。
1.不就是为对象里的Greet方法传一个参数就行了嘛，这个参数表示用什么方法打招呼。

public delegate void language1(string name);//表示函数类型
    class People
    {
        public string name;
        public People(string name)//构造函数
        {
            this.name = name;
        }
        public void Greet(language1 lang)//根据参数进行打招呼
        {lang(this.name);}
    }
    class _1
    {
        public static void ChineseGreet(string name)
        { Console.WriteLine("你好!{0}", name); }
        public static void AmericanGreet(string name)
        { Console.WriteLine("Hello!{0}", name); }
        public static void JapaneseGreet(string name)
        { Console.WriteLine("こんにちは！{0}", name); }

        static void Main(string[] args)
        {
            //对不同国家的人传入不同的语言方法
            People Chinese1 = new People("李华");
            Chinese1.Greet(ChineseGreet);
            People American1 = new People("Sam");
            American1.Greet(AmericanGreet);
            People Japanese1 = new People("きとう ももな");
            Japanese1.Greet(JapaneseGreet);
            Console.ReadLine();
        }
    }

2.思考上面的对象有什么问题，每次打招呼都要传入语言函数，多麻烦哟。
可不可以使语言函数有字段的特征，存储在对象的一个变量中，可以在外部修改。同时还可以有函数的功能，能够被调用。
这是用到了委托的第二个作用。
3.语法
<1>创建委托：修饰符 delegate 返回类型 委托名（参数1的类型，参数2的类型,…）
<2>在对象中声明一个委托指针：修饰符 委托名 委托指针名
<3>使委托的指针指向一个函数：对象.委托实例名=函数名 使得委托指针指向一个函数。或者对象.委托实例名=new 委托类型（函数名）
<4>使用方法：if(委托指针！=null)委托指针需要判断一个委托指针是否有指向的东西，一个委托指针可以指向多个函数，只要函数参数符合委托类型的规定。指针被调用了，相当于所有函数按顺序都调用了。
<5>给委托指针指向多个函数,叫做多播代理。
**对象.委托指针+=函数。**也可以通过-=减去已经有的代理
4.修改后的实例

 public delegate void language2(string name);//表示函数类型
    class People2
    {
        public string name;
        public  language2 lang;//用委托类型创建一个委托实例
        public People2(string name)//构造函数
        {
            this.name = name;
        }
        public void Greet()//根据参数进行打招呼
        {
            if (lang != null)
                lang(name);// lang?.Invoke(name);这是一种简化的调用方法

        }//使用委托实例，像函数一样使用
    }
    class Test
    {
        public static void ChineseGreet(string name)
        { Console.WriteLine("你好!{0}", name); }
        public static void AmericanGreet(string name)
        { Console.WriteLine("Hello!{0}", name); }
        public static void JapaneseGreet(string name)
        { Console.WriteLine("こんにちは！{0}", name); }

        static void Main(string[] args)
        {
            //对不同国家的人传入不同的语言方法
            People2 Chinese1 = new People2("李华")
            {
                lang = ChineseGreet//为委托实例绑定一个函数
                //或者lang=new language2（Chinese.Greet）
            };//(创建对象指定参数)
            Chinese1.Greet();//不用传入参数就可以使用了

            People2 American1 = new People2("Sam")
            {
                lang = AmericanGreet
            };
            American1.Greet();

            People2 Japanese1 = new People2("きとう ももな")
            {
                lang = JapaneseGreet
            };
            Japanese1.Greet();
            Console.ReadLine();

        }
    }

委托的协变与逆变

思考一下，创建委托类型时指定了参数类型和返回类型。委托指针指向的必须是参数类型一模一样的吗？
当然不是

1. 委托的协变：委托指针指向的函数返回类型可以是委托指定类型或者它的基类
2. 委托的逆变：委托指针指向的函数参数可以是委托指定类型或者它的子类。

复习：
1.委托类型用作函数参数类型便于传参。
2.用委托类型声明委托指针，指向一个函数。
3.使用委托指针调用所有被委托的函数。有多个函数时称为多播委托。
4.添加委托指针指向的函数
5.委托的协变和逆变