C# 委托详解

已于 2022-08-29 01:16:19 修改
阅读量993 收藏 15
点赞数
分类专栏： Java / C# / MySql 文章标签： c# 开发语言
于 2022-08-29 01:14:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56651882/article/details/126570417
版权

通过 刘铁锰老师的 C# 入门详解中委托详解 记录学习，讲得真的非常好

目录

1. 什么是委托

1.1 一切皆地址

程序 = 数据结构 + 算法。
数据结构也就是存放 数据 的结构，比如最常用的数组、哈希表、链表等。
算法我目前的理解是尽量减少一个 方法 的时间复杂度，比如排序算法中冒泡排序的时间复杂度为 O(N^2)，而快排的时间复杂度为O(log2n)，显然，冒泡排序的时间复杂度高于快排。
跑题了。。。
数据 和 方法 存储在什么地方呢？

答案是内存中。

数据 存储在以某个地址为起点的一段内存
方法 存储在以某个地址为起点的一段内存中所存储的一组机器语言指令

1.2 方法的调用

方法的调用 分为 直接调用 和 间接调用
直接调用：通过方法名调用，CPU 通过读取函数名从而获得函数所在地址 → 执行函数 → 返回
间接调用：通过函数指针调用，CPU 通过读取函数指针存储的函数所在地址 → 执行函数 → 返回

1.3 什么是委托

委托就是 间接调用方法，也就是说，将函数作为参数传递，在合适的时候调用该方法

C# 中内置了两个常用委托类型，

无返回值有 0 - 16 个参数的 Action

使用方法：
在这里插入图片描述

有返回值有 0 - 16 个参数的 Func

使用方法：
在这里插入图片描述

代码如下

using System;

namespace DelegateTest
{
    internal class Program
    {
        static void Main(string[] args)
        {
			Calculator calculator = new Calculator();
            // 2 C# 内置委托类型 Action
            // Action 类型委托没有返回值、有 0 - 16 个参数
            // 传入方法名, 注意不是方法

            // 2.1 使用 Action 无参数
            Console.Write("通过 C# 内置委托 Action<> 间接调用 calculator.Report, 结果为:  ");
            Action actionReport = new Action(calculator.Report);
            actionReport.Invoke();

            // 1.1 通过函数名调用
            Console.Write("直接调用 calculator.Report, 结果为: ");
            calculator.Report();

            Console.WriteLine();

            // 2.2 使用 Action 有 1 个参数
            Console.Write("通过 C# 内置委托 Action<> 间接调用 calculator.Log, 结果为:  ");
            string now = DateTime.Now.ToString();
            Action<string> actionLog = new Action<string>(calculator.Log);
            actionLog.Invoke(now);

            // 1.2 直接调用
            Console.Write("直接调用 calculator.Report, 结果为: ");
            calculator.Log(now);

            Console.WriteLine();
            
            int num1 = 100;
            int num2 = 200;

            // 3 C# 内置委托类型 Func
            // Func 中重载方法 17 种, 但是都是必须要有返回值, 第一个参数始终为返回值类型, 之后参数个数从 0 - 16

            // 3.1 有参数有返回值
            // Func<返回值类型, 参数 1 类型, 参数 2 类型> 实例化对象 = new Func<返回值类型, 参数 1 类型, 参数 2 类型>(需要调用方法名);
            Func<double, double, double> funcAdd = new Func<double, double, double>(calculator.Add);
            double resAdd = funcAdd.Invoke(num1, num2);
            Console.WriteLine("通过 C# 内置委托 Func<> 间接调用 calculator.Add, 结果为: {0}", resAdd);

            // 1.3 直接调用 calculator.Add
            resAdd = calculator.Add(num1, num2);
            Console.WriteLine("直接调用 calculator.Add, 结果为: {0}", resAdd);

            Console.WriteLine();

            // 3.2 间接调用 calculator.Sub
            Func<double, double, double> funcSub = new Func<double, double, double>(calculator.Sub);
            double resSub = funcSub.Invoke(num1, num2);
            Console.WriteLine("通过 C# 内置委托 Func<> 间接调用 calculator.Sub, 结果为: {0}", resSub);

            // 1.4 直接调用 calculator.Sub
            resSub = calculator.Sub(num1, num2);
            Console.WriteLine("直接调用 calculator.Sub, 结果为: {0}", resSub);

            Console.WriteLine();

            // 3.3 有返回值无参数
            Func<string> funcGetTime = new Func<string>(calculator.GetTime);
            string resGetTime = funcGetTime.Invoke();
            Console.WriteLine("通过 C# 内置委托 Func<> 间接调用 calculator.GetTime, 结果为: {0}", resGetTime);

            // 1.5 直接调用 calculator.GetTime
            resGetTime = calculator.GetTime();
            Console.WriteLine("直接调用 calculator.GetTime, 结果为: {0}", resGetTime);

            Console.WriteLine();
        }
    }

    class Calculator
    {
        public void Report()
        {
            Console.WriteLine("I have 3 methods.");
        }
        public double Add(double num1, double num2)
        {
            return num1 + num2;
        }

        public double Sub(double num1, double num2)
        {
            return num1 - num2;
        }

        public string GetTime()
        {
            string time = DateTime.Now.ToString();
            return time;
        }

        public void Log(string time)
        {
            Console.WriteLine("Now is {0}, I will record something to text ", time);
        }
    }
}

运行截图如下
在这里插入图片描述

2 如何自定义委托

委托与类同级，也是一种数据类型，因此声明时一般都是声明在以类同级的地方
在这里插入图片描述

声明方式如下
在这里插入图片描述
使用方式如下

在这里插入图片描述

代码如下

using System;

namespace DelegateTest
{
    internal class Program
    {
        static void Main(String[] args)
        {
            double num3 = 100;
            double num4 = 200;
            Calculator calculator = new Calculator();

            // 自定义委托类型 实例化对象 = new 自定义委托类型(需要调用对象的方法名);

            Calc calcAdd = new Calc(calculator.Add);
            double resAdd = calcAdd.Invoke(num3, num4);
            Console.WriteLine("通过自定义委托 Calc 间接调用 calculator.Add, 结果为：{0}", resAdd);
            resAdd = calculator.Add(num3, num4);
            Console.WriteLine("直接调用 calculator.Add, 结果为: {0}", resAdd);

            Console.WriteLine();

            Calc calcSub = new Calc(calculator.Sub);
            double resSub = calcSub.Invoke(num3,num4);
            Console.WriteLine("通过自定义委托 Calc 间接调用 calculator.Sub, 结果为：{0}", resSub);
            resSub = calculator.Sub(num3,num4);
            Console.WriteLine("直接调用 calculator.Sub, 结果为: {0}", resSub);

            Console.WriteLine();
        }
    }


    public delegate double Calc(double num1, double num2);

    class Calculator
    {
        public double Add(double num1, double num2)
        {
            return num1 + num2;
        }

        public double Sub(double num1, double num2)
        {
            return num1 - num2;
        }
}

结果如下
在这里插入图片描述

3 为什么使用委托

委托可用于 模板方法 和 回调方法

3.1 模板方法

什么是模板方法？
来自网络：Java设计模式之（十三）——模板方法模式
定义：一个操作中的算法的框架， 而将一些步骤延迟到子类中。 使得子类可以不改
说人话：父类模板方法定义不变的流程，子类重写流程中的方法。

如下，产品工厂生产产品，包装工厂包装产品
在这里插入图片描述

namespace DelegateTest
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // 产品工厂生产产品
            ProductFactory productFactory = new ProductFactory();
            
            Func<Product> funcBeer = new Func<Product>(productFactory.MakeBeer);
            Func<Product> funcCola = new Func<Product>(productFactory.MakeCola);
            
            // 包装工厂包装产品
            WarpFactory warpFactory = new WarpFactory();
            Box boxBeer = warpFactory.WarpProduct(funcBeer);
            Console.WriteLine(boxBeer.Product.Name);
            Box boxCola = warpFactory.WarpProduct(funcCola);
            Console.WriteLine(boxCola.Product.Name);
        }
    }
        class Product
    {
        public string Name { get; set; }
    }
    class Box
    {
        public Product Product { get; set; }
    }

    class WarpFactory
    {
        public Box WarpProduct(Func<Product> getProduct)
        {
            Box box = new Box();
            Product product = getProduct.Invoke();
            box.Product = product;
            return box;
        }
    }

    class ProductFactory
    {
        public Product MakeBeer()
        {
            Product product = new Product();
            product.Name = "Beer";
            return product;
        }

        public Product MakeCola()
        {
            Product product = new Product();
            product.Name = "Cola";
            return product;
        }
    }
}

运行结果如下
在这里插入图片描述

使用委托的目的则是在于 假如需要生产新的产品，只需要在 ProductFactory() 里添加新的产品即可。

以下是刘铁锰老师对委托中模板方法的总结

  1. 相当于填空题
  2. 常位于代码中部
  3. 委托有返回值

3.2 回调方法

什么是回调方法？
来自网络：C 语言回调函数详解
解释： 函数 F1 调用函数 F2 的时候，函数 F1 通过参数给 函数 F2 传递了另外一个函数 F3 的指针，在函数 F2 执行的过程中，函数F2 调用了函数 F3，这个动作就叫做回调（Callback），而先被当做指针传入、后面又被回调的函数 F3 就是回调函数。

虽然说的是 C 语言的回调函数，但是对应 C# 的回调方法道理也是一样的

继续应该上面的例子，当产品的价格大于 5 时，记录下来
在这里插入图片描述

代码如下

using System;

namespace DelegateTest
{
	class Program{
		static class Main(String[] args) {
			// 生产工厂
		    ProductFactory productFactory = new ProductFactory();
		    
		    // 日志
		    Logger logger = new Logger();
		    Func<Product> funcBeer = new Func<Product>(productFactory.MakeBeer);
		    Func<Product> funcCola = new Func<Product>(productFactory.MakeCola);
		    Action<Product> funcLog = new Action<Product>(logger.Log);
			
			// 包装工厂
		    WarpFactory warpFactory = new WarpFactory();
		    Box boxBeer = warpFactory.WarpProduct(funcBeer,funcLog);
		    Console.WriteLine(boxBeer.Product.Name);
		    Box boxCola = warpFactory.WarpProduct(funcCola,funcLog);
		    Console.WriteLine(boxCola.Product.Name);
		    Console.WriteLine();
		}
	}
    class Logger
    {
        public void Log(Product product)
        {
            Console.WriteLine("Product '{0}' created at {1}. Price is {2}", product.Name, DateTime.Now.ToString(), product.Price);
        }
    }
    class Product
    {
        public string Name { get; set; }
        public double Price { get; set; }
    }
    class Box
    {
        public Product Product { get; set; }
    }

    class WarpFactory
    {
        public Box WarpProduct(Func<Product> getProduct, Action<Product> logCallback)
        {
            Box box = new Box();
            Product product = getProduct.Invoke();
            box.Product = product;
            if (product.Price >= 5)
            {
                logCallback.Invoke(product);
            }
            return box;
        }
    }

    class ProductFactory
    {
        public Product MakeBeer()
        {
            Product product = new Product();
            product.Name = "Beer";
            product.Price = 6;
            return product;
        }

        public Product MakeCola()
        {
            Product product = new Product();
            product.Name = "Cola";
            product.Price = 3;
            return product;
        }
    }
}

运行结果如下
在这里插入图片描述

以下是刘铁锰老师对委托中回调方法的总结

  1. 相当于 “流水线”
  2. 常位于代码末尾
  3. 委托无返回值

刘铁锰老师对于委托的整体优缺点总结
难精通 + 易使用 + 功能强大，一旦滥用后果严重

  1. 方法级别的紧耦合，工作中慎用
  2. 可读性下降，debug 难度增加
  3. 把委托回调、异步调用和多线程纠缠在一起，会让项目难以维护
  4. 使用不当可能会造成内存泄漏和程序性能下降

4 多播委托

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace DelegateTest
{
	class Progarm
	{
		static void Main(String[] args) 
		}
            Student stu1 = new Student() { id=1,penColor=ConsoleColor.Red};
            Student stu2 = new Student() { id=2,penColor=ConsoleColor.Green};
            Student stu3 = new Student() { id=3,penColor=ConsoleColor.Blue};
            Action action1 = new Action(stu1.DoHomework);
            Action action2 = new Action(stu2.DoHomework);
            Action action3 = new Action(stu3.DoHomework);

            //action1.Invoke();
            //action2.Invoke();
            //action3.Invoke();
			
			// 使用 += 实现多播委托
            action1 += action2;
            action1 += action3;
            action1.Invoke();
        }
	}
    class Student
    {
        public int id { get; set; }
        public ConsoleColor penColor { get; set; }
        public void DoHomework()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.ForegroundColor = this.penColor;
                Console.WriteLine("Student {0} doing Homework {1} hours.", this.id, i);
                Thread.Sleep(1000);
            }
        }
    }
}

运行结果如下
在这里插入图片描述

5 隐式异步调用

什么是 异步调用 ？
个人理解：
先来说 异步，编程中异步指的是同时进行，也就是宏观意义上的程序的并行（不是同步），而 同步 指的是程序的串行。
调用 指的是调用某个回调方法。
结合博客内容来理解就是 开辟多线程完成某个委托，在代码上看不出来开辟了多线程。
之前写过一篇 C# 异步编程 的博客，欢迎访问

使用 委托的 BeginInvoke 方法实现 隐士异步调用

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace DelegateTest
{
	class Progarm
	{
		static void Main(String[] args) 
		}
            Student stu1 = new Student() { id=1,penColor=ConsoleColor.Red};
            Student stu2 = new Student() { id=2,penColor=ConsoleColor.Green};
            Student stu3 = new Student() { id=3,penColor=ConsoleColor.Blue};
            Action action1 = new Action(stu1.DoHomework);
            Action action2 = new Action(stu2.DoHomework);
            Action action3 = new Action(stu3.DoHomework);
			
			
            action1.BeginInvoke(null, null);
            action2.BeginInvoke(null, null);
            action3.BeginInvoke(null, null);
        }
	}
    class Student
    {
        public int id { get; set; }
        public ConsoleColor penColor { get; set; }
        public void DoHomework()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.ForegroundColor = this.penColor;
                Console.WriteLine("Student {0} doing Homework {1} hours.", this.id, i);
                Thread.Sleep(1000);
            }
        }
    }
}

执行结果如下：
在这里插入图片描述
可以看出，代码执行顺序不是顺序的。

6 适当的使用接口替代委托

对 3.1 中模板方法示例代码使用接口进行重构

代码如下

using System;

namespace DelegateTest
{
	class Program
	{
		static void Main(string[] args) {
			// 产品制造工厂
            IProductFactory makeBeer = new MakeBeer();
            IProductFactory MakeCalo = new MakeCalo();
			
			// 包装产品工厂
            WarpFactory warpFactory = new WarpFactory();
            Box resBeer = warpFactory.WarpProduct(makeBeer.Make());
            Console.WriteLine(resBeer.Product.Name);
            Box resCalo = warpFactory.WarpProduct(MakeCalo.Make());
            Console.WriteLine(resCalo.Product.Name);
		}
	}
    class Product
    {
        public string Name { get; set; }
        public double Price { get; set; }
    }
    class Box
    {
        public Product Product { get; set; }
    }

    class WarpFactory
    {
        // 接口取代委托
        public Box WarpProduct(Product product)
        {
            Box box = new Box();
            box.Product = product;
            return box;
        }
    }

    interface IProductFactory
    {
        Product Make();
    }

    class MakeBeer : IProductFactory
    {
        public Product Make()
        {
            Product product = new Product();
            product.Name = "Beer";
            product.Price = 6;
            return product;
        }
    }

    class MakeCalo : IProductFactory
    {
        public Product Make()
        {
            Product product = new Product();
            product.Name = "Calo";
            product.Price = 3;
            return product;
        }
    }
}

执行结果如下
在这里插入图片描述

7 个人总结（接口和委托）

使用接口逻辑如下
在这里插入图片描述

使用委托逻辑如下
在这里插入图片描述

目前的理解为：

  1. 从上面两张图可以看出，接口可能更 “粗”，委托更 “细”，以上面为例子，接口判断生产那种产品是在 Main 函数也就是主线程中，而委托判断生产那种产品则是在类的某个方法中；
  2. 接口不能用方法作为参数，而委托可以以方法名作为参数，从而实现动态调用。

2022.08.29，后续学完事件再看看有啥新的理解。

逍遥ovo
关注
  • 0
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#高级--委托详解
李宥的博客
08-14 1万+
C#高级–委托详解 一、委托是什么 1、委托是什么 ​ 委托和类一样是一种用户自定义类型，它存储的就是一系列具有相同签名和返回类型的方法的地址，调用委托的时候，它所包含的所有方法都会被执行。 2、委托声明 （1）委托可以声明在类外部，也可以在类内部 （2）跟方法有点类似，有参数，返回值，访问修饰符，比方法声明多一个关键字delegate namespace MyDelegate { /// <summary> /// 1.无参数无返回值委托 /// <
C#基础--委托(Delegate)
热门推荐
five_s的博客
07-20 1万+
简单介绍C# 委托知识
C#委托应用详解：概念、实例与代码注释
最新发布
java专栏
04-17 617
C#中的委托是一种强类型的功能性对象，它代表了具有特定签名的方法。委托允许我们将方法作为参数传递，实现事件处理、回调、异步编程以及代码模块化与重用。本篇文章将深入探讨C#委托的核心概念、使用场景、创建与实例化过程，并通过丰富的代码示例和详尽注释，展示如何在实际编程中有效地应用委托。
【C#教程13/16】：委托
gongdiwudu的专栏
09-15 4921
委托是一种表示对具有特定参数列表和返回类型的方法的引用的类型。实例化委托时，可以将其实例与具有兼容签名和返回类型的任何方法相关联。您可以通过委托实例调用（或调用）该方法。
C#委托详解
qq_44717657的博客
03-14 2119
C#委托 Action Func 多播委托 同步 异步 显式调用和隐式调用
C#基础篇——委托
chinaherolts2008的博客
12-30 2384
前言 在本章中，主要是借机vb.net教程这个C#基础篇的系列整理过去的学习笔记、归纳总结并更加理解透彻。 在.Net开发中，我们经常会遇到并使用过委托，如果能灵活的掌握并加以使用会使你在编程中游刃有余，然后对于很多接触C#时间 c#教程不长的开发者而言，较好的理解委托和事件并不容易。 本节主要是讲述对委托的定义、委托的使用、多播委托、泛型委托、匿名方法、Func和Action委托、Lambda委托，并对它们进行讨论。 说明 简单说它就是一个能把方法当参数传递的对象，而且还知道怎么调用这个方法，同时也是粒度
c# 委托详解
08-31
C#中的委托是一种强大的特性，它允许我们存储和调用方法的引用，使得代码更加灵活和模块化。委托的本质是一个类型，它代表了一种特定的函数签名，即具有固定参数列表和返回类型的方法集合。在C#中，委托类型是通过`...
c#委托详解和和示例分享
09-04
委托是C#语言中的一个重要特性，它允许我们将方法当作参数传递，从而实现了一种灵活的事件处理机制和回调功能。本文将深入解析C#中的委托，包括它的定义、使用方式、安全性和执行效率，以及一些实用示例。 首先，...
C#委托与匿名委托详解
08-29
C#委托与匿名委托详解 C#中的委托是一种特殊的类型，它可以视为一个方法签名的抽象表示。委托的主要作用是将方法作为参数传递给其他方法，或者将方法作为返回值从其他方法中返回。委托的定义使用delegate关键字，...
c#委托详解
naer_chongya的博客
05-03 735
C#中的委托是一个类型，它描述了一个方法的签名，即方法的参数类型和返回类型。委托可以看作是一个指向方法的引用，使得我们可以像使用函数指针一样调用这些方法。将一个或多个方法作为参数传递给另一个方法，从而在需要时调用这些方法。实现事件处理程序。实现回调方法。实现异步编程等功能。其中，accessModifier是可选的访问修饰符，returnType是委托返回值类型，name是委托名字，ParameterList是委托参数列表。
C#中委托概念及使用方法详解
u011555996的博客
02-11 847
c#
C#委托使用详解（Delegates）
12-22
摘要 　　委托是C#编程一个非常重要的概念，也是一个难点。本文将系统详细讲解委托。 　　1. 委托是什么？ 　　其实，我一直思考如何讲解委托，才能把委托说得更透彻。说实话，每个人都委托都有不同的见解，因为看问题的角度不同。个人认为，可以从以下2点来理解： 　　（1） 从数据结构来讲，委托是和类一样是一种用户自定义类型。 　　（2） 从设计模式来讲，委托（类）提供了方法（对象）的抽象。 　　既然委托是一种类型，那么它存储的是什么数据？ 　　我们知道，委托是方法的抽象，它存储的是一系列具有相同签名和返回回类型的方法的地址。调用委托的时候，委托包含的所有方法将被执行。 　　2. 委托
c# 中的委托 详细讲解了如何使用c#中的委托机制
06-10
详细讲解了如何使用c#中的委托机制 深入理解C#中的委托和事件:委托的定义
C#中委托详解
m0_48667560的博客
10-24 102
关键字：delegate概念：一种引用类型，存储某以方法的内存地址。
【C#】委托-Delegate
aoduan2234的博客
06-09 842
C#委托（Delegate） C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。委托（Delegate）是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。 委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自System.Delegate类。 声明委托（Delegate） 委托声明决定了可由...
C#之初始委托
狂奔的蜗牛
11-30 1082
在C#视频中看到了一个比较有意思的东西-委托。 日常生活中也存在委托：老板委托经理完成某个项目就是很好的范例一、下面我们来举一个简单的例子 有这样一个小程序，要求能计算两个数相加或相减 一般我们的思路是这样的public class Operate { public static int add(int arg1, int arg2) {
c#委托的好处
猫敷雪
09-28 686
19 /// 对中国人说你好 20 ///
C# 中的委托和事件(详解)
weixin_34308389的博客
04-05 5907
C# 中的委托和事件        委托和事件在 .NET Framework 中的应用非常广泛，然而，较好地理解委托和事件对很多接触 C# 时间不长的人来说并不容易。它们就像是一道槛儿，过了这个槛的人，觉得真是太容易了，而没有过去的人每次见到委托和事件就觉得心里堵得慌，浑身不自在。本章中，我将由浅入深地讲述什么是委托、为什么要使用委托、事件的由来、.NET Framework 中的委托和事件、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值