C#-委托的详细用法

真的没事鸭

已于 2024-06-09 13:08:05 修改

阅读量9.1k

点赞数 5

分类专栏： C# 文章标签： c# 开发语言

于 2022-08-10 20:25:59 首次发布

本文链接：https://blog.csdn.net/qq_52905520/article/details/126261862

版权

C# 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

什么是委托

委托是一种函数引用的Object，实际上是用类完成了函数指针的功能

C#中的委托（Delegate）类似于C或C++中函数的指针。委托（Delegate）是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。

委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自System.Delegate 类。

说人话就是委托是一种引用类型，它可以用来引用一个或多个方法，并且也可以将方法作为参数传递给其他方法，或者将方法作为返回值类型返回。

委托的使用

1，声明委托：

Delegate void Print(int x)

2，初始化，给委托赋值

方法1：Print someFunc=hello;
方法2：Print someFunc=new Print(hello);

3，调用委托变量

SomeFunc(x);

委托的分类

委托静态方法：委托一个静态方法
委托实例方法：委托一个实例方法

委托的原理

委托是将函数指针和实例对象打包在一起的类，它有两个重要的成员，一个用来保存实例对象，一个用来保存函数的指针。从源码中可以查看System.Delegate

我们查看System.Delegate的属性，可以看到一个属性Target

public Object Target
{
    get
    {
        return GetTarget();
    }
}

看一下GetTarget的功能

internal virtual Object GetTarget()
{
    return (_methodPtrAux.IsNull())?_target:null;
}

意思就是当把一个静态方法给委托的时候将会返回一个null，如果是一个实例方法时，将会返回当前方法所在的实例对象(this)

下面用一段代码演示一下：

using System;
//声明委托
public delegate void Print(int x);
namespace ConsoleApp1
{
    public class Test
    {
        //实例方法
        public void Test1(int x)
        {
            Console.WriteLine("实例方法,数字：{0}",x);
        }
        //静态方法
        public static void Test2(int x)
        {
            Console.WriteLine("静态方法，数字：{0}",x);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //委托的使用
            Test t = new Test();//实例对象
            Print p1 = new Print(t.Test1);//委托赋值
            p1(25);//调用委托
            Print p2 = Test.Test2;//委托赋值
            p2(33);//调用委托
            //委托原理
            Console.WriteLine(p1.Target is Test);//实例方法-判断Target是不是指向方法所在的对象
            Console.WriteLine(p2.Target is Test);//静态方法-判断Target是不是null
            Console.ReadLine();
        }
    }
}

输出结果

实例方法，数字：25
静态方法，数字：33
True
False

也就是如果Target属性为null说明是静态方法的委托，如果不为null说明是实例方法的委托

需要注意的是声明的委托类型和被委托的函数类型以及参数要一致，如果委托没有返回值，那么被委托的函数也要没有返回值，如果委托有参数，那么被委托的函数和委托的参数类型要一致。

如果这个还不是很好理解的话，下面我们再看一段代码

using System;

// 定义一个委托类型
public delegate void MyDelegate(string message);

public class DelegateExample
{
    // 一个接受委托作为参数的方法
    public void ProcessMessage(string message, MyDelegate callback)
    {
        // 处理消息
        Console.WriteLine("Processing message: " + message);
        // 调用委托，传递消息
        callback(message);
    }
}

public class Program
{
    // 一个方法作为委托的实例
    public static void DisplayMessage(string message)
    {
        Console.WriteLine("Displaying message: " + message);
    }

    public static void Main()
    {
        DelegateExample example = new DelegateExample();//创建一个实例
        // 创建委托实例并传递方法引用
        MyDelegate delegateInstance = new MyDelegate(DisplayMessage);
        // 调用方法，并将委托作为参数传递
        example.ProcessMessage("Hello, World!", delegateInstance);
    }
}

输出结果

Processing message: Hello, World!
Displaying message: Hello, World!
请按任意键继续. . .

我们首先定义了一个名为 MyDelegate 的委托类型，它可以引用一个带有 string 类型参数和无返回值的方法，或者接收一个也是参数也是String类型的方法。

然后，我们创建了一个包含 ProcessMessage 方法的类，该方法接受一个字符串和一个委托作为参数，然后调用传入的委托并传递消息。

最后，在 Main 方法中，我们创建了一个委托实例MyDelegate，并将一个DisplayMessage方法引用传递给它，然后将这个委托实例作为参数传递给 ProcessMessage 法。

注意：将方法传递给委托时，此方法和委托的形参要一致，也就是传入的参数要一致。

所以在32行将委托作为参数传递给ProcessMessage的时候，首先输出Processing message:hello，然后调用委托，在之前我们已经将DisplayMessage传递给了委托，所以在调用委托时，会调用DisplayMessage方法。

通过这两个代码就可以很直白的看出委托的作用，就是将方法封装在委托中，然后就可以将委托对象传递给可调用所引用方法的代码，不必在编译时知道将要调用那个方法。（这样应该就清楚了吧，在看不懂就说不过去了）。

通常委托和事件一起使用来构成发布-订阅模式，或者叫观察者模式。

系统内置委托

前面是自己定义的委托，但是系统也提供了两种委托：Action和Func，Action用于不需要返回值的委托，Func适合需要返回值的委托

Action委托

1，Action委托封装一个方法，该方法不具有参数并且不返回值

2，Action<T>委托封装一个方法，该方法只有一个参数并且不返回值

3，Action<T1,T2>委托封装一个方法，该方法具有两个参数并且不返回值

最多有16个参数

Func委托

1，Func(TResult)委托封装封装一个不具有参数但却返回 TResult 参数指定的类型值的方法

2，Func(T,TResult)委托封装一个具有一个参数并返回 TResult 参数指定的类型值的方法

3，Func(T1,T2,TResult)委托封装一个具有两个参数并返回 TResult 参数指定的类型值的方法

其中的T是参数类型，TResult是返回值类型

下面用一个例子演示：

using System;

namespace ConsoleApp1
{
    public class Test
    {
        //Action示例
        public void Test1(int x)
        {
            Console.WriteLine("打印数字："+x);
        }
        //Func示例
        public int Test2(int n)
        {
            return n;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //系统内置委托的使用
            Test t = new Test();//实例对象
            Action<int> ac1 = new Action<int>(t.Test1);//委托赋值
            ac1(22);//调用委托
            Func<int, int> ac2 = new Func<int, int>(t.Test2);//委托赋值
            Console.WriteLine(ac2(233));//调用委托
            Console.ReadLine();
        }
    }
}

输出结果：

打印数字：22
233

多播委托

多播委托是指在一个委托中注册多个方法，在注册方法时可以在委托中使用加号运算符

或者减号运算符来实现添加或撤销方法。

比如现实的点餐系统，可以点甜食，面食，水果等，在这里委托相当于点餐平台，每一个类型的商品可以理解为在委托商注册的一个方法。

使用委托的这个有用的特点，可以创建一个委托被调用时要调用的方法的调用列表。这被称为委托的多播（multicasting），也叫组播。

下面的程序演示了委托的多播：

using System;

//声明委托
public delegate void Order();
namespace ConsoleApp1
{
    public class Test
    {
        //买水果
        public void Test1()
        {
            Console.WriteLine("购买水果！");
        }
       //买甜食
       public static void Test2()
        {
            Console.WriteLine("购买甜食！");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //多播委托
            Test t = new Test();//实例对象
            Order order =new Order(t.Test1);//委托赋值-实例方法
            order += new Order(Test.Test2);//委托赋值-静态方法
            order();//调用委托
            Console.ReadLine();
        }
    }
}

输出结果：