C#难点语法讲解之委托---从应用需求开始讲解

一、委托的定义

委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。

简单解释：变量好控制，方法不好控制，委托可以把方法变成变量

二、例子解释定义

如果我们有一个数组,里面有10个数据：（数组就是变量的一种）

int[] num = new int[10] {0,1,2,3,4,5,6,7,8,9};

现在，我们想把它们每个都输出一遍，我们可以：

   public void OutPut()
    {
        foreach (int item in num)
        {
            Console.WriteLine(item);
        }
    }

那如果我们有十个方法：

 public void Fun0() 
    {
        Console.WriteLine(0);
    }
    public void Fun1()
    {
        Console.WriteLine(1);
    }
    public void Fun2()
    {
        Console.WriteLine(2);
    }
    public void Fun3()
    {
        Console.WriteLine(3);
    }
    public void Fun4()
    {
        Console.WriteLine(4);
    }
    public void Fun5()
    {
        Console.WriteLine(5);
    }
    public void Fun6()
    {
        Console.WriteLine(6);
    }
    public void Fun7()
    {
        Console.WriteLine(7);
    }
    public void Fun8()
    {
        Console.WriteLine(8);
    }
    public void Fun9()
    {
        Console.WriteLine(9);
    }

现在，我们想把它们每个都用一遍，我们就得：

    public void OutPut()
    {
        Fun0();
        Fun1();
        Fun2();
        Fun3();
        Fun4();
        Fun5();
        Fun6();
        Fun7();
        Fun8();
        Fun9();
    }

如果，这时候，你觉得还好，那需求如果继续变化：

1.周一希望执行方法2、4、6、8

2.周二想执行方法1、3、5、7

3.周三想执行方法0、1、2、3、4

4.周四想执行方法5、6、7、8、9

5.周五我希望在这10个方法里，随机抽取两个方法执行

就问你难不难受，你要写好几组

如果这时候，他和数组一样，就很好写了（这就是变量比方法好用的地方）

三、把方法做成变量

整数是int

字符串是string

方法是 delegate

四、把一个已经有的方法和delegate联系起来

1.联系一个普通方法

 public void Fun0() 
    {
        Console.WriteLine(0);
    }

我们需要让这个委托长得和这个普通的方法一样

public delegate void Apple();

    public void Fun0() 
    {
        Console.WriteLine(0);
    }

这里的格式指的是：括号里有没有参数，有没有返回值

为什么要给委托起名字？

因为你可能建很多委托啊，有参数的，没参数的，需要return的，不需要return的。

例（有参数的）：

    //方法
    public void Fun1(string s)
    {
        Console.WriteLine(1);
    }

    //建立委托（抄方法的格式）
    public delegate void Apple1(string s);


    //把委托和方法联系起来
    public void OutPut()
    {
        Apple1 apple1 = Fun1;
    }

例（有两个参数的）：

    //方法
    public void Fun2(string s,string s1)
    {
        Console.WriteLine(1);
    }
    
    //建立委托（抄方法的格式）
    public delegate void Apple2(string s, string s1);

    //把委托和方法联系起来
    public void OutPut()
    {
        Apple2 apple2 = Fun2;
    }

例（有返回值的）：

不需要参数咱就把参数删了就行，相信大家都是灵活的宝宝~~

    //方法
    public int Fun3(string s,string s1)
    {
        Console.WriteLine(1);
        return 1;     
    }

    //建立委托（抄方法的格式）
    public delegate int Apple3(string s, string s1);

    //把委托和方法联系起来 
    public void OutPut()
    {
        Apple3 apple2 = Fun3;
    }

五、委托应用

回到我们最开始的故事，我们用委托，就可以把方法当变量了

（注意，这些方法格式是一样的，都是无返回值，无参数）

方法，还是那10个方法，委托还是那个委托

public delegate void Apples();
 
public void Fun0()
    {
        Console.WriteLine(0);
    }
    public void Fun1()
    {
        Console.WriteLine(1);    
    }
    public void Fun2()
    {
        Console.WriteLine(2);
    }
    public void Fun3()
    {
        Console.WriteLine(3);
    }
    public void Fun4()
    {
        Console.WriteLine(4);
    }
    public void Fun5()
    {
        Console.WriteLine(5);
    }
    public void Fun6()
    {
        Console.WriteLine(6);
    }
    public void Fun7()
    {
        Console.WriteLine(7);
    }
    public void Fun8()
    {
        Console.WriteLine(8);
    }
    public void Fun9()
    {
        Console.WriteLine(9);
    }

我们可以搞个委托数组，把这些方法都放进去 

    public void OutPut()
    {
    //委托数组，Apples是之前建立的按Fun方法写的委托
        Apples[] apples =new Apples[10];

        apples[0] = Fun0;
        apples[1] = Fun1;
        apples[2] = Fun2;
        apples[3] = Fun3;
        apples[4] = Fun4;
        apples[5] = Fun5;
        apples[6] = Fun6;
        apples[7] = Fun7;
        apples[8] = Fun8;
        apples[9] = Fun9;
    }

开始用啦!!!!!快乐来了

 public void OutPut()
    {
        Apples[] apples =new Apples[10];

        apples[0] = Fun0;
        apples[1] = Fun1;
        apples[2] = Fun2;
        apples[3] = Fun3;
        apples[4] = Fun4;
        apples[5] = Fun5;
        apples[6] = Fun6;
        apples[7] = Fun7;
        apples[8] = Fun8;
        apples[9] = Fun9;


        //执行Fun0-4
        for (int i = 0; i < 5; i++)
        {
            apples[i]();
        }

        //执行Fun5-9
        for (int i = 5; i < 10; i++)
        {
            apples[i]();
        }


        //执行Fun1-3-5-7-9
        for (int i = 1; i < 10; i=i+2)
        {
            apples[i]();
        }
    }

就不往多的写了，意思就是这个意思，我们可以把方法当参数了，与此同时，你也可以搞list，也可以在括号里传递委托，等等等等，，，如果有疑问，请写在评论区，我会继续补充修改的~