一篇文章彻底搞清楚c#中的委托与事件

一篇文章彻底搞清楚C#中的委托与事件

委托

委托（Delegate）是一种类型，它可以持有函数的引用并执行这个函数。通过委托，我们可以在不知道函数名的情况下，直接访问和执行函数。

定义

在C#中，委托是定义在类的外部，但是要在类的内部定义具体的委托实例。委托的定义格式如下：

public delegate void DelegateName(parameters)

其中 DelegateName 就是委托的名称，而 parameters 是委托所需要的参数。

委托的使用

定义

首先，我们需要定义一个委托类型：

public delegate int MyDelegate(int a, int b);

这个委托类型可以被用来表示一个带有两个 int 类型参数并且返回值也为 int 类型的方法。

实例化

然后，我们可以通过委托类型实例化一个委托，这个委托将会执行一个方法。

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

    public static void Main()
    {
        // 实例化一个委托
        MyDelegate myDelegate = new MyDelegate(Add);

        // 使用委托执行 Add 方法
        int result = myDelegate(1, 2);
        Console.WriteLine("1 + 2 = " + result);
    }
}

在这个例子中，我们实例化了一个 MyDelegate 委托，然后通过 myDelegate 来调用 Add 方法。

委托链

委托链是一种将多个委托实例组合在一起并依次执行的方式。

添加委托

我们可以通过 += 操作符向委托链中添加委托：

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

    public static int Multiply(int a, int b)
    {
        return a * b;
    }

    public static void Main()
    {
        // 实例化两个委托
        MyDelegate addDelegate = new MyDelegate(Add);
        MyDelegate multiplyDelegate = new MyDelegate(Multiply);

        // 将委托实例添加到委托链中
        MyDelegate myDelegate = addDelegate;
        myDelegate += multiplyDelegate;

        // 依次执行委托链中的委托
        int result = myDelegate(1, 2);
        Console.WriteLine("1 + 2 * 2 = " + result);
    }
}

在这个例子中，我们定义了两个带有两个 int 类型参数并且返回值也为 int 类型的方法，然后实例化了两个 MyDelegate 类型的委托。接着我们将这两个委托实例添加到了委托链中，并依次执行了这个委托链。

移除委托

我们可以通过 -= 操作符从委托链中移除委托：

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

    public static int Multiply(int a, int b)
    {
        return a * b;
    }

    public static void Main()
    {
        // 实例化两个委托
        MyDelegate addDelegate = new MyDelegate(Add);
        MyDelegate multiplyDelegate = new MyDelegate(Multiply);

        // 将委托实例添加到委托链中
        MyDelegate myDelegate = addDelegate;
        myDelegate += multiplyDelegate;

        // 从委托链中移除委托实例
        myDelegate -= addDelegate;

        // 依次执行委托链中的委托
        int result = myDelegate(1, 2);
        Console.WriteLine("1 * 2 = " + result);
    }
}

在这个例子中，我们使用了 -= 操作符将 addDelegate 委托从委托链中移除，然后只剩下了 multiplyDelegate 委托实例。

事件

事件（Event）是一种特殊的委托，它可以在委托链中添加和移除委托实例。当事件被触发时，委托链中所有的委托实例都会被执行。

定义

在C#中，事件的定义格式如下：

public event EventHandler EventName;

其中 EventHandler 是一个预定义的委托类型，用于处理事件。

定义自定义事件处理程序

public class CustomEventArgs : EventArgs
{
    public CustomEventArgs(string s)
    {
        Message = s;
    }

    public string Message { get; set; }
}

public class EventExample
{
    public delegate void CustomEventHandler(object sender, CustomEventArgs args);

    public event CustomEventHandler CustomEvent;

    public void RaiseEvent(string message)
    {
        OnCustomEvent(new CustomEventArgs(message));
    }

    protected virtual void OnCustomEvent(CustomEventArgs e)
    {
        CustomEvent?.Invoke(this, e);
    }
}

在这个例子中，我们定义了一个 CustomEventArgs 类型，用于包含我们需要传递至事件处理程序的自定义参数。然后我们定义了一个 CustomEventHandler 委托，用于处理事件。随后我们定义了一个 CustomEvent 事件，并在 RaiseEvent 方法中触发这个事件。

由于事件只能触发委托链中的方法，因此我们需要在事件定义中使用一个委托类型，而不是使用一个具体的处理程序。然后，在 OnCustomEvent 方法中，我们调用了委托链中所有的委托实例。

注册事件

public void RegisterEvent(EventExample ex)
{
    ex.CustomEvent += CustomEventHandler1;
    ex.CustomEvent += CustomEventHandler2;
}

public void CustomEventHandler1(object sender, CustomEventArgs args)
{
    Console.WriteLine(args.Message + " from EventHandler1.");
}

public void CustomEventHandler2(object sender, CustomEventArgs args)
{
    Console.WriteLine(args.Message + " from EventHandler2.");
}

在这个例子中，我们向 EventExample 中的 CustomEvent 事件注册两个事件处理程序。当事件被触发时，CustomEventHandler1 和 CustomEventHandler2 会被依次执行。

触发事件

public void TriggerEvent(EventExample ex)
{
    ex.RaiseEvent("This is a custom event.");
}

在这个例子中，我们通过调用 RaiseEvent 方法来触发 CustomEvent 事件。这个方法将会依次执行 CustomEventHandler1 和 CustomEventHandler2。

总结

• 委托是一种可以持有函数引用并执行这个函数的类型。通过委托，我们可以在不知道函数名的情况下，访问和执行这个函数。
• 委托链是一种将多个委托实例组合在一起并依次执行的方式。
• 事件是一种特殊的委托，可以在委托链中添加和移除委托实例。当事件被触发时，委托链中所有的委托实例都会被执行。

示例

下面是一个简单的示例，演示了如何使用委托和事件：

using System;

public delegate int MyDelegate(int a, int b);

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

    public static int Multiply(int a, int b)
    {
        return a * b;
    }

    public static void Main()
    {
        // 实例化两个委托
        MyDelegate addDelegate = new MyDelegate(Add);
        MyDelegate multiplyDelegate = new MyDelegate(Multiply);

        // 将委托实例添加到委托链中
        MyDelegate myDelegate = addDelegate;
        myDelegate += multiplyDelegate;

        // 依次执行委托链中的委托
        int result = myDelegate(1, 2);
        Console.WriteLine("1 + 2 * 2 = " + result);

        // 定义事件
        EventExample ex = new EventExample();

        // 注册事件
        RegisterEvent(ex);

        // 触发事件
        TriggerEvent(ex);
    }

    public static void RegisterEvent(EventExample ex)
    {
        ex.CustomEvent += CustomEventHandler1;
        ex.CustomEvent += CustomEventHandler2;
    }

    public static void CustomEventHandler1(object sender, CustomEventArgs args)
    {
        Console.WriteLine(args.Message + " from EventHandler1.");
    }

    public static void CustomEventHandler2(object sender, CustomEventArgs args)
    {
        Console.WriteLine(args.Message + " from EventHandler2.");
    }

    public static void TriggerEvent(EventExample ex)
    {
        ex.RaiseEvent("This is a custom event.");
    }
}

public class CustomEventArgs : EventArgs
{
    public CustomEventArgs(string s)
    {
        Message = s;
    }

    public string Message { get; set; }
}

public class EventExample
{
    public delegate void CustomEventHandler(object sender, CustomEventArgs args);

    public event CustomEventHandler CustomEvent;

    public void RaiseEvent(string message)
    {
        OnCustomEvent(new CustomEventArgs(message));
    }

    protected virtual void OnCustomEvent(CustomEventArgs e)
    {
        CustomEvent?.Invoke(this, e);
    }
}