委托 - 《C#编程指南》 - 严富坤的知识库专栏(yanfukun.com)

什么是委托？
- 委托的声明与使用
委托的实例化和调用
多播委托
- 多播委托的实现
委托的实际应用
- 委托与事件
委托与回调
泛型委托
Action和Func委托
- Action委托
- Func委托
Lambda表达式与委托
委托的高级用法
- 异步编程
- 事件聚合
小结

C#语言作为一种现代化的编程语言，以其强大的功能和灵活的特性受到了广泛的欢迎。其中，委托（Delegate）是C#中的一个重要特性，它为程序员提供了一种强大且灵活的方式来处理方法的调用和事件的处理。本文将深入探讨C#中的委托，从基础概念到高级用法，并结合实际例子，帮助读者全面理解和掌握这一重要技术。

什么是委托？

委托是一种引用方法的类型，它类似于C语言中的函数指针，但更加安全和灵活。在C#中，委托是一种类型，可以定义为方法的签名。换句话说，委托是一种可以存储对具有特定参数列表和返回类型的方法的引用的对象。

委托的声明与使用

在C#中，声明一个委托的语法如下：

public delegate void MyDelegate(string message);

上面的代码定义了一个名为MyDelegate的委托类型，该委托可以引用任何返回类型为void，并且带有一个string类型参数的方法。

委托的实例化和调用

一旦声明了一个委托类型，就可以创建该委托类型的实例，并将方法赋给它。例如：

public class Program
{
    public static void Main(string[] args)
    {
        // 创建委托实例，并指向一个具体的方法
        MyDelegate del = new MyDelegate(ShowMessage);
        // 调用委托
        del("Hello, World!");
    }
    // 被委托引用的方法
    public static void ShowMessage(string message)
    {
        Console.WriteLine(message);
    }
}

上面的代码展示了如何创建一个MyDelegate类型的委托实例del，并将方法ShowMessage赋给它。然后，通过调用del，实际上是调用了ShowMessage方法，并传递了参数。

多播委托

C#中的委托不仅可以引用一个方法，还可以引用多个方法。这种能力使得委托可以成为事件处理的基础。这种引用多个方法的委托称为多播委托（Multicast Delegate）。

多播委托的实现

多播委托可以通过+=运算符将多个方法附加到同一个委托实例上，例如：

public class Program
{
    public static void Main(string[] args)
    {
        MyDelegate del = ShowMessage;
        del += ShowAnotherMessage;
        del("Hello, World!");
    }
    public static void ShowMessage(string message)
    {
        Console.WriteLine("Message: " + message);
    }
    public static void ShowAnotherMessage(string message)
    {
        Console.WriteLine("Another message: " + message);
    }
}

在上面的例子中，委托del依次调用了ShowMessage和ShowAnotherMessage方法。

委托的实际应用

委托在实际开发中有广泛的应用场景，包括事件处理、回调机制、LINQ等。在这一部分，我们将深入探讨委托在这些场景中的具体应用。

委托与事件

在C#中，事件是基于委托实现的。事件是一种特殊的委托，用于在某个操作发生时通知其他对象。通过事件，类可以提供一种机制，允许其他类注册和响应某些操作的发生。

以下是一个简单的事件例子：

public class Publisher
{
    public delegate void NotifyEventHandler(object sender, EventArgs e);
    public event NotifyEventHandler Notify;
    public void RaiseEvent()
    {
        if (Notify != null)
        {
            Notify(this, EventArgs.Empty);
        }
    }
}
public class Subscriber
{
    public void OnNotify(object sender, EventArgs e)
    {
        Console.WriteLine("Event received.");
    }
}
public class Program
{
    public static void Main(string[] args)
    {
        Publisher publisher = new Publisher();
        Subscriber subscriber = new Subscriber();
        publisher.Notify += subscriber.OnNotify;
        publisher.RaiseEvent();
    }
}

在这个例子中，我们定义了一个事件Notify，并在RaiseEvent方法中触发该事件。当事件被触发时，所有订阅该事件的方法都会被调用。

委托与回调

回调是一种常见的编程模式，允许在某个操作完成后调用指定的方法。在C#中，回调通常通过委托实现。以下是一个使用委托实现回调的例子：

public class Program
{
    public delegate void CallbackDelegate(string message);
    public static void Main(string[] args)
    {
        ExecuteAction("Hello, World!", PrintMessage);
    }
    public static void ExecuteAction(string message, CallbackDelegate callback)
    {
        // 执行一些操作
        Console.WriteLine("Action executed.");
        // 调用回调方法
        callback(message);
    }
    public static void PrintMessage(string message)
    {
        Console.WriteLine("Callback message: " + message);
    }
}

在这个例子中，我们定义了一个CallbackDelegate类型的委托，并在ExecuteAction方法中接受该委托作为参数。然后，在执行某些操作后，调用回调方法。

泛型委托

C#中的委托可以是泛型的，允许定义具有不同类型参数和返回类型的委托。通过使用泛型委托，可以大大增加代码的灵活性和重用性。

以下是一个泛型委托的例子：

public class Program
{
    public delegate T Transformer<T>(T arg);
    public static void Main(string[] args)
    {
        Transformer<int> square = Square;
        Console.WriteLine(square(5));  // 输出 25
        Transformer<string> reverse = Reverse;
        Console.WriteLine(reverse("Hello"));  // 输出 olleH
    }
    public static int Square(int x)
    {
        return x * x;
    }
    public static string Reverse(string s)
    {
        char[] array = s.ToCharArray();
        Array.Reverse(array);
        return new string(array);
    }
}

在这个例子中，我们定义了一个泛型委托Transformer<T>，并分别使用了不同的类型实例化该委托。

Action和Func委托

为了简化委托的使用，C#提供了两个内置的泛型委托：Action和Func。Action用于没有返回值的方法，而Func用于有返回值的方法。

Action委托

Action委托用于表示没有返回值的方法，可以接受0到16个参数。例如：

public class Program
{
    public static void Main(string[] args)
    {
        Action<string> action = PrintMessage;
        action("Hello, World!");
    }
    public static void PrintMessage(string message)
    {
        Console.WriteLine(message);
    }
}

在这个例子中，Action<string>委托表示一个接受string参数且没有返回值的方法。

Func委托

Func委托用于表示有返回值的方法，可以接受0到16个参数，并且最后一个类型参数是返回类型。例如：

public class Program
{
    public static void Main(string[] args)
    {
        Func<int, int, int> func = Add;
        int result = func(5, 3);
        Console.WriteLine(result);  // 输出 8
    }
    public static int Add(int x, int y)
    {
        return x + y;
    }
}

在这个例子中，Func<int, int, int>委托表示一个接受两个int参数并返回一个int的函数。

Lambda表达式与委托

Lambda表达式是C#中一种简洁的匿名函数表示法，通常用于创建委托或表达式树。Lambda表达式可以与委托结合使用，使得代码更加简洁和可读。

以下是一个使用Lambda表达式创建委托的例子：

public class Program
{
    public static void Main(string[] args)
    {
        Func<int, int, int> add = (x, y) => x + y;
        Console.WriteLine(add(5, 3));  // 输出 8
        Action<string> print = message => Console.WriteLine(message);
        print("Hello, World!");
    }
}

在这个例子中，我们使用Lambda表达式创建了一个Func<int, int, int>委托和一个Action<string>委托。

委托的高级用法

除了基本的用法，委托在一些高级场景中也有广泛应用，例如异步编程和事件聚合。

异步编程

在异步编程中，委托可以用于定义和执行异步操作。C#中的BeginInvoke和EndInvoke方法允许异步调用委托。例如：

public class Program
{
    public delegate int AddDelegate(int x, int y);
    public static void Main(string[] args)
    {
        AddDelegate add = Add;
        IAsyncResult result = add.BeginInvoke(5, 3, null, null);
        int sum = add.End
Invoke(result);
        Console.WriteLine(sum);  // 输出 8
    }
    public static int Add(int x, int y)
    {
        return x + y;
    }
}

在这个例子中，我们使用BeginInvoke方法异步调用Add方法，并在稍后使用EndInvoke方法获取结果。

事件聚合

在大型应用程序中，事件聚合是一种常见的设计模式，用于集中管理和分发事件。委托可以用于实现事件聚合，简化事件的管理和处理。例如：

public class EventAggregator
{
    private readonly Dictionary<Type, List<Delegate>> _subscribers = new Dictionary<Type, List<Delegate>>();
    public void Subscribe<T>(Action<T> handler)
    {
        if (!_subscribers.ContainsKey(typeof(T)))
        {
            _subscribers[typeof(T)] = new List<Delegate>();
        }
        _subscribers[typeof(T)].Add(handler);
    }
    public void Publish<T>(T eventArgs)
    {
        if (_subscribers.ContainsKey(typeof(T)))
        {
            foreach (var handler in _subscribers[typeof(T)].Cast<Action<T>>())
            {
                handler(eventArgs);
            }
        }
    }
}
public class Program
{
    public static void Main(string[] args)
    {
        EventAggregator aggregator = new EventAggregator();
        aggregator.Subscribe<string>(message => Console.WriteLine("Subscriber 1: " + message));
        aggregator.Subscribe<string>(message => Console.WriteLine("Subscriber 2: " + message));
        aggregator.Publish("Hello, World!");
    }
}

在这个例子中，我们实现了一个简单的事件聚合器，可以订阅和发布事件。

小结

委托是C#中一个强大且灵活的特性，广泛应用于事件处理、回调机制、异步编程等场景。通过本文的介绍，相信读者已经对C#中的委托有了全面的了解。掌握委托不仅可以提高代码的可读性和可维护性，还可以在复杂应用程序中发挥重要作用。