深入理解C#中常见的委托【详细】

客官°小女子只卖身不卖艺 2024-04-01 19:32 130阅读 0赞

#### 深入理解C\#中常见的委托 ####

*   *  C\#之委托
     *   *  1.定义一个委托：
         *  2.定义回调方法：
         *  3.编写一个方法来触发回调函数：
         *  4.定义Counter的方法调用
         *  5. 查看控制台信息
         *  6. 委托链：
         *  7. C\#为委托提供的简化：

### C\#之委托 ###

委托：顾名思义，让别人帮你办件事。委托是C\#实现回调函数的一种机制。可能有人会问了，回调函数是个啥？？？

举个例子：我现在是一家公司的老板，公司现在在招聘.NET工程师，我们有一个小姐姐专门负责接受求职者投递的简历，我就告诉这个小姐姐，一旦收到新的简历就转发给我一份。

这个例子里小姐姐要做的工作：给我转发一份简历（回调函数里的操作），就是一个回调函数的作用。一旦有了满足条件（收到了新的简历），小姐姐就会转发给我（触发回调函数）

用来代码来看看是怎么实现的：

#### 1.定义一个委托： ####

【修饰符】 delegate 【返回类型】 【委托名称】 (【参数列表】)

// 定义委托，这个委托需要获取一个int型参数，返回void
          internal delegate void Feedback(int value);

#### 2.定义回调方法： ####

这里定义了两个方法，一个静态，一个实例。正好看看调用方式的不同。注意：定义的回调方法签名必须和委托对象一致（这里都是int 类型参数，没有返回值。这么说也不全对，涉及到协变和逆变。这里就不解释这俩了），这是因为将方法绑定到委托时，编译器会检测他们的兼容性。不符合的话回报编译错误。就比如有一个方法要传入String类型，我们给它传递了一个int类型一样。

这里为了方便演示就只把数字打印在了控制台。

/// <summary>
            /// 静态回调方法
            /// </summary>
            /// <param name="value"></param>
            private static void FeedbackToConsole(int value)
            {
        
                // 依次打印数字
                Console.WriteLine("Item=" + value);
            }
            /// <summary>
            /// 实例回调方法
            /// </summary>
            /// <param name="value"></param>
            private void InstanceFeedbackToConsole(int value)
            {
        
                Console.WriteLine("Item=" + value);
            }

#### 3.编写一个方法来触发回调函数： ####

有三个参数：前两个做循环使用，后一个接收定义的委托对象。内部代码循环调用回调方法 fb(val)的写法，其实就是相当于要调用的函数。例：

FeedbackToConsole（val)

/// <summary>
            /// 使用此方法触发委托回调
            /// </summary>
            /// <param name="from">开始</param>
            /// <param name="to">结束</param>
            /// <param name="fb">委托引用</param>
            private static void Counter(int from,int to, Feedback fb)
            {
        
                for (int val = from; val <= to; val++)
                {
        
                    // fb不为空，则调用回调方法
                    if (fb != null)
                    {
        
                        fb(val);
                    }
                    //fb?.Invoke(val); 简化版本调用
                }
            }

#### 4.定义Counter的方法调用 ####

第一次调用Counter，传递Null，在回调方法里有一步判空操作，所以是不回调用回调函数的。第二个Counter调用正常传递参数，构造一个委托对象并绑定了一个方法

/// <summary>
            /// 静态调用
            /// </summary>
            private static void StaticDelegateDemo()
            {
        
                Console.WriteLine("---------委托调用静态方法------------");
                Counter(1, 10, null);
                Counter(1, 10, new Feedback(FeedbackToConsole));
            }
            /// <summary>
            /// 实例调用
            /// </summary>
            private static void InstanceDelegateDemo()
            {
        
                Console.WriteLine("---------委托调用实例方法------------");
                Program p = new Program();
                Counter(1, 10, null);
                Counter(1, 5, new Feedback(p.InstanceFeedbackToConsole));
            }

#### 5. 查看控制台信息 ####

完整代码：

class Program
        {
        
            // 定义委托，并引用一个方法，这个方法需要获取一个int型参数返回void
            internal delegate void Feedback(int value);
            static void Main(string[] args)
            {
        
                StaticDelegateDemo();
                InstanceDelegateDemo();
                Console.ReadKey();
            }
            /// <summary>
            /// 静态调用
            /// </summary>
            private static void StaticDelegateDemo()
            {
        
                Console.WriteLine("---------委托调用静态方法------------");
                Counter(1, 10, null);
                Counter(1, 10, new Feedback(FeedbackToConsole));
     
            }
            /// <summary>
            /// 实例调用
            /// </summary>
            private static void InstanceDelegateDemo()
            {
        
                Console.WriteLine("---------委托调用实例方法------------");
                Program p = new Program();
                Counter(1, 10, null);
                Counter(1, 5, new Feedback(p.InstanceFeedbackToConsole));
            }
     
            /// <summary>
            /// 静态回调方法
            /// </summary>
            /// <param name="value"></param>
            private static void FeedbackToConsole(int value)
            {
        
                // 依次打印数字
                Console.WriteLine("Item=" + value);
            }
            /// <summary>
            /// 实例回调方法
            /// </summary>
            /// <param name="value"></param>
            private void InstanceFeedbackToConsole(int value)
            {
        
                Console.WriteLine("Item=" + value);
            }
        }

启动控制台：可以看到已经成功把数字打印出来了

![在这里插入图片描述][309d1e1699a14bac86917084cd7a88b2.png]

#### 6. 委托链： ####

委托链是委托对象的集合。可以利用委托链调用集合中的委托所绑定的全部方法。继续在原有的基础上添加委托链的方法。

新添加的两个方法本质上没有区别都是对委托链的实现，不同的是写法，明显是第二个方法更加精简一些。这是因为C\#编译器重载了+=和-=操作符，这两个操作符分别调用Combine和Remove。

/// <summary>
            /// 委托链调用 1
            /// </summary>
            /// <param name="p"></param>
            private static void ChainDelegateDemo(Program p)
            {
        
                Console.WriteLine("---------委托链调用1------------");
                Feedback fb1 = new Feedback(FeedbackToConsole);
                Feedback fb2 = new Feedback(p.InstanceFeedbackToConsole);
                Feedback fbChain = null;
                fbChain = (Feedback)Delegate.Combine(fbChain, fb1);
                fbChain = (Feedback)Delegate.Combine(fbChain, fb2);
                Counter(1, 3, fbChain);
                Console.WriteLine();
                fbChain = (Feedback)Delegate.Remove(fbChain, new Feedback(FeedbackToConsole));
                Counter(1, 3, fbChain);
            }
            /// <summary>
            /// 委托链调用 2
            /// </summary>
            /// <param name="p"></param>
            private  static void ChainDelegateDemo2(Program p)
            {
        
                Console.WriteLine("---------委托链调用2------------");
                Feedback fb1 = new Feedback(FeedbackToConsole);
                Feedback fb2 = new Feedback(p.InstanceFeedbackToConsole);
                Feedback fbChain = null;
                fbChain += fb1;
                fbChain += fb2;
                Counter(1, 3, fbChain);
                Console.WriteLine();
                fbChain -= new Feedback(FeedbackToConsole);
                Counter(1, 2, fbChain);
            }

在Main方法添加对委托链的调用：

static void Main(string[] args)
            {
        
                Program p = new Program();
                StaticDelegateDemo();
                InstanceDelegateDemo();
                ChainDelegateDemo(p);
                ChainDelegateDemo2(p);
                Console.WriteLine("Hello World!");
                Console.ReadKey();
            }

启动项目：

![在这里插入图片描述][9bb495235d0e469fbce081488b8e8eba.png]

#### 7. C\#为委托提供的简化： ####

**7.1 不需要构造委托对象：**  
之前的代码：

Counter(1, 10, new Feedback(FeedbackToConsole));

构造了一个委托对象并传递给Counter方法，由于C\#编译器能自己推断。所以可以省略构造委托对象，直接传递方法。使代码的可读性更佳，也更容易理解。

简化后的代码：

/// <summary>
            /// 静态调用
            /// </summary>
            private static void StaticDelegateDemo()
            {
        
                Console.WriteLine("---------委托调用静态方法------------");
                Counter(1, 10, null);
                //Counter(1, 10, new Feedback(FeedbackToConsole));
                Counter(1, 10, FeedbackToConsole);
     
            }

可以看到效果是一样的：

![在这里插入图片描述][71eed5bfd68a424f9a691b9e2594c38c.png]

**7.2 简化语法：不需要定义回调方法（以lambda表达式实现）**  
在前面的代码中定义了一个回调方法：

现在以lambda表达式方式实现：

/// <summary>
            /// 静态调用
            /// </summary>
            private static void StaticDelegateDemo()
            {
        
                Console.WriteLine("---------委托调用静态方法------------");
                Counter(1, 10, null);
                //Counter(1, 10, new Feedback(FeedbackToConsole));
                //Counter(1, 10, FeedbackToConsole);
                Counter(1, 10, value => Console.WriteLine(value));
            }

lambda表达式实际上是一个匿名函数。编译器在看到lambda之后会在类中自动定义一个新的私有方法。类似于之前写的回调方法FeedbackToConsole（）。lambda必须匹配委托！

lambda的语法： 参数 => 方法体。

=>左边是要传入的参数，本例中是传入一个Int类型的变量，=>右边是具体的代码，相当于FeedbackToConsole（），\{\}中所做的操作

一些规则：

如果不传递参数： ()=>Console.WriteLine(“Hello World!”)

传递一个参数：(int n)=>Console.WriteLine(n.ToString()) 或者去掉（）和int 编译器会自己推断类型：n=>Console.WriteLine(n.ToString())

传递多个参数：(int n ,int m)=>Console.WriteLine(n.ToString()) 或者编译器自己推断类型：（n , m）=>Console.WriteLine(n.ToString())

注：如果有一个方法需要多处调用或者方法里面的代码量较多。还是单独写一个方法较为理想。

最后看一下换成lambda的写法结果显示是否一样  
![在这里插入图片描述][d4167b8a49804dcbbedc4ee1931a2e51.png]

全部代码：

class Program
        {
        
            // 定义委托，并引用一个方法，这个方法需要获取一个int型参数返回void
            internal delegate void Feedback(int value);
            static void Main(string[] args)
            {
        
                Program p = new Program();
                StaticDelegateDemo();
                InstanceDelegateDemo();
                ChainDelegateDemo(p);
                ChainDelegateDemo2(p);
                Console.WriteLine("Hello World!");
                string[] names = {
         "Jeff", "Jee", "aa", "bb" };
                //char find = 'e';
                //names= Array.FindAll(names, name => name.IndexOf(find) >= 0);
                //Array.ForEach(names, Console.WriteLine);
                Console.ReadKey();
            }
            /// <summary>
            /// 静态调用
            /// </summary>
            private static void StaticDelegateDemo()
            {
        
                Console.WriteLine("---------委托调用静态方法------------");
                Counter(1, 10, null);
                //Counter(1, 10, new Feedback(FeedbackToConsole));
                //Counter(1, 10, FeedbackToConsole);
                Counter(1, 10, value => Console.WriteLine(value));
            }
            /// <summary>
            /// 实例调用
            /// </summary>
            private static void InstanceDelegateDemo()
            {
        
                Console.WriteLine("---------委托调用实例方法------------");
                Program p = new Program();
                Counter(1, 10, null);
                Counter(1, 5, new Feedback(p.InstanceFeedbackToConsole));
            }
            /// <summary>
            /// 委托链调用 1
            /// </summary>
            /// <param name="p"></param>
            private static void ChainDelegateDemo(Program p)
            {
        
                Console.WriteLine("---------委托链调用1------------");
                Feedback fb1 = new Feedback(FeedbackToConsole);
                Feedback fb2 = new Feedback(p.InstanceFeedbackToConsole);
                Feedback fbChain = null;
                fbChain = (Feedback)Delegate.Combine(fbChain, fb1);
                fbChain = (Feedback)Delegate.Combine(fbChain, fb2);
                Counter(1, 3, fbChain);
                Console.WriteLine();
                fbChain = (Feedback)Delegate.Remove(fbChain, new Feedback(FeedbackToConsole));
                Counter(1, 3, fbChain);
            }
            /// <summary>
            /// 委托链调用 2
            /// </summary>
            /// <param name="p"></param>
            private  static void ChainDelegateDemo2(Program p)
            {
        
                Console.WriteLine("---------委托链调用2------------");
                Feedback fb1 = new Feedback(FeedbackToConsole);
                Feedback fb2 = new Feedback(p.InstanceFeedbackToConsole);
                Feedback fbChain = null;
                fbChain += fb1;
                fbChain += fb2;
                Counter(1, 3, fbChain);
                Console.WriteLine();
                fbChain -= new Feedback(FeedbackToConsole);
                Counter(1, 2, fbChain);
            }
            /// <summary>
            /// 使用此方法触发委托回调
            /// </summary>
            /// <param name="from">开始</param>
            /// <param name="to">结束</param>
            /// <param name="fb">委托引用</param>
            private static void Counter(int from,int to, Feedback fb)
            {
        
                for (int val = from; val <= to; val++)
                {
        
                    // fb不为空，则调用回调方法
                    if (fb != null)
                    {
        
                        fb(val);
                    }
                    //fb?.Invoke(val); 简化版本调用
                }
            }
            /// <summary>
            /// 静态回调方法
            /// </summary>
            /// <param name="value"></param>
            private static void FeedbackToConsole(int value)
            {
        
                // 依次打印数字
                Console.WriteLine("Item=" + value);
            }
            /// <summary>
            /// 实例回调方法
            /// </summary>
            /// <param name="value"></param>
            private void InstanceFeedbackToConsole(int value)
            {
        
                Console.WriteLine("Item=" + value);
            }
        }

[309d1e1699a14bac86917084cd7a88b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/a4c011f88963479eb978178bf689c431.png
[9bb495235d0e469fbce081488b8e8eba.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d77a7a062f114250b992ac15ed60b6ad.png
[71eed5bfd68a424f9a691b9e2594c38c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/504058a84d2b41969ae8ab8bf342aa6f.png
[d4167b8a49804dcbbedc4ee1931a2e51.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/e8fad146d4ad40a8ab3b367c9a6b142e.png