C# 委托

已于 2023-03-24 13:54:43 修改
阅读量159 收藏
点赞数
文章标签： 开发语言 c# .net
于 2023-01-20 16:24:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/djwuhjwiwhe/article/details/128741723
版权
本文介绍了C#中的委托，它是函数指针的升级版，允许将方法作为参数传递。文中详细讲解了Action和Func委托的使用，以及如何自定义委托。通过示例展示了委托在模板方法和回调方法中的应用，同时提到了委托的潜在缺点，如紧耦合和可能影响代码可读性。此外，还探讨了单播和多播委托，以及异步调用的不同方式。
摘要由CSDN通过智能技术生成

前言

委托： 函数指针的“升级版”；（C/C++中的函数指针）

委托分类： Action委托、Function委托、自定义委托；

”一切皆地址“： 程序（本质） = 数据 + 算法；（变量（数据） 是以某个地址为起点的一段内存中所存储的值；函数（算法） 是以某个地址为起点的一段内存中所存储的一组机器语言指令）

Java 中没有与委托相对应的功能实体

什么是委托？

一句话解释就是：将方法当作参数传入另一个方法的参数。 .net中有很多常见的委托如：Func 、Action 作用：提高方法的扩展性

  • 委托从字面上理解就是一种代理，类似于房屋中介，由租房人委托中介为其租赁房屋。
  • 在 C#语言中，委托则委托某个方法来实现具体的功能。
  • 委托是一种引用类型，虽然在定义委托时与方法有些相似，但不能将其称为方法。
  • 委托在使用时遵循三步走的原则，即定义声明委托、实例化委托以及调用委托。
  • 从数据结构来讲，委托是和类一样是一种用户自定义类型。
  • 委托是方法的抽象，它存储的就是一系列具有相同签名和返回回类型的方法的地址。
  • 调用委托的时候，委托包含的所有方法将被执行。
  • 委托是 C# 语言中的一个特色，通常将委托分为命名方法委托、多播委托、匿名委托，其中命名方法委托是使用最多的一种委托。

三种委托的使用

Action 委托： 指向无返回值成员；

using System;

namespace InterfaceTest
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Action action = new Action(calculator.Report);//Action委托

            calculator.Report();//直接调用
            action.Invoke();//间接调用
            action();//间接调用
        }
    }
    class Calculator
    {
        public void Report()
        {
            System.Console.WriteLine("I have 3 methods");
        }

        public int Sum(int a, int b)
        {
            return a + b;
        }
    }

Function委托： 指向有返回值成员（Func<参数1类型，参数2类型，返回值类型>）

using System;

namespace InterfaceTest
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Func<int, int, int> func = new Func<int, int, int>(calculator.Sum);//func<>委托

            calculator.Sum(2, 3);//直接调用
            func.Invoke(2, 3);//间接调用
            func(2, 3); //间接调用
        }
    }
    class Calculator
    {
        public void Report()
        {
            System.Console.WriteLine("I have 3 methods");
        }

        public int Sum(int a, int b)
        {
            return a + b;
        }
    }
}

自定义委托： 【修饰符】 delegate 【返回类型】【名称】（【参数列表】） （例如：public delegate int Add(int x,int y)）

using System;

namespace InterfaceTest
{
    public delegate double Cal(double x, double y);//委托声明
    class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Cal cal = new Cal(calculator.Sum);//委托实例化,方式一
            Cal cal1 = calculator.Sub;//委托实例化,方式二

            System.Console.WriteLine(cal(3, 2));
            System.Console.WriteLine(cal1(3, 2));
        }
    }
    class Calculator
    {
        public void Report()
        {
            System.Console.WriteLine("I have 3 methods");
        }
        public double Sum(double a, double b)
        {
            return a + b;
        }
        public double Sub(double a, double b)
        {
            return a - b;
        }
    }
}

委托的使用

模板方法：借用指定的外部方法产生结果（可最大限度重用代码）

  1. 相当于“填空题”；
  2. 常位于代码中部；
  3. 委托有返回值
using System;

namespace InterfaceTest
{
    public delegate double Cal(double x, double y);//委托声明
    class Program
    {
        static void Main(string[] args)
        {
            ProductFactory productFactory = new ProductFactory(); //声明产品方法
            WrapFactory wrapFactory = new WrapFactory();  //声明产品封装方法

            Func<Product> func1 = new Func<Product>(productFactory.MakePizza);//声明委托方法，获取产品名字信息，并作为产品封装方法的传入参数
            Func<Product> func2 = new Func<Product>(productFactory.MakeToCar);

            Box box1 = wrapFactory.WrapProduct(func1); //调用产品封装方法，输出含产品名字信息的box类
            Box box2 = wrapFactory.WrapProduct(func2);

            System.Console.WriteLine(box1.Product.Name); //输出结果
            System.Console.WriteLine(box2.Product.Name);
        }
    }
    class Product
    {
        public string Name { get; set; }
    }
    class Box
    {
        public Product Product { get; set; }
    }
    class WrapFactory
    {
        //传入委托参数，内部使用委托方法
        public Box WrapProduct(Func<Product> getProduct)
        {
            Box box = new Box();
            Product product = getProduct.Invoke();//调用委托方法，即所传入委托参数的成员类型
            box.Product = product;
            return box;
        }
    }
    class ProductFactory
    {
        public Product MakePizza()
        {
            Product product = new Product();
            product.Name = "Pizza";
            return product;
        }

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

回调方法：调用指定的外部方法

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

namespace InterfaceTest
{
    public delegate double Cal(double x, double y);//委托声明
    class Program
    {
        static void Main(string[] args)
        {
            ProductFactory productFactory = new ProductFactory(); //声明产品方法
            WrapFactory wrapFactory = new WrapFactory();  //声明产品封装方法

            Func<Product> func1 = new Func<Product>(productFactory.MakePizza);//声明委托方法，获取产品名字信息，并作为产品封装方法的传入参数
            Func<Product> func2 = new Func<Product>(productFactory.MakeToCar);

            Logger logger = new Logger(); //声明产品记录方法
            Action<Product> log = new Action<Product>(logger.Log);

            Box box1 = wrapFactory.WrapProduct(func1, log); //调用产品封装方法，输出含产品名字信息的box类
            Box box2 = wrapFactory.WrapProduct(func2, log);

            System.Console.WriteLine(box1.Product.Name); //输出结果
            System.Console.WriteLine(box2.Product.Name);
        }
    }

    //定义记录产品信息类
    class Logger
    {
        public void Log(Product product)
        {
            System.Console.WriteLine("Product'{0}' create at {1} Price is {2}.", product.Name, DateTime.UtcNow, product.Price); //utcNow为不带时区的时间形式
        }
    }
    class Product
    {
        public string Name { get; set; }
        public double Price { get; set; }
    }
    class Box
    {
        public Product Product { get; set; }
    }
    class WrapFactory
    {
        //传入委托参数，内部使用委托方法
        public Box WrapProduct(Func<Product> getProduct, Action<Product> logCallBack)
        {
            Box box = new Box();
            Product product = getProduct.Invoke();//调用委托方法，即所传入委托参数的成员类型
            if (product.Price > 50)
            {
                logCallBack.Invoke(product);
            }
            box.Product = product;
            return box;
        }
    }
    class ProductFactory
    {
        public Product MakePizza()
        {
            Product product = new Product();
            product.Name = "Pizza";
            product.Price = 12;
            return product;
        }

        public Product MakeToCar()
        {
            Product product = new Product();
            product.Name = "MakeToCar";
            product.Price = 100;
            return product;
        }
    }
}

委托的缺点

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

委托的高级使用

单播委托：一个委托封装一个方法；

using System;
using System.Threading;

namespace InterfaceTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            Action action1 = new Action(stu1.DoHomework);
            Action action2 = new Action(stu2.DoHomework);
            Action action3 = new Action(stu3.DoHomework);
            action1.Invoke();	//单播委托
            action2.Invoke();
            action3.Invoke();
        }
    }

    class Student
    {
        public int ID { get; set; }
        public ConsoleColor PenColor { get; set; }
        public void DoHomework()
        {
            for (int i = 0; i < 3; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homework {1} hours", this.ID, i);
                Thread.Sleep(1000);
            }
        }
    }
}

结果

在这里插入图片描述

 多播（Multicast）委托：一个委托封装多个方法，调用执行顺序为封装方法的先后顺序

using System;
using System.Threading;

namespace InterfaceTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            Action action1 = new Action(stu1.DoHomework);
            Action action2 = new Action(stu2.DoHomework);
            Action action3 = new Action(stu3.DoHomework);

            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 < 3; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homework {1} hours", this.ID, i);
                Thread.Sleep(1000);
            }
        }
    }
}

结果：同上

在这里插入图片描述

异步调用

同步调用和异步调用

  • 直接同步调用：使用方法名；
  • 间接同步调用：使用单播/多播委托的Invoke方法；
  • 隐式异步调用：使用委托的BeginInvoke；
  • 显示异步调用：使用Thread 或 Task

隐式异步调用（.Net Core 框架不适用，.Net Framework框架可以）

using System;
using System.Threading;

namespace InterfaceTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            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);

            for (int i = 0; i < 5; i++)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread {0}", i);
                Thread.Sleep(1000);
            }
        }
    }

    class Student
    {
        public int ID { get; set; }
        public ConsoleColor PenColor { get; set; }
        public void DoHomework()
        {
            for (int i = 0; i < 3; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homework {1} hours", this.ID, i);
                Thread.Sleep(1000);
            }
        }
    }
}

结果

在这里插入图片描述

 显示异步调用（Thread / Task）

using System;
using System.Threading;

namespace InterfaceTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            Thread thread1 = new Thread(stu1.DoHomework);  //显示异步调用Thread
            Thread thread2 = new Thread(stu2.DoHomework);
            Thread thread3 = new Thread(stu3.DoHomework);

            thread1.Start();
            thread2.Start();
            thread3.Start();

            for (int i = 0; i < 5; i++)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread {0}", i);
                Thread.Sleep(1000);
            }
        }
    }

    class Student
    {
        public int ID { get; set; }
        public ConsoleColor PenColor { get; set; }
        public void DoHomework()
        {
            for (int i = 0; i < 3; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homework {1} hours", this.ID, i);
                Thread.Sleep(1000);
            }
        }
    }
}

结果

在这里插入图片描述

djwuhjwiwhe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#中委托的理解(方便Java的童孩们理解)
技术人
10-24 1002
C#中委托的理解(方便Java的童孩们理解)   定义：委托即Java中的抽象方法，是一个没有实现的方法，没有方法体。要在程序运行的时候才知道它的具体运行的是哪一部分代码（这个定义是从Java角度理解的）   使用：1、定义委托（委托定义的返回类型和形参要与指定的实现函数的返回类型和形参一致）。语法格式如下：           修饰符 delegate 返回类型 委托名字(形参);
C#委托与匿名委托详解
08-29
C#委托与匿名委托详解 C#中的委托是一种特殊的类型，它可以视为一个方法签名的抽象表示。委托的主要作用是将方法作为参数传递给其他方法，或者将方法作为返回值从其他方法中返回。委托的定义使用delegate关键字，...
C# 实例详解委托之Func、Action、delegate（精品）
weixin_68436326的博客
02-11 203
委托是.NET编程的精髓之一，在日常编程中经常用到，在C#中实现委托主要有Func、Action、delegate三种方式，本节主要就这三种委托的用法通过实例展开讲解。
c#委托与java处理
Geogre wu的博客
06-19 767
有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。“委托”在C#中是一个语言级特性，是C#语言的动态拓展能力。而在Java语言中没有直接的对应，但是我们可以通过动态代理来实现委托！    （一）  C#下委托代理方式： /**将方法作为方法的参数 */   publicdelegate voidGreetingDelegate(string name);
C#中的委托和Java中的“委托”（Java8 lambda表达式）
思月行云
04-25 3112
Java8中新增了有关对lambda表达式的支持，其本质是一种编译阶段的语法糖，效果是双向的，代码看似简洁的前提下牺牲了部分可读性。 我们可以尝试实现一些有意思的东西，先来看段C#委托（delegate）的代码 namespace Hello { class Program { static Action<int> callback; ...
C# 中的函数式接口与 Java 的对应关系
PodProgram的博客
09-27 142
与函数式接口类似，C# 的委托类型可以定义一个具有单一抽象方法（Single Abstract Method，SAM）的接口。总结起来，C# 中的函数委托是对应于 Java 中函数式接口的概念。通过使用函数委托，我们可以在 C# 中实现类似于 Java 中函数式接口的功能，并且可以更方便地进行函数组合和代码复用。通过上述代码，我们可以看到 C# 中函数委托的使用方式与 Java 中函数式接口的用法非常相似。我们可以定义一个委托类型，然后在方法调用时传递不同的方法作为参数，实现类似于函数式编程的效果。
C#中的委托,个人理解
weixin_30740581的博客
03-15 68
相当于Java中的interface 定义的接口,但是 比Java中的interface要好 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ADONetDome ...
C#委托代码样例DelegateDemo
02-22
在C#编程语言中，委托（Delegate）是一种强大的特性，它允许我们把方法作为参数传递，或者存储在变量中...在`DelegateDemo`这个示例项目中，你可能会看到如何在实际代码中应用这些概念，从而加深对C#委托和事件的理解。
C#委托解决不同页面的传值问题
10-06
C#委托技术有很多作用，以下是一个简单的实例完成C#委托解决不同对象之间的传值或者方法调用的问题： 假设想想实现以下功能： 从主窗体中创建2个子窗体，想把2个子窗体的信息发送到主窗体中，并在主窗体中显示，在子...
c# 委托的本质是什么
08-18
理解C#委托的本质 C#委托是一种非常重要的编程概念，它允许开发者创建可调用方法的引用，並将其作为参数传递或从方法中返回。理解委托的本质是非常重要的，因为它可以帮助开发者更好地理解和使用委托。 委托的本质...
C#委托使用实例入门
10-03
本文将深入探讨C#委托的使用实例，帮助初学者理解并掌握这一核心概念。 首先，理解委托的基本概念是至关重要的。在C#中，委托是一种类型，它代表了一个方法的签名。这意味着，当创建一个委托实例时，我们实际上是...
年度语言之--c#中的委托
dadenny的博客
01-17 813
在Java的世界开发中，我们习惯于使用接口（Interfaces）和匿名类（Anonymous Classes），特别是在处理事件监听器（Event Listeners）或实现回调（Callbacks）时。这对于代码的可读性和自文档化特别重要。委托在C#中扮演了一个类似于Java中接口和Lambda表达式的角色，但它们的工作方式和用法有所不同。C#中的事件是基于委托的，提供了一种在发生特定操作时触发和处理这些操作的机制。在C#中，委托是一种引用类型，它可以引用具有特定参数列表和返回类型的方法。
C#的委托和java里的委托
程序员的博客
11-01 3324
C#：委托是方法的代理，委托的是方法，当调用委托时就调用了它的方法，是一类行为的抽象，是一种自定义数据类型。它有统一的返回类型和参数。1.定义委托：访问级别delegate 返回值 委托的名称（参数组成）delegate void Handler(); 2.创建委托:Handler handler = new Handler(Fun);Fun是当前类中的方法名称。3.调用委托, handle...
事件与委托C#到java
Circ
05-04 407
java的事件与委托-------java监听器（现在监听器里边放两个壳，都在运行时传入）
C#的委托与java的代理
BigWatermelon11的博客
11-17 3114
C#中的委托和JAVA的代理激烈
C#中的委托与Java中的接口回调
拥抱世界
02-03 4487
最近因为业务需求学习起了C#，对于学过Java的人来说，C#其实还是挺好懂的，基本上很多语法都是相通的。今天就谈谈我对C#和Java中不同的地方的理解吧。 　　说到Java中的接口回调那么就不得不提观察者设计模式，所谓观察者模式就是A（观察者 Observer）和B（被观察者 Observable）两者，当B发生了某种特定的情况，会通知A去某件事情。具体的例子就是当天黑了路灯就会亮，这里的路灯就是
一个php快速项目搭建框架源码，带一键CURD等功能
最新发布
jiyc2008的博客
08-26 2480
框架易于功能扩展，代码维护，方便二次开发，帮助开发者简单高效降低二次开发成本，满足专注业务深度开发的需求。百度网盘下载。
C＃与其它编程语言有什么区别，以及相关优势有哪些
probably121的博客
08-19 1963
C#编程语言的主要特性包括**面向对象、统一的类型系统、自动内存管理等**。与其它编程语言相比，C#的优势体现在**跨平台开发支持、强大的语言集成查询（LINQ）功能、高效的性能**这几个方面。通过.NET Core，C#可以实现真正的跨平台开发，这是其相对于许多其他语言的重要优势。LINQ提供了强大的数据查询能力，使得处理数据变得简单而高效。该语言拥有一个统一的类型系统，可以进行无缝的类型转换。尽管C#是一种安全的编程语言，但它仍能提供高效的性能。C#的语言集成查询提供了强大的数据查询能力。
c#委托
05-31
C# 委托（Delegate）是一种类型，它可以用于封装一个或多个方法，使其可以像其他对象一样传递、存储和调用。委托在事件处理、多线程等方面有着广泛的应用。 C# 委托的声明方式与方法类似，可以带有参数和返回值类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值