c# | 委托

最新推荐文章于 2024-08-29 15:07:29 发布
最新推荐文章于 2024-08-29 15:07:29 发布
阅读量143 收藏
点赞数
分类专栏： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42953201/article/details/105413089
版权

一、无题

委托（delegate）是函数指针的升级版

直接调用：通过函数名来调用函数，CPU通过函数名直接获得函数所在的地址并开始执行->返回

间接调用：通过函数指针来调用函数，CPU通过读取函数指针储存的值获得函数所在地址并开始执行->返回

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

namespace ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {
            //第一种委托类型
            Calculator calculor = new Calculator();
            Action action = new Action(calculor.Report);
            calculor.Report();  //直接调用
            action.Invoke();    //委托简介调用
            action();           //简便写法

            //第二种委托类型
            Func<int, int, int> func1 = new Func<int, int, int>(calculor.Add);
            Func<int, int, int> func2 = new Func<int, int, int>(calculor.Sub);

            int x = 100;
            int y = 200;
            int z = 0;

            z = func1.Invoke(x, y);
            z = func1(x, y);        //是上面的简写版
            Console.WriteLine(z);
            z = func2.Invoke(x, y);
            z = func2(x, y);        //是上面的简写版
            Console.WriteLine(z);

        }
    }

    class Calculator
    {
        public void Report()
        {
            Console.WriteLine("I have three number");
        }

        public int Add(int a,int b)
        {
            int result = a + b;
            return result;
        }

        public int Sub(int a,int b)
        {
            int result = a - b;
            return result;
        }
    }
}

结果
在这里插入图片描述

二、委托的声明（自定义委托）

委托是一种类(class)，类是数据类型所以委托也是一种数据类型，它的声明方式与一般的类不同，主要是为了照顾可读性和c/c++传统

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

namespace ConsoleApplication4
{
    public delegate double Calc(double x, double y);//写在Program外面，作为一个单独的类


    class Program
    {
        static void Main(string[] args)
        {
            Type t = typeof(Action);
            Console.WriteLine(t.IsClass);
            Calcular calculator = new Calcular();
            Calc calc1 = new Calc(calculator.Add);
            Calc calc2 = new Calc(calculator.Sub);
            Calc calc3 = new Calc(calculator.Mull);
            Calc calc4 = new Calc(calculator.Div);

            double a = 100, b = 200, c = 0;
            c = calc1.Invoke(a, b);//也可以c = calc1(a,b);
            Console.WriteLine(c);
            c = calc2.Invoke(a, b);
            Console.WriteLine(c);
            c = calc3.Invoke(a, b);
            Console.WriteLine(c);
            c = calc4.Invoke(a, b);
            Console.WriteLine(c);

        }
    }

    class Calcular
    {
        public double Add(double x,double y)
        {
            return x + y;
        }

        public double Sub(double x,double y)
        {
            return x - y;
        }

        public double Mull(double x, double y)
        {
            return x * y;
        }

        public double Div(double x, double y)
        {
            return x / y;
        }
    }

}

结果
在这里插入图片描述
委托与所封装的方法必须“类型兼容”，即返回值的数值类型一致，参数列表在个数和数据类型上一致（参数名不需要一样）

三、委托的一般使用

实例：把方法当作参数传给另一个方法
1、模板方法，“借用”指定的外部方法来产生结果，相当于填空题，常位于代码中部，委托有返回值
2、回调方法，调用指定的外部方法，相当于流水线，常位于代码尾部，委托无返回值

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

namespace ConsoleApplication4
{

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

            Logger logger = new Logger();
            Action<Product> log = new Action<Product>(logger.Log);

            Box box1 = wrapFactory.WrapProduct(func1,log);
            Box box2 = wrapFactory.WrapProduct(func2,log);

            Console.WriteLine(box1.Product.Name);
            Console.WriteLine(box2.Product.Name);


        }
    }

    class Product
    {
        public string Name { get; set; }
        public double Price { get; set; }
    }

    class Logger        //记录错误
    {
        public void Log(Product product)
        {
            Console.WriteLine("Product{0},create at {1}.Price is {2}",product.Name,DateTime.UtcNow,product.Price);
        }
    }

    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(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 MakeToyCar()
        {
            Product product = new Product();
            product.Name = "Toy Car";
            product.Price = 100;
            return product;

        }
    }
}

在这里插入图片描述
这块暂时不是很懂，以后再补充吧、

四、多播委托

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

namespace ConsoleApplication4
{

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Red };
            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 += action3;
            action1();

        }
    }

    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} hour(s).", this.ID, i);
                Thread.Sleep(1000);//1秒
            }
        }
    }
}

在这里插入图片描述

五、隐式异步调用

中英文差异，
同步：你做完我（在你的基础上）接着做(串联）
异步：咱们两个同时做（相当于汉语中的同时进行（并联）

同步调用与异步调用的对比

每一个运行的程序是一个进程（process）
每个进程可以有一个或者多个线程（thread）
同步调用是在同一线程内
异步调用的底层机理是多线程
串行==同步==单线程，并行==异步==多线程

例子：直接同步调用
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace ConsoleApplication4
{

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

            stu1.DoHomework();
            stu2.DoHomework();
            stu3.DoHomework();

            for (int i = 0; i < 10; 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 < 5; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homework {1} hour(s).", this.ID, i);
                Thread.Sleep(1000);//1秒
            }
        }
    }
}

在这里插入图片描述
用委托的话就是间接同步调用，注意直接间接与同步异步是两个不同的概念，这里就不列出间接同步调用了

例子：隐式异步调用
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace ConsoleApplication4
{

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Red };
            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);

            for (int i = 0; i < 10; 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 < 5; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homework {1} hour(s).", this.ID, i);
                Thread.Sleep(1000);//1秒
            }
        }
    }
}

在这里插入图片描述

action.BeginInvoke()就是创建一个并行的线程
可以看到结果出现了学生与颜色不匹配，是因为几个并行在运行中出现资源冲突的情况，从而导致错误

例子：显式异步调用
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace ConsoleApplication4
{

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

            Thread thread1 = new Thread(new ThreadStart(stu1.DoHomework));
            Thread thread2 = new Thread(new ThreadStart(stu2.DoHomework));
            Thread thread3 = new Thread(new ThreadStart(stu3.DoHomework));

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


            for (int i = 0; i < 10; 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 < 5; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homework {1} hour(s).", this.ID, i);
                Thread.Sleep(1000);//1秒
            }
        }
    }
}

在这里插入图片描述
也可以使用Task方法来进显式调用

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

namespace ConsoleApplication4
{

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

            Task task1 = new Task(new Action(stu1.DoHomework));
            Task task2 = new Task(new Action(stu2.DoHomework));
            Task task3 = new Task(new Action(stu3.DoHomework));

            task1.Start();
            task2.Start();
            task3.Start();



            for (int i = 0; i < 10; 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 < 5; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homework {1} hour(s).", this.ID, i);
                Thread.Sleep(1000);//1秒
            }
        }
    }
}

在这里插入图片描述
委托才可以用到隐式异步调用

应该适时地使用接口（interface）取代一些对委托的使用
墨色幽灵
关注
专栏目录
C#委托与匿名委托详解
08-29
C#委托与匿名委托详解 C#中的委托是一种特殊的类型，它可以视为一个方法签名的抽象表示。委托的主要作用是将方法作为参数传递给其他方法，或者将方法作为返回值从其他方法中返回。委托的定义使用delegate关键字，...
C# 事件委托简单封装示例
11-02
在C#编程中，事件和委托是核心特性之一，它们为构建可扩展和灵活的代码提供了基础。事件委托的封装是提高代码复用性和模块化的重要手段。本示例将探讨如何在C#中实现事件委托的简单封装，并提供一个实际的应用场景。...
C# Action
weixin_34092370的博客
05-03 317
Action&lt;T&gt; Delegate   Encapsulates a method that has a single parameter and does not return a value.   https://msdn.microsoft.com/en-us/library/018hxwa8(v=vs.110).aspx
c#new Action就是委托类型，为了减少方法使用在invoke或者BeginInvoke中可以直接用lamda表达式写不必再多写方法
weixin_44035651的博客
06-02 2511
c#委托和INVOKE
c#Action 异步操作
最新发布
weixin_57673087的博客
08-29 256
1.不带参数的= 0)2.带参数的= 0)
C# this.Invoke(new Action(() =＞ { /* some code */ }))用法说明
一只没有感情的AI机械猿
08-16 4671
在 C# 中，`this.Invoke(new Action(() => { /* some code */ }))` 是一种用于在 UI 线程上执行代码的方法，通常用于在后台线程中更新 UI 控件的值或执行其他需要在 UI 线程上执行的操作。总之，`this.Invoke(new Action(() => { /* some code */ }))` 是一种在 UI 线程上执行代码的方法，特别适用于后台线程需要更新 UI 控件或执行其他需要在 UI 线程上执行的操作的情况。
C# Action 使用
热门推荐
u012395209的博客
08-28 1万+
C#Action如何使用，以及注意事项
C# Action用法
cheyueyu3885的博客
01-26 525
class Program{static void Main(string[] args){//循环调用，action不传参List<Action> actions = new List<...
C#中委托的+=和-=深入研究
09-04
在C#中，委托是一种类型，它代表对具有特定签名的方法的引用。`+=` 和 `-=` 操作符在委托上下文中用于添加或移除事件处理程序。本文将深入探讨这两个操作符在处理委托时的具体行为，以及它们如何影响委托的多播特性...
C# 使用委托方式Usercontrol与主窗体进行消息传递
04-25
在C#中，委托是一种类型，它类似于函数指针，可以引用方法。通过使用委托，我们可以创建事件处理程序或者在类之间传递方法调用。这种方式允许我们以面向对象的方式处理回调和异步操作，而无需知道实际执行的代码。 ...
C#创建委托
08-22
### C# 创建委托详解 #### 一、委托概念解析 在C#中，**委托**是一种引用类型的数据，它可以像方法那样被调用。委托可以用来封装类中的方法，并允许将方法作为参数传递给其他方法。它使得可以将代码片段（方法）...
C#中Action和Func的区别
09-04
主要介绍了C#中Action和Func的区别,是进行C#程序设计时需要加以注意的知识点,需要的朋友可以参考下
C#的委托(Action、Func、delegate、predicate)
旧时佑忆的空间
08-27 672
委托是什么？如何使用？ 委托是一种类，类是数据类型所以委托也是一种数据类型，它的声明方式与一般的类不同，主要是为了照顾可读性和C/C++，委托使用要慎之又慎 C#有已经定义好的两种委托方式，一个是Action，一个是Func，Action是无返回值的，而Func是要求有返回值的，两者都通过泛型定义好了参数类型，上限为16个。详细用法如下代码所示。 此外C#中还有自定义的委托，需要使用delegate关键字来定义 需要注意声明委托的位置，因为委托也是一种类，所以声明位置应当是与命名空间下，与其他类同级
C# 的Action和Func简明介绍和用法
weixin_42565127的博客
05-30 1419
以前我都是通过定义一个delegate来写委托的，但是最近看一些外国人写的源码都是用action和func方式来写，当时感觉对这很陌生所以看起源码也觉得陌生，所以我就花费时间来学习下这两种方式，然后发现确实代码简洁了不少。这两种方式我们也可以去实践的过程去慢慢运用。
c# 中的Delegate与Action（界面多线程应用）
delphi863的博客
12-28 3791
很多C#初学者，都遇到过这样的问题，今天就这个问题，进行分析。 根源 先说下这个问题产生的根源，大家都知道，程序运行起来之后，首先会有一个主线程，主线程用于处理控件生成、界面渲染、事件响应等操作，因此我们可以理解为窗体里的控件是属于主线程的。 如果我们想实现与主线程同时执行另一件事，一般会去使用多线程，因此多线程，从某种意义上来说，它和主线程的身份是平等的，就像你和你的同事的关系一样，你们是平级的关系。如果你同事有一天想从你手上把你的项目程序拿过去，你愿不愿意？ 所以，如果在多线程里操作主线程的
UDK 中的委托使用
liuzhimu2018的博客
11-05 165
最近在UDK中使用到了委托记录一下 首先要进行委托的声明 delegate bool OnInterceptRawInputKey( const out InputEventParameters EventParms );
C# action,delegate,func的用法和区别
dotNET跨平台
05-14 351
以前我都是通过定义一个delegate来写委托的，但是最近看一些外国人写的源码都是用action和func方式来写，当时感觉对这很陌生所以看起源码也觉得陌生，所以我就花费时间来学习下这两种...
C# action 与 func 的用法
qq_37066317的博客
09-29 589
总结 1：Action用于没有返回值的方法（参数可以根据自己情况进行传递） 2：Func恰恰相反用于有返回值的方法（同样参数根据自己情况情况） 3：记住无返回就用action，有返回就用Func using System; namespace funcActionDemo {     class MainClass     {         public static void Ma...
C#委托与事件委托详解
"本文主要探讨了C#编程语言中的委托（Delegate）和事件委托的概念、特点、使用方式以及异常处理，旨在帮助读者深入理解和运用这两种关键特性。" C#中的委托是类型安全的函数指针，它允许我们将方法作为参数传递给...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值