委托(Delegate)与事件(Event)-（上篇）

C#中的委托（Delegate）是一种类型安全的函数指针，它允许将方法作为参数传递给其他方法，并且可以用来实现回调机制。委托是C#中实现事件处理、异步编程以及面向对象设计模式的重要工具之一。在C#中，委托被定义为引用类型，所有的委托都派生自System.Delegate类。

一、定义委托

定义一个委托需要使用delegate关键字，并指定返回类型和参数列表。

public delegate void MyDelegate(string message);

这里我们定义了一个名为MyDelegate的委托，它可以指向任何接受一个字符串参数且没有返回值的方法。

使用委托

1. 创建委托实例并关联方法

如果一旦定义了委托，就可以创建该委托类型的实例，并将其与具体的方法关联起来。

public class MyClass {
    public void PrintMessage(string message) {
        Console.WriteLine("PrintMessage: " + message);
    }
}

public class Program {
    public static void Main() {
        // 创建委托实例，并关联到PrintMessage方法
        MyDelegate myDelegate = new MyDelegate(new MyClass().PrintMessage);

        // 调用委托
        myDelegate("Hello, World!");
    }
}

2. 简化委托实例化

从C# 2.0开始，可以直接将方法赋值给委托变量，而不需要显式调用委托构造函数：

MyDelegate myDelegate = new MyClass().PrintMessage;
// 或者更简单的方式：
MyDelegate myDelegate = new MyClass().PrintMessage;

3. 使用匿名方法

MyDelegate myDelegate = delegate(string message) {
    Console.WriteLine("Anonymous method: " + message);
};

4. 使用Lambda表达式

从C# 3.0开始，支持使用lambda表达式，这使得代码更加简洁：

MyDelegate myDelegate = message => Console.WriteLine("Lambda expression: " + message);

5. 多播委托

委托可以链接多个方法，形成所谓的多播委托或多路广播委托。当调用这样的委托时，所有链接的方法都会被依次调用：

MyDelegate del1 = new MyClass().PrintMessage;
MyDelegate del2 = message => Console.WriteLine("Another method: " + message);

// 将两个委托连接起来
MyDelegate multiCastDelegate = del1 + del2;

// 调用多播委托
multiCastDelegate("Calling multiple methods");

在这里需要注意的是，如果多播委托中任何一个方法抛出异常，则后续的方法将不会被执行。

6.内置委托类型

除了自定义委托外，C#还提供了一些内置的委托类型，比如Action、Func和Predicate，它们适用于不同的场景：

Action<T>：表示不返回任何结果的方法，可以有一个或多个输入参数。

Func<T, TResult>：表示返回结果的方法，可以有一个或多个输入参数。

Predicate<T>：表示返回布尔值的方法，通常用于搜索条件等。

泛型委托的基本概念

泛型委托允许在其定义中包含一个或多个类型参数，这些参数可以在实例化时指定具体的类型。这意味着你可以创建一个适用于多种类型的委托，而不必为每个特定类型都定义一个新的委托类型。例如，Func<T, TResult> 是一种常见的泛型委托，它接受一个输入参数 T 并返回一个结果 TResult；同样地，Action<T> 则是另一种泛型委托，它接受一个输入参数 T 但不返回任何值。

二、定义泛型委托

public delegate R MyGenericDelegate<T, R>(T param);

这里我们定义了一个名为 MyGenericDelegate 的泛型委托，它可以接受任意类型的单个参数，并返回任意类型的值。

使用预定义的泛型委托

.NET 框架已经提供了几种常用的泛型委托类型，如 Func<>、Action<> 和 Predicate<>，它们分别用于表示有返回值的方法、无返回值的方法以及返回布尔值的方法。这三种泛型委托覆盖了大部分日常编程的需求，因此大多数情况下你不需要自己定义新的泛型委托。

Func<>：用于定义带有返回值的方法签名。它可以有一个到十六个输入参数，并且最后一个类型参数总是表示返回值的类型。

Func<int, string> formatNumber = num => $"Number: {num}";
Console.WriteLine(formatNumber(42)); // 输出: Number: 42

Action<>：用于定义没有返回值的方法签名。它可以有一个到十六个输入参数。

Action<string> printMessage = message => Console.WriteLine($"Message: {message}");
printMessage("Hello World"); // 输出: Message: Hello World

Predicate<>：专门用于定义返回布尔值的方法签名，通常用来作为条件判断的标准。

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
Predicate<int> isEven = n => n % 2 == 0;
var evenNumbers = numbers.FindAll(isEven);

实例化与调用泛型委托

如果你想要使用上述提到的泛型委托时，可以通过直接赋值方法名给委托变量的方式来进行实例化，也可以使用 lambda 表达式或者匿名函数。一旦实例化完成，就可以像调用普通方法那样调用委托对象。

// 使用方法组转换简化语法
Func<int, int, int> add = AddNumbers;

// 使用 Lambda 表达式
Func<int, int, int> multiply = (x, y) => x * y;

// 调用委托
Console.WriteLine(add(2, 3));      // 输出: 5
Console.WriteLine(multiply(2, 3)); // 输出: 6

泛型委托中的变体支持

从 C# 4.0 开始，Func<> 和 Action<> 支持协变和逆变特性，这使得我们可以更灵活地处理继承关系中的类型转换问题。具体来说，如果某个泛型委托的输出类型是从另一个类型派生出来的，则该泛型委托可以被赋值给以基类作为输出类型的委托变量（协变）。相反地，如果某个泛型委托的输入类型是基类，则它可以被赋值给以派生类作为输入类型的委托变量（逆变）。

class Animal { }
class Dog : Animal { }

// 协变示例
Func<Animal> getDog = () => new Dog();
Animal animal = getDog(); // 正确，因为 Dog 继承自 Animal

// 逆变示例
Action<Dog> feedDog = d => Console.WriteLine("Feeding dog.");
Action<Animal> feedAnimal = feedDog; // 正确，因为 Dog 继承自 Animal
feedAnimal(new Dog());

三、创建静态委托

静态委托并不是一个直接的语言特性或预定义类型，而是指将委托与静态方法关联起来使用的一种方式。

首先，你需要定义一个委托类型，它可以指向静态方法或实例方法。为了创建一个静态委托，你通常会将这个委托绑定到某个类中的静态方法上。

public class MathOperations {
    // 定义一个接受两个整数并返回一个整数的委托类型
    public delegate int Operation(int x, int y);

    // 静态方法 Add，符合上述委托签名
    public static int Add(int a, int b) {
        return a + b;
    }

    // 实例方法 Subtract，同样符合委托签名
    public int Subtract(int a, int b) {
        return a - b;
    }
}

在实例中Operation 是一个委托类型，它能够封装任意一个接受两个整数参数并返回一个整数结果的方法。我们还定义了两个符合该委托签名的方法：一个是静态方法 Add，另一个是非静态（实例）方法 Subtract。

使用静态方法实例化委托

我们可以创建 Operation 类型的委托实例，并将其与静态方法 Add 关联起来。这可以通过以下几种方式完成：

1.直接赋值：最简单的方式是直接给委托变量赋值为静态方法的名字。

MathOperations.Operation addDelegate = MathOperations.Add;

2.使用 new 关键字：也可以显式地使用 new 来创建委托实例。

MathOperations.Operation addDelegate = new MathOperations.Operation(MathOperations.Add);

3.Lambda 表达式：如果静态方法非常简单，可以考虑使用 lambda 表达式来代替命名的方法。

MathOperations.Operation addDelegate = (x, y) => x + y;

如果一旦创建了委托实例，就可以像调用普通方法一样调用它：

Console.WriteLine(addDelegate(5, 3)); // 输出: 8

在多播场景下的静态委托

C# 中的委托支持多播特性，这意味着你可以将多个方法链接到同一个委托实例上。对于静态委托而言，这意味着你可以同时注册多个静态方法，当调用委托时，所有已注册的方法都会被依次执行。不过需要注意的是，由于静态委托只涉及静态方法，因此它们不会携带任何实例上下文信息。

MathOperations.Operation operations = null;

// 添加第一个静态方法
operations += MathOperations.Add;

// 假设还有另一个静态方法 Multiply
operations += MathOperations.Multiply; // 假定存在这样的静态方法

// 调用所有已注册的方法
operations(2, 3); // 先调用 Add 再调用 Multiply

注意事项

尽管静态委托提供了方便的方式来引用静态方法，但在某些情况下也存在局限性。例如，根据 C# 的一些提案讨论，所谓的“静态委托”可能指的是那些只能引用静态函数、不能引用对象成员方法，并且不能链接到其他非静态委托的情况。然而，这些限制主要出现在有关新特性讨论的背景下，并不是当前版本 C# 的实际行为。实际上，在现行标准下，静态委托仍然可以与其他类型的委托混合使用，并且可以在多播环境中工作良好。

此外，当你在一个委托上调用 GetInvocationList() 方法获取调用列表时，如果是静态方法，则委托的 Target 属性将是 null，因为静态方法不依赖于特定的对象实例

综上所述，静态委托在 C# 中是一个有用的工具，尤其是在需要跨不同组件之间传递消息或事件处理程序的情况下。通过合理设计，你可以利用静态委托简化代码结构，减少不必要的对象实例化，从而提高性能和可维护性。