C#委托学习

最新推荐文章于 2024-04-23 14:27:47 发布
最新推荐文章于 2024-04-23 14:27:47 发布
阅读量284 收藏 1
点赞数
分类专栏： C#学习 文章标签： c# delegate 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bojin4564/article/details/106352816
版权

一、什么是委托

什么是委托 Delegate在这里插入图片描述
委托实例 Action 与 Func
Action 和 Func 是 C# 内置的委托实例，它们都有很多重载以方便使用。
Action用于定义返回类型为void的委托，例：Action<int ,int>表示定义一个传入参数为两个int型变量返回值为void的委托
Func 用于定义有返回值的委托，返回值类型为泛型参数列表中最后一个，例Func <int ,int ,double>表示定义一个传入参数为两个int型变量返回值为double 的类型。

class Program
{
    static void Main(string[] args)
    {
        var calculator = new Calculator();
        // Action 用于无形参无返回值的方法。
        Action action = new Action(calculator.Report); //实例化一个委托类型对象action，指向calculator的report方法
        calculator.Report();
        action.Invoke(); //调用action所指向的方法
        // 模仿函数指针的简略写法。
        action();

        Func<int, int, int> func1 = new Func<int, int, int>(calculator.Add);
        Func<int, int, int> func2 = new Func<int, int, int>(calculator.Sub);

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

        z = func1.Invoke(x, y);
        Console.WriteLine(z);
        z = func2.Invoke(x, y);
        Console.WriteLine(z);

        // Func 也有简略写法。
        z = func1(x, y);
        Console.WriteLine(z);
        z = func2(x, y);
        Console.WriteLine(z);
    }
}

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

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

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

二、委托的声明与调用

在这里插入图片描述
委托是一种类：

static void Main(string[] args)
{
    Type t = typeof(Action);
    Console.WriteLine(t.IsClass);
}

委托是类，所以声明位置是和 class 处于同一个级别。但 C# 允许嵌套声明类（一个类里面可以声明另一个类），所以有时也会有 delegate 在 class 内部声明的情况。
实例：

public delegate double Calc(double x, double y);

class Program
{
    static void Main(string[] args)
    {
        var calculator = new Calculator();
        var calc1 = new Calc(calculator.Mul); //定义一个委托类型对象指向calculator的mul方法

        Console.WriteLine(calc1(5, 6));
    }
}

class Calculator
{
    public double Mul(double x, double y)
    {
        return x * y;
    }

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

三、委托的一般使用方法

在这里插入图片描述
模板方法
利用模板方法，提高代码复用性。
下例中 Product、Box、WrapFactory 都不用修改，只需要在 ProductFactory 里面新增不同的 MakeXXX 然后作为委托传入 WrapProduct 就可以对其进行包装。

class Program
{
    static void Main(string[] args)
    {
        var productFactory = new ProductFactory();

        Func<Product> func1 = new Func<Product>(productFactory.MakePizza);
        Func<Product> func2 = new Func<Product>(productFactory.MakeToyCar);

        var wrapFactory = new WrapFactory();
        Box box1 = wrapFactory.WrapProduct(func1);
        Box box2 = wrapFactory.WrapProduct(func2);

        Console.WriteLine(box1.Product.Name);
        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)
    {
        var box = new Box();
        Product product = getProduct.Invoke();
        box.Product = product;
        return box;
    }
}

class ProductFactory
{
    public Product MakePizza()
    {
        var product = new Product();
        product.Name = "Pizza";
        return product;
    }

    public Product MakeToyCar()
    {
        var product = new Product();
        product.Name = "Toy Car";
        return product;
    }
}

Reuse，重复使用，也叫“复用”。代码的复用不但可以提高工作效率，还可以减少 bug 的引入。
良好的复用结构是所有优秀软件所追求的共同目标之一。
回调方法
回调方法是通过委托类型参数传入主调方法的被调用方法，主调方法根据自己的逻辑决定是否调用这个方法。

class Program
{
    static void Main(string[] args)
    {
        var productFactory = new ProductFactory();
        
        // Func 前面是传入参数，最后一个是返回值，所以此处以 Product 为返回值
        Func<Product> func1 = new Func<Product>(productFactory.MakePizza);
        Func<Product> func2 = new Func<Product>(productFactory.MakeToyCar);

        var wrapFactory = new WrapFactory();
        var logger = new Logger();
        // Action 只有传入参数，所以此处以 Product 为参数
        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 Logger
{
    public void Log(Product product)
    {
        // Now 是带时区的时间，存储到数据库应该用不带时区的时间 UtcNow。
        Console.WriteLine("Product '{0}' created at {1}.Price is {2}", product.Name, DateTime.UtcNow, product.Price);
    }
}

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)
    {
        var box = new Box();
        Product product = getProduct.Invoke();

        // 只 log 价格高于 50 的
        if (product.Price >= 50)
        {
            logCallBack(product);
        }

        box.Product = product;
        return box;
    }
}

class ProductFactory
{
    public Product MakePizza()
    {
        var product = new Product
        {
            Name = "Pizza",
            Price = 12
        };
        return product;
    }

    public Product MakeToyCar()
    {
        var product = new Product
        {
            Name = "Toy Car",
            Price = 100
        };
        return product;
    }
}

四、委托的高级使用

在这里插入图片描述
多播（multicast）委托
多播委托即一个委托内部封装不止一个方法。（一个委托中添加了另一个委托，顺序执行）

using System;
using System.Threading;

namespace DelegateExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var stu1 = new Student { ID = 1, PenColor = ConsoleColor.Yellow };
            var stu2 = new Student { ID = 2, PenColor = ConsoleColor.Green };
            var stu3 = new Student { ID = 3, PenColor = ConsoleColor.Red };
            var action1 = new Action(stu1.DoHomework);
            var action2 = new Action(stu2.DoHomework);
            var 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 = PenColor;
                Console.WriteLine("Student {0} doing homework {1} hour(s)", ID, i);
                Thread.Sleep(1000);
            }
        }
    }
}

隐式异步调用在这里插入图片描述
异步互不相干：
这里说的“互不相干”指的是逻辑上，而现实工作当中经常会遇到多个线程共享（即同时访问）同一个资源（比如某个变量）的情况，这时候如果处理不当就会产生线程间争夺资源的冲突。

三种同步调用

using System;
using System.Threading;

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

            // 直接同步调用
            //stu1.DoHomework();
            //stu2.DoHomework();
            //stu3.DoHomework();

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

            // 间接同步调用
            //action1.Invoke();
            //action2.Invoke();
            //action3.Invoke();

            // 多播委托，同步调用
            action1 += action2;
            action1 += action3;

            action1.Invoke();

            // 主线程模拟在做某些事情。
            for (var 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 = PenColor;
                Console.WriteLine("Student {0} doing homework {1} hour(s)", ID, i);
                Thread.Sleep(1000);
            }
        }
    }
}

三种同步调用的结果一样：
在这里插入图片描述
使用委托进行隐式异步调用 BeginInvoke

using System;
using System.Threading;

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

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

            // 使用委托进行隐式异步调用。
            // BeginInvoke 自动生成分支线程，并在分支线程内调用方法。
            action1.BeginInvoke(null, null);
            action2.BeginInvoke(null, null);
            action3.BeginInvoke(null, null);

            // 主线程模拟在做某些事情。
            for (var 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 = PenColor;
                Console.WriteLine("Student {0} doing homework {1} hour(s)", ID, i);
                Thread.Sleep(1000);
            }
        }
    }
}

运行结果
在这里插入图片描述
使用 Thread 与 Task 进行异步调用

using System;
using System.Threading;
using System.Threading.Tasks;

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

            // 老的显式异步调用方式 Thread
            //var thread1 = new Thread(new ThreadStart(stu1.DoHomework));
            //var thread2 = new Thread(new ThreadStart(stu2.DoHomework));
            //var thread3 = new Thread(new ThreadStart(stu3.DoHomework));

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

            // 使用 Task
            var task1 = new Task(new Action(stu1.DoHomework));
            var task2 = new Task(new Action(stu2.DoHomework));
            var task3 = new Task(new Action(stu3.DoHomework));

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

            // 主线程模拟在做某些事情。
            for (var 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 = PenColor;
                Console.WriteLine("Student {0} doing homework {1} hour(s)", ID, i);
                Thread.Sleep(1000);
            }
        }
    }
}

在这里插入图片描述

盛气凌人666
关注
专栏目录
C#委托的学习
心之所至的博客
08-18 2154
注：我的学习笔记，之前在蛮牛网发表的。 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace CSharp_委托的学习 { class Program { ////1
C#深入学习委托
lfanyize的博客
07-11 221
1.向SendMessage和BroadcastMessage说再见 首先我们知道小标题所说的两个方法的作用是通过参数名来进行方法的调用，但是这两个函数过于依赖反射机制来查找消息对应的被调用的函数，频繁的使用反射机制会影响性能能，更加严重的问题是，使用这种机制后代码的维护成本太高，加入在一个开发团队中如果某一个方法被重新命名甚至被删除，会导致很严重的隐患，并且在编译器严重，他是没有错误的，因此也不会通过一些错误的提示来告诉开发者某些方法不存在，另外在一个团队的开发中，方法的命名如果一样呢，这也是个很大的隐患
C#委托学习记录
钢铁之家
04-16 242
该文章非原创，只是作为学习记录，内容摘抄自菜鸟教程：http://www.runoob.com/csharp/csharp-delegate.html 可点击链接查看更多数组相关内容。 定义： C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。 委托（Delegate）特别用于实现事件和...
C#委托学习跨窗体操作.zip
10-20
"C#委托学习跨窗体操作.zip"包含了一个具体的实例代码，旨在帮助开发者理解并应用这一技术。 首先，我们要了解什么是委托。在C#中，委托是一种类型，它是引用方法的引用。委托可以被看作是具有特定签名的方法的类型...
c#委托学习示例分享
09-04
C#中的委托是一种强大的特性，它允许我们将方法作为参数传递给其他方法，从而实现更加灵活和动态的编程。委托在C#中扮演着类似于指针的角色，但它更安全，因为它们只能指向符合特定签名的方法。这使得代码更具可扩展...
【C#】C#委托学习
weixin_34395205的博客
11-08 92
虽然做.NET这行也快2年了，但基础不太好啊，今天看了下委托方面的知识，记录下。 1.委托 总的来说，委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。 所以，引入委托后，编程人员可以把方法的引用封装...
C# 委托之学习
weixin_30347335的博客
01-14 74
现在,做的东西还没有用上委托,不过最近一个项目的SOCKET和多线程涉及到了一些,花一部分时间整理下了委托的思绪. 第一,委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。具体应用在联接.(一种可以饶过B方法的委托调用) 第二,多路广...
C#之委托学习一
05-06 589
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace DelegateDemo1 { class Program { /// /// 定义一个返回st
C# 学习委托
u014677855的博客
08-29 2720
目录 目录 一、什么是委托 二、委托的声明 三、委托的实例化 四、委托的用途 五、委托的多播 6 委托实现事件实例 一、什么是委托 其实在做项目的过程中，应该也多多少少用过委托，但是当想清楚而流利地口述出委托到底是什么的时候，却又犯结巴，总觉得表达不到位。今天看了几篇博文和书本内容，干脆写成博客来帮助自己理解和记忆下委托。 言归正传，什么是委托？ 委托是一种引用类型，...
C#中的委托
最新发布
2301_76618920的博客
04-23 1054
通过泛型解决了排序对象的类型问题，可以排序各种类型的数组，比如Student类等等，再通过Func委托传递比较大小方法，解决了按照什么数据成员排序的问题，比如可以按照年龄排序，身高排序，工资排序，只需要传入对应的比较两个数大小方法。但是当我们需要排序一个Employee雇员类的数组时，比如想按照雇员工资排序，雇员年龄排序等等，我们应该怎么排序，或者现在想要排序Student类的数组呢，逻辑一样但是要重构排序方法，怎么解决。在类里声明了比较两个雇员工资的方法。
【C#学习笔记】委托
q418030645的博客
08-24 170
记录一下委托的概念和用法，以免忘记 概念 委托（delegate）是一种存储函数引用的类型，其实就是相当于函数指针。 定义了委托之后，就可以声明委托类型的变量。接着把这个变量初始化为与委托具有相同返回类型和参数列表的函数引用。之后， 就可以使用委托变量调用这个函数，就像该变量是一个函数一样。 委托挺有用的，你可以把委托变量作为参数传递给一个函数，这个函数就可以使用委托调用它引用的任何函数，...
C#委托学习总结
郭凯 廊坊师范学院信息技术提高班 十三期
07-14 264
众所周知，winform也好，webform也好，里面随处可见的事件驱动，有事件，当然也少不了委托，感觉之前对委托这个概念的理解一直是模模糊糊的，口里都会背的那么几句话：“委托可以把方法当作参数在另一个方法中传递和调用”，“委托是方法的快捷方式”等等。但是真要深入理解，灵活运用，还是要有良好的代码理解功底和面向对象基础的，今天就再来把委托这个知识梳理梳理，以加深对它的理解。 要理解委托，我们首先...
c#委托学习总结
每天学习一点点
01-19 187
委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递。 委托的声明： 没有返回值，没有参数的委托 public delegate void MyDelegate() 有返回值，有参数的委托： public delegate string MyDelegate(int i); 通常情况下使用.Net框架定义好的委托，无需自定义委托。 Action：无返回值的泛型委托 Action<int,string> 表示有传入参数int，string无返.
C#零基础学习之委托
wangyuyu0000的博客
02-26 185
C#零基础学习之路——委托 一. 学习背景 基于学习b站刘老师的c#入门，整理学习心得。 二. 委托 2.1 什么是委托 委托的简要理解：委托其实就是c/c++中的函数指针，只是在c#中换了一种表现形式。 2.2 简单的委托 下面我们使用c#自带的委托，Action和Func委托，老样子，打开编译器，键入代码，代码1： using System; namespace DelegateExample { class Program { static void Main(str
C#学习笔记（11）-委托
lonesome_zxq的博客
06-16 294
为什么要使用委托 需要将方法作为一个参数传递给另一个方法。 结合委托的概念，可以将以下代码： static void Main(string[] args) { //三个需求 //1.将一个字符串数组中的每个元素都转换成大写 //2.将一个字符串数组中的每个元素都转换成小写 ...
C# 委托详解
素弦的博客
07-27 1846
C# 中的委托 （初级应用） 前言 前段时间在整理C#知识点的时候，对于委托这个略微高级的概念有一些迷茫，经过查阅书籍，网上视频，现在终于对这个概念有了一定的认知。此篇文章也用于对自己所学知识的梳理。 一、委托的概念 官方的解释：委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。 梳理 委托是一个类 实际上是一个方法的模板 委托是一个方法的引用，不做实际
C#委托详解与应用示例
"C# 委托学习示例分享" C#中的委托是面向对象设计的一个强大特性，它类似于函数指针，允许我们将方法作为参数传递给其他方法，或者存储在变量中以便稍后调用。这使得我们可以实现事件处理、回调函数以及策略模式等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值