C#委托与事件原理及实例解析

委托

委托是一种类型，它可以用来表示对一个或多个方法的引用。在计算机中，委托的本质就是一个类，它可以包含方法的引用或者函数指针，并允许在运行时将方法指定给委托，以便在需要时调用该方法。

委托的定义

使用 delegate 关键字来声明一个委托类型，例如：

public delegate void MyDelegate(string message);

在上面的代码中，声明了一个名为 MyDelegate 的委托类型，它允许指向返回类型为 void，参数为 string 类型的方法。

委托的使用

假设有一个名为 MyClass 的类，其中有一个方法 MyMethod：

public class MyClass {
    public void MyMethod(string message) {
        Console.WriteLine(message);
    }
}

现在，我们使用委托将 MyMethod 引用到一个委托实例中：

MyClass myObject = new MyClass();
MyDelegate myDelegate = new MyDelegate(myObject.MyMethod);

上面的代码创建了一个 MyDelegate 类型的委托实例 myDelegate，它包含了引用 MyMethod 方法的内存地址。

为了调用该委托实例，我们可以使用 Invoke 方法：

myDelegate.Invoke("Hello, world!");

或者，我们也可以使用更为简洁的方法调用语法：

myDelegate("Hello, world!");

事件

事件是一种对象间的机制，用于在事件发生时通知其他对象。事件可以看作是委托的一个特殊使用方式，它提供者一个便利的方式，使得当一个特定的操作发生时，所有感兴趣的对象可以收到通知。

事件的定义

在 C# 中，事件可以被定义在一个类中，如下所示：

public class MyClass {
    public event EventHandler MyEvent;
}

上面的代码定义了一个事件 MyEvent，该事件的类型为 EventHandler。

事件发布者

事件需要注册一个事件发布者，负责发布事件并通知订阅者。我们来看一下事件发布者的代码：

public class MyPublisher {
    public event EventHandler MyEvent;

    protected virtual void OnMyEvent(EventArgs e) {
        if (MyEvent != null) {
            MyEvent(this, e);
        }
    }

    public void DoSomething() {
        // do something
        OnMyEvent(EventArgs.Empty);
    }
}

以上代码定义了一个 MyPublisher 类，该类包含了一个名为 MyEvent 的事件。当 DoSomething 方法被调用时，会触发 MyEvent 事件，并调用事件处理程序。

事件订阅者

事件订阅者则需要注册事件处理程序，用于在事件发生时接收并处理通知。我们来看一下事件订阅者的代码：

public class MySubscriber {
    public void OnMyEvent(object sender, EventArgs e) {
        // handle event
    }
}

以上代码定义了一个 MySubscriber 类，该类包含了一个名为 OnMyEvent 的事件处理程序。

事件的使用

我们先创建一个发布者和一个订阅者：

MyPublisher publisher = new MyPublisher();
MySubscriber subscriber = new MySubscriber();

现在，我们注册订阅者的事件处理程序：

publisher.MyEvent += subscriber.OnMyEvent;

接着，我们可以调用发布者的方法 DoSomething：

publisher.DoSomething();

当 DoSomething 方法被调用时，会触发 MyEvent 事件，并调用订阅者的事件处理程序 OnMyEvent。在事件处理程序中，我们可以对事件进行相应的处理。

示例一

我们来看一个简单的委托实例：

public delegate void MyDelegate();

public class MyClass {
    public void MyMethod1() {
        Console.WriteLine("MyMethod1 is called.");
    }

    public void MyMethod2() {
        Console.WriteLine("MyMethod2 is called.");
    }
}

public class MyProgram {
    static void Main(string[] args) {
        MyClass myObject = new MyClass();
        MyDelegate myDelegate = new MyDelegate(myObject.MyMethod1);
        myDelegate += myObject.MyMethod2;

        myDelegate.Invoke();
    }
}

在上面的代码中，我们定义了一个委托类型 MyDelegate，并在 MyClass 类中定义了两个方法 MyMethod1 和 MyMethod2。我们使用委托将这两个方法引用到一个委托实例中，并在方法中使用委托调用这两个方法。

示例二

我们来看一个简单的事件实例：

public class MyClock {
    public event EventHandler ClockTick;

    public void Start() {
        while (true) {
            Thread.Sleep(1000);
            OnClockTick();
        }
    }

    protected virtual void OnClockTick() {
        if (ClockTick != null) {
            ClockTick(this, EventArgs.Empty);
        }
    }
}

public class MyProgram {
    static void Main(string[] args) {
        MyClock clock = new MyClock();
        clock.ClockTick += MyEventHandler;
        clock.Start();
    }

    static void MyEventHandler(object sender, EventArgs e) {
        Console.WriteLine(DateTime.Now);
    }
}

在上面的代码中，我们定义了一个 MyClock 类，该类包含了一个名为 ClockTick 的事件。在 MyProgram 类中，我们创建了一个 MyClock 实例，并注册了事件处理程序 MyEventHandler。在 MyClock 类中，当 Start 方法被调用时，会一直循环并不断触发 ClockTick 事件。在 MyProgram 类中，当 ClockTick 事件被触发时，将会调用 MyEventHandler 方法，输出当前时间。