事件和委托

以一个列子开始了解委托更容易些，下面是委托的使用方式：

internal delegate void Feedback（int32 value）fb；
//使用
public void main（）
{
    fb = getsomthing;
    fb+=getanything;
     
    if(fb != null)
    {
        fb(321);
    }
    fb-=getanything;
    fb（123）；
}

private void getsomthing（int32 value）
{
    Console.WriteLine($"this value is {value}")
}

private static void getanything(int32 value)
{
    Console.WriteLine($"this value is anything {value}")
}

编译器在遇到 ：internal delegate void Feedback （int32 value）；语句时会将它编译为一个类，这个类继承 System.MulticastDelegate 基类，而System.MulticastDelegate 又继承自 System.delegate。

这个类也有构造函数，它要求传递两个参数，一个 object 和一个 IntPtr 。把它们保存到内部的字段中(字段是来自基类)，以后会通过它们找到回调函数。

这个类其他的方法有，invoke、BeginIvoke，EndIvoke。这个具体是啥样参照下面的代码:

internal class Feedback : System.MulticastDelegate {
    // Constructor
    public Feedback(Object @object, IntPtr method);
    
    // Method with same prototype as specified by the source code
    public virtual void Invoke(Int32 value);
    
    // Methods allowing the callback to be called asynchronously
    public virtual IAsyncResult BeginInvoke(Int32 value,
        AsyncCallback callback, Object @object);
    
    public virtual void EndInvoke(IAsyncResult result);
}

它的基类MulticastDelegate 有三个关键字段：

 

• target 是一个 Object 类型，如果包装的方法是静态的，这个字段就是null，如果包装的实例方法，这个字段就是实例的引用。

• methodPtr 是一个内部整数值，CLR 用它标识回调方法。

• _invocationList 是Object 类型，构造委托链时它引用一个委托数组。

上面的C# 语句 fb = getsomthing；，实际上会被编译器转为 Feedback fb = new Feedback（getsomthing）；

在委托调用回调方法时：fb（321），实际上是调用 委托实例的 invoke 方法，这个方法的返回值和参数与 getsomthing 一致，它使用私有变量 _target 和 _methodPtr 在指定对象上调回调方法。

 

委托链

基类 Delegate 中有两个重要的方法，一个是Combine 另一个是 Remove，是构造委托链时使用的。

上面的语句 fb+=getanything; 编译器会转为fb = （Feedback）Delegate.Combine(fb , new Feedback(getanything));

Combine 方法传递两个参数，一个是fb ，另一个 是新的委托实例。分三种情况：

• 如果fb 是null，Combine 直接返回 参数2。

• 如果fb 不是null，Combine 创建一个新的委托实例，并将_invocationList 初始化为一个委托数组，第一个元素是参数1，第二个元素是参数2.

• 如果fb 不是null，第一个参数也是一个包含委托数组的委托实例，Combine也会创建一个新的委托实例，并将它的 _invocationList 初始化成一个委托数组，元素的前几个是参数1的委托数组元素，最后是参数2

　　

图是CLR via C# 中截取的，fb被赋值新的委托实例后，原来的就被垃圾回收处理了。

 

当C# 遇到fb-=getanything; C#编译器会转为这样：fb = （Feedback）Delegate.Remove(fb , new Feedback(getanything));

Remove 方法传递也是两个参数，Remove 方法的内部有以下几个步骤：

• 首先扫描参数1 的委托数组，从尾到头。

• 如果委托数组中有参数2，就删除它，

  • 删除后如果数组为空，返回null，

  • 如果只剩一个，返回这个委托实例，

  • 如果还剩多个，就再创建一个新的委托实例，将参数1的数组除去参数2，全部赋值到新委托实例中的数组中。

 

在调用 fb（321） 时会触发这个委托链。委托的invoke 方法是定义 Feedback 类型时就定义好了。下面是伪代码实现 invoke方法：

public void Invoke(Int32 value) {
    Delegate[] delegateSet = _invocationList as Delegate[];
    if (delegateSet != null) {
        // This delegate's array indicates the delegates that should be called
        foreach (Feedback d in delegateSet)
            d(value); // Call each delegate
    } else {
        // This delegate identifies a single method to be called back
        // Call the callback method on the specified target object.
        _methodPtr.Invoke(_target, value);
        // The preceding line is an approximation of the actual code.
        // What really happens cannot be expressed in C#.
    }
}
​
//如果是有返回值的回调方法，invoke 也被定义为有返回值，但是委托链调用后，只返回最后一个委托实例包装方法的返回值。
//这是为啥呢？看下面的 invoke方法的实现就知道了。不是我臆想的，它截取自 CLR via C#。
public Int32 Invoke(Int32 value) {
    Int32 result;
    Delegate[] delegateSet = _invocationList as Delegate[];
    if (delegateSet != null) {
        // This delegate's array indicates the delegates that should be called
        foreach (Feedback d in delegateSet)
            result = d(value); // Call each delegate
    } else {
        // This delegate identifies a single method to be called back
        // Call the callback method on the specified target object.
        result = _methodPtr.Invoke(_target, value);
        // The preceding line is an approximation of the actual code.
        // What really happens cannot be expressed in C#.
    }
    return result;
}

调用委托链时是顺序执行委托函数的，如果某个委托实例包含的方法运行出错了，上面的这种方法会导致，接下来的委托实例包含的方法得不到调用。

怎么办呢? 解决办法是从fb 实例中获取出委托数组。

MulticastDelegate 类提供了一个实例方法 GetInvocationList，用于显示调用委托数组中的每个委托。

public abstract class MulticastDelegate : Delegate {
    // Creates a delegate array where each element refers
    // to a delegate in the chain.
    public sealed override Delegate[] GetInvocationList();
}

使用的方式如下：

 事件

事件也是类型中的一种成员。

 

什么叫事件？

 

定义了事件成员的类型，允许类型或者类型的实例 通知其他对象发生了特定的事情。 

具体的说 定义了事件成员的类型 能提供以下功能：

 

1 方法能登记他对事件的关注

2 方法能注销他对事件的关注

3 事件发生时，登记了的方法将收到通知

 

事件通知功能是怎么做到的？

 

因为类型中维护了一个列表，列表中记录了已登记的方法。事件发生后类型将通知列表中所有的登记方法。 

CLR事件模型以委托为基础，对象凭借回调方法接收他们订阅的通知。

 

实现一个事件需要有哪些操作？

1、定义一个事件类型，  事件引发时，引发事件的对象，希望能向接收事件的对象发送一些附加信息。这些附加信息封装在自己的类中（可以定义字段、属性来实现）。

这种类应该从System.EventArgs 派生， 而且类名以 EventArgs 结束。

// Step #1: Define a type that will hold any additional information that
// should be sent to receivers of the event notification
internal class NewMailEventArgs : EventArgs {
    private readonly String m_from, m_to, m_subject;
    public NewMailEventArgs(String from, String to, String subject) {
        m_from = from; m_to = to; m_subject = subject;
    }
    public String From { get { return m_from; } }
    public String To { get { return m_to; } }
    public String Subject { get { return m_subject; } }
}

2、定义事件成员

事件成员使用C#关键字 event 定义。每个事件成员都要指定以下内容：    

• 可访问性标识符 public 、 委托类型、名称；    
• 用第一步定义好的事件类型，定义一个事件成员。

internal class MailManager {
    // Step #2: Define the event member
    public event EventHandler<NewMailEventArgs> NewMail;
    ...
}

3、定义负责引发事件的方法

    按照约定，类要定义一个受保护的虚方法。引发事件时，类及派生类中的代码会调用该方法。这个方法只获取一个参数，就是第一步定义的事件类型实例的对象，它包含了要发送的消息。在这个方法给事件订阅者发送事件消息之前，会检查一下是否有人订阅了该事件，如果有的话再发送。在执行发送事件消息的时候，涉及到多线程并发的问题，确保一个事件不能被重发两次。

protected virtual void OnNewMail(NewMailEventArgs e) {
    EventHandler<NewMailEventArgs> temp = Volatile.Read(ref NewMail);
    if (temp != null) temp(this, e);
}

像上面这样写没有问题，但是用扩展泛型方法可以让所有的事件类型都能用该函数，只要它的参数是一个 EventHandler委托。

public static class EventArgExtensions {
    public static void Raise<TEventArgs>(this TEventArgs e,
    Object sender, ref EventHandler<TEventArgs> eventDelegate) {
        // Copy a reference to the delegate field now into a temporary field for thread safety
        EventHandler<TEventArgs> temp = Volatile.Read(ref eventDelegate);
        // If any methods registered interest with our event, notify them
        if (temp != null) temp(sender, e);
    }
}

使用的时候如下所示：

protected virtual void OnNewMail(NewMailEventArgs e) {
    e.Raise(this, ref m_NewMail);
}

4、实例化一个事件对象，并调用扩展方法，将事件发送出去，通过触发委托的方式。

internal class MailManager {
    // Step #4: Define a method that translates the
    // input into the desired event
    public void SimulateNewMail(String from, String to, String subject) {
    // Construct an object to hold the information we want
    // to pass to the receivers of our notification ； 实例化一个 事件对象，它包含了事件该有的信息。
    NewMailEventArgs e = new NewMailEventArgs(from, to, subject);
    // Call our virtual method notifying our object that the event
    // occurred. If no type overrides this method, our object will
    // notify all the objects that registered interest in the event
    OnNewMail(e);
    }
}

 

编译器是如何实现事件的，事件是如何工作的？

 

MailManager类用一行代码的定义了事件成员本身。C#编译器将它转换为以下三个构造。下面的代码中，CLR via C# 作者遇到并发问题都是用Interlocked.CompareExchange。

 

// 1. A PRIVATE delegate field that is initialized to null
private EventHandler<NewMailEventArgs> NewMail = null;

// 2. A PUBLIC add_Xxx method (where Xxx is the Event name)
// Allows methods to register interest in the event.
public void add_NewMail(EventHandler<NewMailEventArgs> value) {
    // The loop and the call to CompareExchange is all just a fancy way
    // of adding a delegate to the event in a thread-safe way
    EventHandler<NewMailEventArgs>prevHandler;
    EventHandler<NewMailEventArgs> newMail = this.NewMail;
    do {
        prevHandler = newMail;
        EventHandler<NewMailEventArgs> newHandler =
        (EventHandler<NewMailEventArgs>) Delegate.Combine(prevHandler, value);
        newMail = Interlocked.CompareExchange<EventHandler<NewMailEventArgs>>(
        ref this.NewMail, newHandler, prevHandler);
    } while (newMail != prevHandler);
}
// 3. A PUBLIC remove_Xxx method (where Xxx is the Event name)
// Allows methods to unregister interest in the event.
public void remove_NewMail(EventHandler<NewMailEventArgs> value) {
    // The loop and the call to CompareExchange is all just a fancy way
    // of removing a delegate from the event in a thread­safe way
    EventHandler<NewMailEventArgs> prevHandler;
    EventHandler<NewMailEventArgs> newMail = this.NewMail;
    do {
        prevHandler = newMail;
        EventHandler<NewMailEventArgs> newHandler =
        (EventHandler<NewMailEventArgs>) Delegate.Remove(prevHandler, value);
　　　　　newMail = Interlocked.CompareExchange<EventHandler<NewMailEventArgs>>(ref this.NewMail, newHandler, prevHandler); 

　　} while (newMail != prevHandler); 
}　　

1 一个被初始化为null 的私有委托字段

private EventHandler<NewMailEventArgs> NewMail = null;

 

2 一个公共 add_Xxx 方法 ， Xxx 是事件名。用来记录 方法登记对事件的关注。

 

3 一个Remove_Xxx 方法， Xxx 是事件名，用来记录 方法注销对事件的关注。

 

编译器还会再托管程序集的元数据中生成一个事件定义记录项。这个记录项包含了一些标志， 和一些基础委托类型，还引用了add 和 Remove 访问器方法， 建立事件的抽象概念，和它的访问器方法之间的联系。

 

设计侦听事件的类型

 

这里就比较简单了，在接收事件消息的类中定义一个符合委托类型的方法，将它记录到事件的回调方法中。

internal sealed class Fax {
    // Pass the MailManager object to the constructor
    public Fax(MailManager mm) {
        // Construct an instance of the EventHandler<NewMailEventArgs>
        // delegate that refers to our FaxMsg callback method.
        // Register our callback with MailManager's NewMail event
        mm.NewMail += FaxMsg;
    }
    // This is the method the MailManager will call
    // when a new email message arrives
    private void FaxMsg(Object sender, NewMailEventArgs e) { 
        // 'sender' identifies the MailManager object in case
        // we want to communicate back to it.
        // 'e' identifies the additional event information
        // the MailManager wants to give us.
        // Normally, the code here would fax the email message.
        // This test implementation displays the info in the console
        Console.WriteLine("Faxing mail message:");
        Console.WriteLine(" From={0}, To={1}, Subject={2}",e.From, e.To, e.Subject);
    }
    // This method could be executed to have the Fax object unregister
    // itself with the NewMail event so that it no longer receives
    // notifications
    public void Unregister(MailManager mm) {
        // Unregister with MailManager's NewMail event
        mm.NewMail -= FaxMsg;
    }
}

显式实现事件

 

为什么要显式实现事件？

 

System.Windows.Forms.Control 类型定义了大约70个事件，在经编译器转换之后，会生成add 和 remove 访问器方法 以及委托字段。由于大多数程序源只关心少数几个事件，从Control派生类型创建的对象都要浪费大量内存。

 

这些定义的事件没有被用到，导致了浪费。那么就需要一个方法能将需要的事件定义，不需要的事件不会定义。所以就出现了显式实现事件. 

 

如何通过显示实现事件来高效率的实现提供了大量事件的类？

 

为了高效率存储事件委托，公开了事件的每个对象都要维护一个集合（即字典）。 

集合将事件标识符作为键（key），将委托列表作为值（value）

 

如何实现这个模式：

 

1 首先实现一个EventSet 类，它代表一个集合，包含事件以及每个事件的委托列表。 

2 接着定义一个类来使用 EventSet 类。 在这个类中，一个字段引用了一个EventSet对象，而且这个类的每个事件都是显式实现的，使每个事件的add方法都将指定的 回调委托存储 到 Event对象中，而且每个事件的 remove 方法都删除指定的回调委托。