C# 委托的一般用法

最新推荐文章于 2024-04-17 08:59:55 发布
最新推荐文章于 2024-04-17 08:59:55 发布
阅读量2.8k 收藏 67
点赞数 7
分类专栏： C# 文章标签： c# .net delegate 委托
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cpp_learner/article/details/107955487
版权

今天在公司又学习到了一个新的知识点：委托！
它相当于C/C++中的函数指针。也就是间接调用！
其实它的作用还是挺大的，但是也是挺难学习的，花了好大的时间才搞懂一点点，但是还是不知道它在项目中该用在什么地方。
算了，先不管，先用博客记录下来，也许以后就知道了，就用得上了！！！

委托有两种方式：系统封装好的，自定义的。

系统封装好的委托

系统封装好的委托有很多，这里就主要讲常用的两种：Action 和 Func.

其实这两个很好区别的：

  1. Action是没有返回值类型的，所以它只适合0至n个参数的void返回值的方法。
  2. Func是固定要有一个返回值的，所以它只适合0至n个参数的和带返回值的方法。

Action

定义：Action action = new Action(对象.方法名);

下面我们写一个类来测试一下：

class ActionFuncDelegate {
    public void ADelegate() {
        Console.WriteLine("这是一个返回值为空，参数也为空的函数！");
    }
}

Mian函数：

static void Main(string[] args) {
    ActionFuncDelegate actionDelegate = new ActionFuncDelegate();

    Console.WriteLine("---系统自带委托：Action---");
    // 定义系统的委托：Action
    //									 对象.方法名
    Action action = new Action(actionDelegate.ADelegate);
    // 间接调用
    action.Invoke();	// 等效于： action();
    // 直接调用
    actionDelegate.ADelegate();
}

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

其他例子：

Action：void返回值，带两个不同的参数。

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

namespace _Action {

    class Program {
        static void Main(string[] args) {

            Action<int, string> action = new Action<int, string>(OutName);

            action.Invoke(5, "Mir.Yang");

            Console.ReadKey();
        }

        static void OutName(int count, string name) {
            for (int i = 0; i < count; i++) {
                Console.WriteLine("Hello {0}.", name);
            }
        }
    }
}

在这里插入图片描述

Func

定义：Func<返回类型, 参数类型1, 参数类型2, 参数类n> func1 = new Func<返回类型, 参数类型1, 参数类型2, 参数类型n>(对象名.方法名);

下面我们写一个类来测试一下：

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

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

Main函数：

static void Main(string[] args) {
    ActionFuncDelegate actionDelegate = new ActionFuncDelegate();
            
    Console.WriteLine("\n");
    Console.WriteLine("---系统自带委托：Func---");
    // 定义系统的委托：Func
    Func<int, int, int> func1 = new Func<int, int, int>(actionDelegate.Add);
    Func<int, int, int> func2 = new Func<int, int, int>(actionDelegate.Minus);

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

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

自定义委托（delegate）

自定义委托，使用的关键字是：delegate

声明：public delegate 返回类型 委托名(参数1, 参数2，参数n);
例：：public delegate double UserD(double x, double y);

当我们需要使用到它时，需要new实例化它才可以使用！

下面我们写一个类来测试一下：

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

namespace Delegate_委托 {

	/************************************************/
    // 声明自定义委托
    public delegate double UserD(double x, double y);

    class UserDelegate {

		// 下面方法返回值都是double类型，且参数都是两个double类型
        public double Add(double x, double y) {
            return x + y;
        }

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

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

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

Main函数：

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

namespace Delegate_委托 {
    class Mains {
        static void Main(string[] args) {            
            Console.WriteLine("\n");            
            Console.WriteLine("---自定义委托---");
            
            UserDelegate userDelegate = new UserDelegate();
            
            // ***自定义委托***
            // 实例化委托
            UserD userD1 = new UserD(userDelegate.Add);
            UserD userD2 = new UserD(userDelegate.Min);
            UserD userD3 = new UserD(userDelegate.Mul);
            UserD userD4 = new UserD(userDelegate.Div);

            double a = 100;
            double b = 200;
            double c = 0;

			// 间接调用
            c = userD1.Invoke(a, b);
            Console.WriteLine(c);
            c = userD2.Invoke(a, b);
            Console.WriteLine(c);
            c = userD3.Invoke(a, b);
            Console.WriteLine(c);
            c = userD4.Invoke(a, b);
            Console.WriteLine(c);
		}         
    }

}

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

当然也可以时其他的不同类型的组合。

委托小例子

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

namespace 委托 {

    // 定义委托
    public delegate void delSayHi(string name);

    class Program {

        static void Main(string[] args) {
            // 方式一 直接调用函数
            Console.WriteLine("--- 方式一 ---");
            SayHiChinese("张三");
            SayHiEnglish("李四");
            Console.WriteLine();


            // 方式二 通过委托调用函数
            Console.WriteLine("--- 方式二 ---");
            delSayHi sayHi1 = new delSayHi(SayHiChinese);
            delSayHi sayHi2 = new delSayHi(SayHiEnglish);

            sayHi1("张三");
            sayHi2("李四");
            Console.WriteLine();


            // 方式三 函数名直接赋值委托调用
            Console.WriteLine("--- 方式三 ---");
            delSayHi sayHi3 = SayHiChinese;
            delSayHi sayHi4 = SayHiEnglish;

            sayHi3("张三");
            sayHi4("李四");
            Console.WriteLine();


            // 方式四 直接将函数名当作参数传给委托调用
            Console.WriteLine("--- 方式四 ---");
            test("张三", SayHiChinese);
            test("李四", SayHiEnglish);
            Console.WriteLine();

            Console.ReadKey();
        }

        // 带有委托参数的函数
        public static void test(string name, delSayHi dsh) {
            dsh(name);
        }


        public static void SayHiChinese(string name) {
            Console.WriteLine("吃饭了吗？" + name);
        }

        public static void SayHiEnglish(string name) {
            Console.WriteLine("Nice to meet you?" + name);
        }
    }
}

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

泛型委托

泛型就是相当与C++当中的容器，它可以是任何类型。

代码例子：

寻找数组的最大值（任意类型的数组）

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

namespace 泛型 {

    // 定义泛型委托，实现两数相减
    public delegate int Delegate<T>(T o1, T o2);


    class Program {
        static void Main(string[] args) {
            int[] array1 = { 1, 2, 3, 5, 4, 6, 9, 8 };
            string[] array2 = { "asdfasdlg", "xzvcnryt", "waerw4thbvzxt", "asdfgh" };

            // 利用匿名函数实现
            int result1 = GetMax<int>(array1, delegate (int t1, int t2) {
                return t1 - t2;
            });            
            Console.WriteLine("最大值：" + result1);


            string result2 = GetMax<string>(array2, delegate (string s1, string s2) {
                return s1.Length - s2.Length;
            });            
            Console.WriteLine("最大值：" + result2);


            Console.ReadKey();
        }

        // 定义泛型函数
        public static T GetMax<T>(T[] arr, Delegate<T> del) {
            T max = arr[0];

            for (int i = 0; i < arr.Length; i++) {

                // 委托实现max减去arr[i]，当小于0，说明max比它小
                if (del(max, arr[i]) < 0) {
                    max = arr[i];
                }
            }

            return max;
        }

    }
}

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

其他例子：
实现两个不同类型的变量相加。

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

namespace 复习委托 {

    // 定义泛型委托
    public delegate Y MyDeleAdd<T, Y>(T a, Y b);

    class 泛型委托 {
        static void Main(string[] args) {
            MyDeleAdd<int, double> myDeleAddDouble = new MyDeleAdd<int, double>(DeleAtOne);
            double res = myDeleAddDouble.Invoke(10, 5.5);
            Console.WriteLine("MyDeleAdd<int, double>：{0}", res);

            MyDeleAdd<double, int> myDeleAddInt = new MyDeleAdd<double, int>(DeleteAtTwo);
            int ret = myDeleAddInt.Invoke(10.4, 5);
            Console.WriteLine("MyDeleAdd<double, int>：{0}", ret);

            Console.ReadKey();
        }

        static double DeleAtOne(int x, double y) {
            return x + y;
        }

        static int DeleteAtTwo(double x, int y) {
            return Convert.ToInt32(x + y);  // 转换为int类型，按照四舍五入的原则
        }

    }

}

在这里插入图片描述

委托还有两个常用的用法：模板方法 与 回调方法。

模板方法

这个我也不知道该怎么讲，我就把代码放在这里，在讲解一下代码的思路就这样吧！

代码思路：

  1. 我们有一个产品类Product，它包含一个Name属性。
  2. 还有一个箱子类Box，它包含有产品类的对象属性。
  3. 紧接着我们编写一个模板方法类TemplateMethod ，它的返回值是Box类型，参数是Func委托类型，该方法的主要作用是将一个产品包装完后，返回包装后Box的类型。
  4. 我们在定义一个生产产品的工厂类ProductFactory ，里面有生产披萨和玩具卡车的方法。
  5. 这样定义的作用是：我们以后都不需要去修改Product 类 和 Box 类 和 TemplateMethod 类，只是需要后续还有什么商品需要增加的话，就在ProductFactory 类的增加对应的生产方法。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

/*
 *  委托：模板方法的使用
 */

namespace Delegate_委托 {

    // 产品
    class Product {
        public string Name { get; set; }
    }
    
    // 箱子
    class Box {
        public Product product { get; set; }
    }

    // 模板方法(对产品进行包装)
    class TemplateMethod {
        public Box Template(Func<Product> func) {
            Box box = new Box();                // 找一个箱子
            Product product = func.Invoke();    // 找到产品
            box.product = product;              // 将产品包装到箱子中

            return box;                         // 返回箱子
        }
    }

    // 生产产品的工厂
    class ProductFactory {
        public Product MakePizza() {
            Product product = new Product();
            product.Name = "Pizza";
            return product;
        }

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

Main函数:

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

namespace Delegate_委托 {
    class Mains {
        static void Main(string[] args) {

            Console.WriteLine("\n");
            Console.WriteLine("---委托的常用用法一：模板方法---");
            ProductFactory productFactory = new ProductFactory();   // 产品生产工厂
            TemplateMethod templateMethod = new TemplateMethod();   // 包装产品

            // 定义委托
            Func<Product> f1 = new Func<Product>(productFactory.MakePizza);
            Func<Product> f2 = new Func<Product>(productFactory.MakeToyCar);

            // 产品包装
            Box box1 = templateMethod.Template(f1);
            Box box2 = templateMethod.Template(f2);

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

            Console.WriteLine("\n按任意键继续...");
            Console.ReadKey();
        }
    }

}

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

回调方法

按照我个人的理解就是：当函数在正常执行时遇到一些突发状况而调用一个特定的回调方法！

代码还是和上面差不多的代码，就修改一些部分和添加了一个回调方法类Logger 。

产品Product_2 添加多了一个价格Price属性，当包装类TemplateMethod_2 在包装产品时，判断产品的价格大于50元钱时，出发调用回调方法Logger ！

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

/*
 *  委托：回调方法的使用
 */

namespace Delegate_委托 {

    // 产品
    class Product_2 {
        public string Name { get; set; }
        public double Price { get; set; }
    }

    // 盒子
    class Box_2 {
        public Product_2 product { get; set; }
    }

    /************/
    /* 回调方法 */
    class Logger {
        public void Log(Product_2 product_2) {
            Console.WriteLine("出现价格偏高的产品：产品名字：{0}  产品价格：{1}  出现的时间：{2}", 
                product_2.Name, product_2.Price, DateTime.Now);
        }
    }

    // 模板方法(对产品进行包装)
    class TemplateMethod_2 {
        public Box_2 Template(Func<Product_2> func, Action<Product_2> action) {
            Box_2 box = new Box_2();
            Product_2 product = func.Invoke();

            // 调用回调方法
            if (product.Price > 50) {
                action.Invoke(product);
            }

            box.product = product;

            return box;
        }
    }

    // 生产产品的工厂
    class ProductFactory_2 {
        public Product_2 MakePizza() {
            Product_2 product = new Product_2();
            product.Name = "Pizza";
            product.Price = 15.5;
            return product;
        }

        public Product_2 MakeToyCar() {
            Product_2 product = new Product_2();
            product.Name = "ToyCar";
            product.Price = 55.6;
            return product;
        }
    }
}

Main函数：

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

namespace Delegate_委托 {
    class Mains {
        static void Main(string[] args) {

            Console.WriteLine("\n");
            Console.WriteLine("---委托的常用用法二：回调方法---");
            ProductFactory_2 productFactory_2 = new ProductFactory_2(); // 产品生产工厂
            TemplateMethod_2 templateMethod_2 = new TemplateMethod_2(); // 包装产品
            Logger logger = new Logger();   // 定义回调

            // 定义委托
            Func<Product_2> ff1 = new Func<Product_2>(productFactory_2.MakePizza);
            Func<Product_2> ff2 = new Func<Product_2>(productFactory_2.MakeToyCar);
            Action<Product_2> action_1 = new Action<Product_2>(logger.Log);

            // 产品包装
            // 如果有产品价格高于50，则会调用回调方法
            Box_2 boxs1 = templateMethod_2.Template(ff1, action_1);
            Box_2 boxs2 = templateMethod_2.Template(ff2, action_1);

            Console.WriteLine(boxs1.product.Name);
            Console.WriteLine(boxs2.product.Name);

            Console.WriteLine("\n按任意键继续...");
            Console.ReadKey();
        }
    }

}

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

再讲最后一点：
委托有单播委托和多播委托两种。

上面我们使用的都是单播委托，所以我们这里就演示多播委托的用法！

多播委托

其实也很简单，就将委托相加起来进行了。
或者定义一个委托，然后将委托对象加等于函数名。

看不懂例子一的可以去看例子二。

下面我们写一个类来测试一下：

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

/*
 * 多播委托 
 */

namespace Delegate_委托 {
    class MultiDelegate {
        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 homgwork {1} hour(s)", this.ID, i);
                
                // 睡眠一秒钟
                Thread.Sleep(1000);
            }
        }
    }
}

Main函数：

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

namespace Delegate_委托 {
    class Mains {
        static void Main(string[] args) {

            Console.WriteLine("\n");
            Console.WriteLine("---多播委托---");
            MultiDelegate multicastDelegate1 = new MultiDelegate() { ID = 1, penColor = ConsoleColor.Blue };
            MultiDelegate multicastDelegate2 = new MultiDelegate() { ID = 2, penColor = ConsoleColor.Green };
            MultiDelegate multicastDelegate3 = new MultiDelegate() { ID = 3, penColor = ConsoleColor.Red };

            Action act_1 = new Action(multicastDelegate1.DoHomework);
            Action act_2 = new Action(multicastDelegate2.DoHomework);
            Action act_3 = new Action(multicastDelegate3.DoHomework);

            // 单薄委托测试用例
            /*
            act_1.Invoke();
            act_2.Invoke();
            act_3.Invoke();
            */


            // 多播委托测试用例
            act_1 += act_2;
            act_1 += act_3;

            act_1.Invoke();

            Console.WriteLine("\n按任意键继续...");
            Console.ReadKey();
        }
    }
}

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

多播委托例子二

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

namespace 多播委托 {

    // 定义委托
    public delegate void Del();

    class Program {
        static void Main(string[] args) {

            // 多播委托就是将委托对象+=函数名
            Del del = test1;
            del += test2;
            del += test3;
            del += test4;

            del();

            Console.WriteLine("-----华丽的分割线-----");

            // 有+=，也会有-=
            del -= test2;
            del -= test4;

            del();

            Console.ReadKey();
        }

        public static void test1() {
            Console.WriteLine("测试一");
        }

        public static void test2() {
            Console.WriteLine("测试二");
        }

        public static void test3() {
            Console.WriteLine("测试三");
        }

        public static void test4() {
            Console.WriteLine("测试四");
        }
    }
}

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

总结：
好了，委托也就讲到这里了，看懂、看不懂也就凑合一下吧，毕竟我也是一名刚入手C#语言的菜鸟！

cpp_learners
关注
  • 7
    点赞
  • 踩
  • 67
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C#中的委托delegate（2）
oSmileOO的博客
10-06 358
委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种方法动态地给参数赋值的做法，可以避免在程序中大量使用 namespace Delegate { //定义
C# 使用带参数的委托
ak49的博客
06-07 2337
C# 使用带参数的委托
C#委托应用详解：概念、实例与代码注释
最新发布
java专栏
04-17 647
C#中的委托是一种强类型的功能性对象，它代表了具有特定签名的方法。委托允许我们将方法作为参数传递，实现事件处理、回调、异步编程以及代码模块化与重用。本篇文章将深入探讨C#委托的核心概念、使用场景、创建与实例化过程，并通过丰富的代码示例和详尽注释，展示如何在实际编程中有效地应用委托。
C#高级--委托详解
李宥的博客
08-14 1万+
C#高级–委托详解 一、委托是什么 1、委托是什么 ​ 委托和类一样是一种用户自定义类型，它存储的就是一系列具有相同签名和返回类型的方法的地址，调用委托的时候，它所包含的所有方法都会被执行。 2、委托声明 （1）委托可以声明在类外部，也可以在类内部 （2）跟方法有点类似，有参数，返回值，访问修饰符，比方法声明多一个关键字delegate namespace MyDelegate { /// <summary> /// 1.无参数无返回值委托 /// <
C#基础--委托(Delegate)
five_s的博客
07-20 1万+
简单介绍C# 委托知识
【C#教程13/16】：委托
gongdiwudu的专栏
09-15 4980
委托是一种表示对具有特定参数列表和返回类型的方法的引用的类型。实例化委托时，可以将其实例与具有兼容签名和返回类型的任何方法相关联。您可以通过委托实例调用（或调用）该方法。
c# 委托的常见用法
12-16
　语法看似像声明一个变量或方法的签名，但实现上是在声明一个类型。编译器会生成一个派生自System.MulticastDelegate的类(而System.MulticastDelegate派生自System.Delegate)，类型名与委托的名字相同，其中包含...
C#委托与匿名委托详解
08-29
C#委托与匿名委托详解 C#中的委托是一种特殊的类型，它可以视为一个方法签名的抽象表示。委托的主要作用是将方法作为参数传递给其他方法，或者将方法作为返回值从其他方法中返回。委托的定义使用delegate关键字，...
C#委托使用实例入门
10-03
本文将深入探讨C#委托的使用实例，帮助初学者理解并掌握这一核心概念。 首先，理解委托的基本概念是至关重要的。在C#中，委托是一种类型，它代表了一个方法的签名。这意味着，当创建一个委托实例时，我们实际上是...
C#中委托用法
09-03
下面我们将深入探讨C#中的委托用法。 首先，我们来看一个简单的例子，这个例子中定义了一个名为`Predicate`的委托类型，它表示一个接受`Student`对象并返回`bool`值的方法。这样，我们就可以创建一个委托实例，将...
C#委托代码样例DelegateDemo
02-22
在C#编程语言中，委托（Delegate）是一种强大的特性，它允许我们把方法作为参数传递，或者存储在变量中...在`DelegateDemo`这个示例项目中，你可能会看到如何在实际代码中应用这些概念，从而加深对C#委托和事件的理解。
C++中实现委托（delegate）
05-06
网上有很多关于C++ delegate机制的文章，但都讲的是函数指针的内容，上周就C++中实现C#的delegate机制的问题研究了好几天，查看了很多相关资料，才解决了问题，现将我写的C++ delegate测试程序贴出来，希望能帮到有需要的人。
C#基础篇——委托
chinaherolts2008的博客
12-30 2385
前言 在本章中，主要是借机vb.net教程这个C#基础篇的系列整理过去的学习笔记、归纳总结并更加理解透彻。 在.Net开发中，我们经常会遇到并使用过委托，如果能灵活的掌握并加以使用会使你在编程中游刃有余，然后对于很多接触C#时间 c#教程不长的开发者而言，较好的理解委托和事件并不容易。 本节主要是讲述对委托的定义、委托的使用、多播委托、泛型委托、匿名方法、Func和Action委托、Lambda委托，并对它们进行讨论。 说明 简单说它就是一个能把方法当参数传递的对象，而且还知道怎么调用这个方法，同时也是粒度
c#委托详解
naer_chongya的博客
05-03 740
C#中的委托是一个类型，它描述了一个方法的签名，即方法的参数类型和返回类型。委托可以看作是一个指向方法的引用，使得我们可以像使用函数指针一样调用这些方法。将一个或多个方法作为参数传递给另一个方法，从而在需要时调用这些方法。实现事件处理程序。实现回调方法。实现异步编程等功能。其中，accessModifier是可选的访问修饰符，returnType是委托返回值类型，name是委托名字，ParameterList是委托参数列表。
c# 中委托的多种写法
wang371659926的博客
08-22 1844
一、按照标准的事件委托格式编写 public delegate void MyDelegateHandler(string name);         public static event MyDelegateHandler myDelegate;         public static void OnMyDelegate(string name)         {       ...
c#委托（Delegates)--基本概念及使用
热门推荐
陈一木木
05-13 5万+
   在我这菜鸟理解上，委托就是可以用方法名调用另一方法的便捷方法，可以简化switch等语句的重复。最近做项目的时候恰好需要用到委托，便来复习及学习委托的使用。嗯...本人以前并没有用过，只是稍微知道而已。以下是整理的笔记。一.委托的概念    委托是用户自定义的类，它定义了方法的类型。储存的是一系列具有相同参数和返回类型方法的地址列表，调用委托时，此委托列表的所有方法都将被执行。二.委托类型的...
C#语言入门详解---委托（刘铁猛）
weixin_43885532的博客
01-07 1624
委托：函数指针的升级版，可以类比C语言中的函数指针进行理解 变量的本质就是以变量名所对应的内存地址为起点的一段内存，这段内存中存储的就是变量的数据，这段内存的大小由变量的数据类型决定。 函数代表算法，函数的本质是以函数名所对应的内存地址为起点的一段内存中，这段内存中存储的不是某个值，而是一组机器语言的指令，CPU就是按照这组指令一条一条执行完成这段函数中所包含的算法。 无论是数据还是算法都是保存在内存中的，变量是用来寻找数据的地址，函数是用来寻找算法的地址。 C#通过委托这种数据类型保留了与C/
【C#】委托-Delegate
aoduan2234的博客
06-09 844
C#委托（Delegate） C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。委托（Delegate）是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。 委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自System.Delegate类。 声明委托（Delegate） 委托声明决定了可由...
c# 委托用法
05-27
C# 委托是一种类型，它允许将方法作为参数传递给其他方法或存储在变量中。委托常用于事件处理程序、回调函数和多线程编程等场景，以下是 C# 委托的用法： 1.定义委托类型 可以使用 `delegate` 关键字定义一个委托类型，例如： ``` delegate void MyDelegate(string message); ``` 上面的代码定义了一个委托类型 `MyDelegate`，它可以引用一个参数为字符串类型、返回值为 void 的方法。 2.创建委托对象 可以使用 `new` 关键字创建一个委托对象，例如： ``` MyDelegate myDelegate = new MyDelegate(MyMethod); ``` 上面的代码创建了一个委托对象 `myDelegate`，它引用方法 `MyMethod`。 3.调用委托对象 可以使用委托对象调用它所引用的方法，例如： ``` myDelegate("Hello, world!"); ``` 上面的代码调用了委托对象 `myDelegate` 引用的方法，并传入参数。 4.多播委托 委托可以组合成多个方法的调用，形成一个多播委托。可以使用加法运算符将多个委托组合成一个新的委托，例如： ``` MyDelegate myDelegate1 = new MyDelegate(MyMethod1); MyDelegate myDelegate2 = new MyDelegate(MyMethod2); MyDelegate myDelegate3 = myDelegate1 + myDelegate2; ``` 上面的代码创建了三个委托对象，并将前两个委托对象组合成一个新的委托对象 `myDelegate3`。 5.使用内置委托类型 C# 还提供了一些内置的委托类型，例如 `Func`、`Action`、`Predicate` 等。可以直接使用这些内置委托类型，无需定义新的委托类型。例如： ``` Func<int, int, int> myFunc = (x, y) => x + y; int result = myFunc(1, 2); // result = 3 ``` 上面的代码使用内置委托类型 `Func` 定义了一个接收两个 int 类型参数并返回 int 类型结果的委托对象 `myFunc`，并使用 lambda 表达式实现了方法体。 以上就是 C# 委托的基本用法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cpp_learners

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值