C#图解教程 第十四章 事件

事件

发布者和订阅者


很多程序都有一个共同的需求,既当一个特定的程序事件发生时,程序的其他部分可以得到该事件已经发生的通知。
发布者/订阅者模式(publisher/subscriber pattern)可以满足这种需求。


  • 发布者(publisher) 发布某个事件的类或结构,其他类可以在该事件发生时得到通知
  • 订阅者(subscriber) 注册并在事件发生时得到通知的类或结构
  • 事件处理程序(event handler) 由订阅者注册到事件的方法,在发布者触发事件时执行。事件处理程序可定义在事件所在的类或结构中,也可定义在不同的类或结构中
  • 触发(raise)事件 调用(invoke)或触发(fire)事件的术语。当事件触发时,所有注册到它的方法都会被依次调用

前一章介绍了委托。事件的很多部分都与委托类似。实际上,事件就像专门用于特殊用途的简单委托。事件包含了一个私有的委托。

有关事件的私有委托需要了解的重要事项如下:

  • 事件提供了对它的私有控制委托的结构化访问。即,你无法直接访问委托
  • 事件中可用的操作比委托少,对于事件我们只可添加、删除或调用事件处理程序
  • 事件被触发时,它调用委托来依次调用调用列表中的方法

源代码组件概览


需要在事件中使用的代码有5部分。

  • 委托类型声明 事件和事件处理程序必须有共同的签名和返回类型,它们通过委托类型进行描述
  • 事件处理程序声明 订阅者类中会在事件触发时执行的方法声明。它们不一定是有显式命名的方法,还可以是第13章描述的匿名方法或Lambda表达式
  • 事件声明 发布者类必须声明一个订阅者类可以注册的事件成员。当声明的事件为public时,称为发布了事件
  • 事件注册 订阅者必须订阅事件才能在它被触发时得到通知
  • 触发事件的代码 发布者类中“触发”事件并导致调用注册的所有事件处理程序的代码

 

声明事件


发布者类必须提供事件对象。创建事件比较简单–只需要委托类型和名字。事件声明的语法如下代码所示。
代码中声明了CountADozen事件。

  • 事件声明在一个类中
  • 它需要委托类型的名称,任何附加到事件(如注册)的处理程序都必须与委托类型的签名和返回类型匹配
  • 它声明为public,这样其他类和结构可以在它上面注册事件处理程序
  • 不能使用对象创建表达式(new 表达式)来创建对象
class Incrementer
{
           关键字   委托类型      事件名
             ↓        ↓           ↓
    public event EventHandler CountedADozen;
    ...
}

可以通过使用逗号分隔同时声明多个事件。

public event EventHandler MyEvent1,MyEvent2,OtherEvent;

还可以使用static关键字让事件变成静态

public static event EventHandler CountedADozen;

事件是成员
一个常见误解是把事件认为是类型。和方法、属性一样,事件是类或结构的成员,这一点引出几个重要特性。

  • 由于事件是成员:
    • 我们不能在一段可执行代码中声明事件
    • 它必须声明在类或结构中
  • 事件成员被隐式自动初始化为null

事件声明需要委托类型的名字,我们可以声明一个委托类型或使用已存在的。如果我们声明一个委托类型,它必须指定事件保存的方法的签名和返回类型。
BCL(Base Class Library,基类库)声明了一个叫做EventHandler的委托,专门用于系统事件。

订阅事件


  • 使用+=运算符来为事件增加事件处理程序
  • 事件处理程序的规范可以是以下任意一种
    • 实例方法的名称
    • 静态方法的名称
    • 匿名方法
    • Lambda表达式

例:为CountedADozen事件增加3个方法。

incrementer.CountedADozen+=IncrementDozensCount;//实例方法
incrementer.CountedADozen+=ClassB.CounterHandlerB;//静态方法
mc.CountedADozen+=new EventHandler(cc.CounterHandlerC);//委托形式

例:Lambda表达式和匿名方法

incrementer.CountedADozen+=()=>DozensCount++;//Lambda表达式
incrementer.CountedADozen+=delegate{DozensCount++;};//匿名方法

触发事件


事件成员本身只保存了需要被调用的事件处理程序。如果事件没触发,什么都不会发生。我们需要确保在合适的时候有代码来做这件事情。
例:下面代码触发了CountedADozen事件。

  • 在触发事件前和null比较,从而查看是否包含事件处理程序,如果事件是null,则表示没有,不能执行
  • 触发事件的语法和调用方法一样
    • 使用事件名称,后面跟参数列表
    • 参数列表需与事件委托类型相匹配
if(CountedADozen!=null)
{
    CountedADozen(source,args);
}

把事件声明和触发事件的代码放在一起便有了如下的发布者类声明。
下面展示了整个程序,代码需要注意的地方如下:

  • 在构造函数中,Dozens类订阅事件,将IncrementDozensCount作为事件处理程序
  • 在Incrementer类的DoCount方法中,每增长12个数就触发CountedADozen事件
delegate void Handler();    //声明委托
//发布者
class Incrementer
{
    public event Handler CountedADozen;//创建事件并发布
    void DoCount(object source,EventArgs args)
    {
        for(int i=1;i<100;i++)
        {
            if((i%12==0)&&(CountedADozen!=null))
            {
                CountedADozen(source,args);
            }
        }
    }
}
//订阅者
class Dozens
{
    public int DozensCount{get;private set;}
    public Dozens(Incrementer incrementer)
    {
        DozensCount=0;
        incrementer.CountedADozen+=IncrementDozensCount;//订阅事件
    }
    void IncrementDozensCount()//声明事件处理程序
    {
        DozensCount++;
    }
}
class Program
{
    static void Main()
    {
        var incrementer=new Incrementer();
        var dozensCounter=new Dozens(incrementer);
        incrementer.DoCount();
        Console.WriteLine("Number of dozens = {0}",dozensCounter.DozensCount);
    }
}

标准事件的用法


GUI编程是事件驱动的,即程序运行时,它可以在任何时候被事件打断,比如鼠标点击,按下按键或系统定时器。在这些情况发生时,程序需要处理事件然后继续其他事情。
程序事件的异步处理是使用C#事件的绝佳场景。Windows GUI编程广泛的使用事件,对于事件的使用,.NET框架提供了一个标准模式。事件使用的标准模式根本就是System命名空间声明的EventHandler委托类型。EventHandler委托类型的声明代码如下。

  • 第一个参数用来保存触发事件的对象的引用。由于是object类型,所以可以匹配任何类型的实例
  • 第二个参数用来保存状态信息,指明什么类型适用于该程序
  • 返回类型是void
public delegate void EventHandler(object sender,EventArgs e);

EventHandler委托类型的第二个参数是EventArgs类的UI项,它声明在System命名空间中。既然第二个参数用于传递数据,你可能会误认为EventArgs类的对象应该可以保存一些类型的数据。

  • EventArgs设计为不能传递任何数据。它用于不需要传递数据的事件处理程序–通常会被忽略
  • 如果你希望传递数据,必须声明一个派生自EventArgs的类,使用合适的字段来保存需要传递的数据

例:Incrementer+EventHandler

  • 在声明中使用系统定义的EventHandler委托替换Handler
  • 订阅者中声明的事件处理程序签名必须与事件委托(object、EventArgs参数)的签名(和返回类型)匹配。对于IncrementDozensCount事件处理程序来说,该方法忽略了正式参数
  • 触发事件的代码在调用事件时必须使用适当的参数类型的对象
public delegate void EventHandler(object sender,EventArgs e);
//发布者
class Incrementer
{
    public event EventHandler CountedADozen;//创建事件并发布
    public void DoCount()
    {
        for(int i=1;i<100;i++)
        {
            if((i%12==0)&&(CountedADozen!=null))
            {
                CountedADozen(this,null);
            }
        }
    }
}
//订阅者
class Dozens
{
    public int DozensCount{get;private set;}
    public Dozens(Incrementer incrementer)
    {
        DozensCount=0;
        incrementer.CountedADozen+=IncrementDozensCount;//订阅事件
    }
    void IncrementDozensCount(object source,EventArgs e)//声明事件处理程序
    {
        DozensCount++;
    }
}
class Program
{
    static void Main()
    {
        var incrementer=new Incrementer();
        var dozensCounter=new Dozens(incrementer);
        incrementer.DoCount();
        Console.WriteLine("Number of dozens = {0}",dozensCounter.DozensCount);
    }
}
通过扩展EventArgs来传递数据

为了向EventArgs传入数据,并且符合标准惯例,我们需要声明一个派生自EventArgs的自定义类,用于保存需要传入的数据。类的名称应该以EventArgs结尾。
例:声明自定义的EventArgs类,它将字符串存储在IterationCount字段中。

public class IncrementerEventArgs:EventArgs
{
    public int IterationCount{get;set;}
}

除了自定义类外,你还需要一个使用自定义类的委托类型。要获取该类,可以使用泛型(第17章)版本的委托EventHandler<>。要使用泛型委托,需要做到以下两点:

  • 将自定义类的名称放在尖括号内
  • 在需要使用自定义委托类型的时候使用整个字符串。

例:使用了自定义类和自定义委托的事件示例

public class IncrementerEventArgs:EventArgs
{
    public int IterationCount{get;set;}
}
//发布者
class Incrementer
{
                       使用自定义类的泛型委托
                                ↓
    public event EventHandler<IncrementerEventArgs> CountedADozen;//创建事件并发布
    public void DoCount()
    {
        IncrementerEventArgs args=new IncrementerEventArgs();
        for(int i=1;i<100;i++)
        {
            if((i%12==0)&&(CountedADozen!=null))
            {
                args.IterationCount=i;
                CountedADozen(this,args);
            }
        }
    }
}
//订阅者
class Dozens
{
    public int DozensCount{get;private set;}
    public Dozens(Incrementer incrementer)
    {
        DozensCount=0;
        incrementer.CountedADozen+=IncrementDozensCount;//订阅事件
    }
    void IncrementDozensCount(object source,IncrementerEventArgs e)//声明事件处理程序
    {
        Console.WriteLine("Incremented at iteration: {0} in {1}",e.IterationCount,source.ToString());
        DozensCount++;
    }
}
class Program
{
    static void Main()
    {
        var incrementer=new Incrementer();
        var dozensCounter=new Dozens(incrementer);
        incrementer.DoCount();
        Console.WriteLine("Number of dozens = {0}",dozensCounter.DozensCount);
    }
}

移除事件处理程序

用完事件处理程序后,可以使用-=运算符把事件处理程序从事件中移除。

例:移除事件处理程序示例

class Publisher
{
    public event EventHandler SimpleEvent;
    public void RaiseTheEvent(){SimpleEvent(this,null);}
}
class Subscriber
{
    public void MethodA(object o,EventArgs e)
    {
        Console.WriteLine("AAA");
    }
    public void MethodB(object o,EventArgs e)
    {
        Console.WriteLine("BBB");
    }
}
class Program
{
    static void Main()
    {
        var p=new Publisher();
        var s=new Subscriber();
        p.SimpleEvent+=s.MethodA;
        p.SimpleEvent+=s.MethodB;
        p.RaiseTheEvent();
        Console.WriteLine("\r\nRemove MethodB");
        p.SimpleEvent-=s.MethodB;
        p.RaiseTheEvent();
    }
}

如果一个处理程序向事件注册了多次,那么移除程序时,将只移除列表中该处理程序的最后一个实例。

事件访问器


之前我提到+=和-=运算符是事件允许的唯一运算符。看到这里我们应该知道,这些运算符有预定义行为。
我们可以修改这些运算符的行为,并且使用它们时可以让事件执行任何我们希望的自定义代码。但这是高级主题,此处只做简单介绍。
要改变这两个运算符的操作,可以为事件定义事件访问器。

  • 有两个访问器:add和remove
  • 声明事件的访问器看上去和声明一个属性差不多

例:具有访问器的事件声明。两个访问器都有隐式值参数value,它接受实例或静态方法的引用。

public event EventHandler CountedADozen
{
    add
    {
        ...    //执行+=运算符的代码
    }
    remove
    {
        ...    //执行-=运算符的代码
    }
}

声明事件访问器后,事件不包含任何内嵌委托对象。我们必须实现自己的机制来存储和移除事件注册方法。
事件访问器表现为void方法,即没有返回值。

posted @ 2017-01-22 14:31  只追昭熙  阅读(2704)  评论(0编辑  收藏  举报