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

灰太狼 2023-10-15 19:05 16阅读 0赞

#### 一、委托的定义 ####

**委托（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);
        }

![d18171a82bd2476b9ceb08a0810ac9d8.png][]

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

**为什么要给委托起名字？**

因为你可能建很多委托啊，有参数的，没参数的，需要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，也可以在括号里传递委托，等等等等，，，如果有疑问，请写在评论区，我会继续补充修改的~

[d18171a82bd2476b9ceb08a0810ac9d8.png]: https://img-blog.csdnimg.cn/d18171a82bd2476b9ceb08a0810ac9d8.png