委托与事件（4）

原创链接

网上讲C#委托和事件的博文已经非常多了，其中也不乏一些深入浅出、条理清晰的文章。我之所以还是继续写，主要是借机整理学习笔记、归纳总结从而理解更透彻，当然能够以自己的理解和思路给其他人讲明白更好。
另外，太长的文章会让很多读者失去兴趣，所以我决定把这篇分成四个部分来介绍。分别是委托的基础、委托的进阶、事件的基础和事件的进阶。对使用委托与事件要求不高的同学可以跳过进阶部分。

本文开始讲最后一部分，事件的进阶，前三节请内容请参见C#委托与事件(1)、C#委托与事件(2)和C#委托与事件(3)。

---

7. 事件的高级知识

(1) 揭开事件的神秘面纱

回到上一节中我们声明的事件public event BoilHandler BoilEvent;，这里的事件虽然被声明为公开的，但上一节最后我们试图对h.BoilEvent进行赋值操作会出现编译错误。为什么会这样呢？看看编译后的BoilEvent你就明白了。

private BoilHandler BoilEvent; // 事件实际上被声明为私有的委托变量

[MethodImpl(MethodImplOptions.Synchronized)]
public void add_BoilEvent(BoilHandler value)
{   // 在事件上绑定方法实际上是间接调用Delegate.Combine()
    this.BoilEvent= (BoilHandler) Delegate.Combine(this.BoilEvent, value);
}

[MethodImpl(MethodImplOptions.Synchronized)]
public void remove_BoilEvent(BoilHandler value)
{   // 在事件上解除绑定方法实际上是间接调用Delegate.Remove()
    this.BoilEvent = (BoilHandler) Delegate.Remove(this.BoilEvent, value);
}```

上面的代码进一步说明，实际上事件就是封装了的委托，而且我们只需要键入`event`关键字，编译器就可以帮我们把相关的方法自动生成。另外，代表事件本身的`CIL`代码将使用`.addon`和`.removeon`指令对应要调用的`add_XXX()`和`remove_XXX()`方法的名称。

.event MyFirstEvent.Heater/BoilHandler BoilEvent
{
.addon instance void MyFirstEvent.Heater::add_BoilEvent(class MyFirstEvent.Heater/BoilHandler)
.removeon instance void MyFirstEvent.Heater::remove_BoilEvent(class MyFirstEvent.Heater/BoilHandler)
}“`

(2) 重申事件的必要性

我们在第6节从封装性的角度分析了“为什么要用事件”，上面部分又说明了实际上event就是封装的delegate，所以事件在易用性上又占了上风，因为event关键字能够帮助我们节省很多代码的键入。另外，张子阳又从设计模式的角度解释了“为什么要使用事件而不是委托”。我觉得很有道理，所以将借用他的例子来重申一下他的观点。

首先我们定义一个带有一个int参数的委托NumberChangedEventHandler，然后再定义一个发布者和订阅者。其中发布者类中可以声明上述委托的变量或者对应的事件，发布者通过DoSomething()方法来执行委托变量或事件上绑定的方法。而订阅者类中则声明了订阅的方法即实际上应该绑定到委托的方法。所以，用通俗的语言来解释就是，订阅者订阅了某种消息，发布者在它的某种行为中满足了某种条件后触发某件事情的发生，而这件事情的发生正是订阅者订阅的东西，所以发布者触发某事件后即会通知到所有的订阅者。

(a) 如果声明委托变量，那么在Main函数也就是客户端中可以通过pub.NumberChanged(100);来触发事件，这不满足事件由发布者在其内部的某种行为下触发的设计模式。
(b) 如果声明为事件，则它的封装性限制了客户端的行为（直接调用pub.NuberChanged会出现编译错误），从而保证了事件只能供其他类型订阅。

namespace PubSub
{
    public delegate void NumberChangedEventHandler(int count); //定义委托

<span class="hljs-keyword">public</span> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Publishser</span>
{</span>
    <span class="hljs-keyword">private</span> <span class="hljs-keyword">int</span> count;
    <span class="hljs-comment">//public NumberChangedEventHandler NumberChanged;     // 声明委托变量</span>
    <span class="hljs-keyword">public</span> event NumberChangedEventHandler NumberChanged; <span class="hljs-comment">// 声明一个事件</span>

    <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">DoSomething</span><span class="hljs-params">()</span>
    </span>{
        <span class="hljs-comment">// todo: do something</span>

        <span class="hljs-keyword">if</span> (++count &gt; <span class="hljs-number">0</span>)
        {
            <span class="hljs-keyword">if</span> (NumberChanged != null)
            {
                NumberChanged(count);
            }
        }
    }
}

<span class="hljs-keyword">public</span> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Subscriber</span>
{</span>
    <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">OnNumberChanged</span><span class="hljs-params">(<span class="hljs-keyword">int</span> count)</span>
    </span>{
        Console.WriteLine(<span class="hljs-string">"Subscriber notified: count = {0}"</span>, count);
    }
}

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Program</span>
{</span>
    <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Main</span><span class="hljs-params">(<span class="hljs-built_in">string</span>[] args)</span>
    </span>{
        Publishser pub = <span class="hljs-keyword">new</span> Publishser();
        Subscriber sub = <span class="hljs-keyword">new</span> Subscriber();

        pub.NumberChanged += <span class="hljs-keyword">new</span> NumberChangedEventHandler(sub.OnNumberChanged);
        pub.DoSomething();          <span class="hljs-comment">// 通过Pub DoSomething()来触发事件</span>
        <span class="hljs-comment">//pub.NumberChanged(100);   // 委托变量可以被这样直接(不恰当地)调用，但事件不行</span>
    }
}


}“`

(3) 自定义事件的参数与返回值

(a) 事件的参数

微乳推荐的事件模式带有两个参数object和EventArgs，其中object参数表示一个队发送事件的对象的引用，EventArgs则表示与该事件相关的信息，它可以是表示不发送任何信息的基类EventArgs，也可以是派生自EventArgs的类的实例。

> To declare an event inside a class, first a delegate type for the event must be declared, if none is already declared.
public delegate void ChangedEventHandler(object sender, EventArgs e);
The delegate type defines the set of arguments that are passed to the method that handles the event.

所以，接下来我们按照规范的方式改写上面的程序，为了增加其他类型的参数，我们还会在发布者中传递一些字符串类型的message给订阅者。

namespace PubSub
{
public delegate void NumberChangedEventHandler(object sender, ChangedEventArgs e); //定义委托

public class ChangedEventArgs : EventArgs
{
    public readonly int count;
    public readonly string msg;
    public ChangedEventArgs(int cnt, string str)
    {
        count = cnt;
        msg = str;
    }
}

public class Publishser
{
    private int count;
    public event NumberChangedEventHandler NumberChanged; // 声明一个事件

    public void DoSomething()
    {
        // todo: do something
        if (++count > 0)
        {
            if (NumberChanged != null)
            {
                NumberChanged(this, new ChangedEventArgs(count, "Something happened"));
            }
        }
    }
}

public class Subscriber
{
    public void OnNumberChanged(object sender, ChangedEventArgs e)
    {
        Console.WriteLine("Subscriber notified from [{0}]: \ncount = [{1}], msg = [{2}]", sender, e.count, e.msg);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Publishser pub = new Publishser();
        Subscriber sub = new Subscriber();

        pub.NumberChanged += new NumberChangedEventHandler(sub.OnNumberChanged);
        pub.DoSomething();
    }
}

}“`
输出结果：

Subscriber notified from [PubSub.Publishser]:
count = [1], msg = [Something happened]

(b) 事件的返回值

一般情况下，最好让事件的返回值为空。因为
首先，事件上可以绑定多个方法，这些方法是依次执行的，如果每个方法都有返回值，则需要发布者显示地依次执行每个方法，并处理相应的返回值。否则的话只有最后一个方法的返回值能被发布者获得。
其次，发布者与订阅者之间是松耦合的，发布者并不关心有谁订阅它的事件，更不会关心订阅者返回的东西。

(4) 事件的异常处理

还是上面的例子，我们再给发布者多加两个订阅者，并让其中一个订阅者的方法抛出异常。我们可以回顾一下，订阅者的方法被绑定到事件后，发布者一旦满足某种条件后触发该事件。而触发该事件时发布者要做的事情就是依次执行该事件上绑定的方法，即执行NumberChanged(this, EventArgs.Empty);这句话。所以我们尝试对这句话进行结构化异常处理。

namespace PubSub
{
    public delegate void NumberChangedEventHandler(object sender, EventArgs e); //定义委托

    public class Publishser
    {
        private int count;
        public event NumberChangedEventHandler NumberChanged; // 声明一个事件

        public void DoSomething()
        {
            // todo: do something
            if (++count > 0)
            {
                if (NumberChanged != null)
                {
                    try
                    {
                        NumberChanged(this, EventArgs.Empty);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("Exception: {0}", e.Message);
                    }
                }
            }
        }
    }

    public class Subscriber1
    {
        public void OnNumberChanged(object sender, EventArgs e)
        {
            Console.WriteLine("Subscriber1 invoked");
        }
    }

    public class Subscriber2
    {
        public void OnNumberChanged(object sender, EventArgs e)
        {
            throw new Exception("Subscriber2 threw exception");
        }
    }

    public class Subscriber3
    {
        public void OnNumberChanged(object sender, EventArgs e)
        {
            Console.WriteLine("Subscriber3 invoked");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var pub = new Publishser();
            var sub1 = new Subscriber1();
            var sub2 = new Subscriber2();
            var sub3 = new Subscriber3();

            pub.NumberChanged += new NumberChangedEventHandler(sub1.OnNumberChanged);
            pub.NumberChanged += new NumberChangedEventHandler(sub2.OnNumberChanged);
            pub.NumberChanged += new NumberChangedEventHandler(sub3.OnNumberChanged);
            pub.DoSomething();
        }
    }
}```
输出结果：

Subscriber1 invoked
Exception: Subscriber2 threw exception

结果显示，第2个订阅者抛出异常后发布者确实捕捉到了该异常，但是遗憾的是第3个订阅者的方法并没有被执行。也就是说事件上绑定的方法一旦出现了异常就终止了整个事件的处理，这样就影响到了后面的订阅者。所以对于这种情况，我们需要先获得事件上的委托链表，然后再在遍历链表的循环中处理异常。修改上面的`DoSomething()`方法如下：

public void DoSomething()
{
// todo: do something
if (++count > 0)
{
if (NumberChanged != null)
{
Delegate[] delArray = NumberChanged.GetInvocationList();
foreach (Delegate del in delArray)
{
NumberChangedEventHandler method = (NumberChangedEventHandler)del; // 强制转换为具体的委托类型
try
{
method(this, EventArgs.Empty);
}
catch (Exception e)
{
Console.WriteLine(“Exception: {0}”, e.Message);
}
}
}
}
}“`
输出结果：

Subscriber1 invoked
Exception: Subscriber2 threw exception
Subscriber3 invoked

(5) 泛型EventHandler<T>委托

既然有了上面提到的第一个参数为object，第二个参数为EventArgs派生类型的规范来书写自定义委托，我们肯定大多时候都是定义类似这样的委托。所以C#中还提供了EventHandler<T>泛型类型来简化我们得自定义过程。我们直接将它应用到上面的例子(3)(a)中即可得到：

namespace PubSub
{
    //public delegate void NumberChangedEventHandler(object sender, ChangedEventArgs e); //不再需要定义委托

    public class ChangedEventArgs : EventArgs
    {
        public readonly int count;
        public readonly string msg;
        public ChangedEventArgs(int cnt, string str)
        {
            count = cnt;
            msg = str;
        }
    }

    public class Publishser
    {
        private int count;
        public event EventHandler<ChangedEventArgs> NumberChanged; // 利用EventHanler泛型声明一个事件

        public void DoSomething()
        {
            // todo: do something
            if (++count > 0)
            {
                if (NumberChanged != null)
                {
                    NumberChanged(this, new ChangedEventArgs(count, "Something happened"));
                }
            }
        }
    }

    public class Subscriber
    {
        public void OnNumberChanged(object sender, ChangedEventArgs e)
        {
            Console.WriteLine("Subscriber notified from [{0}]: \ncount = [{1}], msg = [{2}]", sender, e.count, e.msg);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Publishser pub = new Publishser();
            Subscriber sub = new Subscriber();

            pub.NumberChanged += new EventHandler<ChangedEventArgs>(sub.OnNumberChanged);
            pub.DoSomething();
        }
    }
}```

8. 委托与事件的编码规范

终于把委托与事件学习完了，但是整篇文章中的代码并不规范，尤其是前面部分。因此，最后我们再来简单谈谈.Net Framework的编码规范，以免我的code误导了大家。
(1) 委托类型的名称应以EventHandler结束，如果没有什么特征要求，则可以直接使用泛型委托定义EventHandler<T>。
(2) 委托的原型定义：有一个<span class="hljs-keyword">void</span>返回值，并接受两个输入参数：一个是object 类型，一个是EventArgs类或其派生类。
(3) 继承自EventArgs的类型应该以EventArgs结尾。
(4) 事件的命名为: 委托定义名去掉EventHandler之后剩余的部分。
(5) 订阅事件的方法的命名通常为: On事件名。

写在最后，如果您从头到尾看到了这里，那真的是非常感谢您的信任与支持。有任何疑问或者不妥之处，欢迎指正！再次感谢！

参考文献：
《精通C#》
[C# 中的委托和事件](http://www.cnblogs.com/JimmyZhang/archive/2007/09/23/903360.html)
[C# 中的委托和事件（续）](http://www.cnblogs.com/JimmyZhang/archive/2008/08/22/1274342.html)
[Events Tutorial](https://msdn.microsoft.com/en-us/library/aa645739(v=vs.71).aspx)