.Net事件

.NET 事件

事件概述

在发生其他类或对象关注的事情时，类或对象可通过事件通知它们。发送（或引发）事件的类称为“发行者”，接收（或处理）事件的类称为“订户”。

事件的订阅和取消

publisher.RaiseCustomEvent += HandleCustomEvent; 
publisher.RaiseCustomEvent += new CustomEventHandler(HandleCustomEvent); 

• 匿名方法订阅事件
  
  • 使用加法赋值运算符 (+=) 来为事件附加匿名方法。在下面的示例中，假设名为 publisher 的对象拥有一个名为 RaiseCustomEvent 的事件，并且还定义了一个 CustomEventArgs 类以承载某些类型的专用事件信息。请注意，订户类需要引用 publisher 才能订阅其事件。

publisher.RaiseCustomEvent += delegate(object o, CustomEventArgs e) 
{ 
    string s = o.ToString() + " " + e.ToString(); 
    Console.WriteLine(s); 
}; 

publisher.RaiseCustomEvent -= HandleCustomEvent; 

发布标准事件

下面的过程演示了如何将符合标准 .NET Framework 模式的事件添加到您自己的类和结构中。.NET Framework 类库中的所有事件均基于 EventHandler 委托，定义如下。

public delegate void EventHandler(object sender, EventArgs e); 

• 采用 EventHandler 模式发布事件
  
  • （如果不需要发送含事件的自定义数据，请跳过此步骤，直接进入步骤 3。）在发行者类和订户类均可看见的范围中声明类，并添加保留自定义事件数据所需的成员。在此示例中，会返回一个简单字符串。
  •  

  public class CustomEventArgs : EventArgs 
  { 
      public CustomEventArgs(string s) 
      { 
          msg = s; 
      } 
      private string msg; 
      public string Message 
      { 
          get { return msg; } 
      }  
  } 

  • （如果您使用的是 EventHandler 的泛型版本，请跳过此步骤。）在发布类中声明一个委托。为它指定以 EventHandler 结尾的名称。第二个参数指定自定义 EventArgs 类型。
  •  

  public delegate void CustomEventHandler(object sender, CustomEventArgs a); 

  • 使用以下任一步骤，在发布类中声明事件。
    
    • 如果没有自定义 EventArgs 类，事件类型就是非泛型 EventHandler 委托。它无需声明，因为它已在 C# 项目默认包含的 System 命名空间中进行了声明
    •  

    public event EventHandler RaiseCustomEvent; 

    • 如果使用的是 EventHandler 的非泛型版本，并且您有一个由 EventArgs 派生的自定义类，请在发布类中声明您的事件，并且将您的委托用作类型
    •  

    class Publisher 
    { 
        public event CustomEventHandler RaiseCustomEvent; 
    } 

    • 如果使用的是泛型版本，则不需要自定义委托。相反，应将事件类型指定为 EventHandler<CustomEventArgs>，在尖括号内放置您自己的类的名称。

    public event EventHandler<CustomEventArgs> RaiseCustomEvent; 

#p#

引发派生类中的基类事件

 以下简单示例演示了在基类中声明可从派生类引发的事件的标准方法。此模式广泛应用于 .NET Framework 基类库中的 Windows 窗体类。

在创建可用作其他类的基类的类时，必须考虑如下事实：事件是特殊类型的委托，只可以从声明它们的类中调用。派生类无法直接调用基类中声明的事件。尽管有时您可能希望某个事件只能通过基类引发，但在大多数情形下，您应该允许派生类调用基类事件。为此，您可以在包含该事件的基类中创建一个受保护的调用方法。通过调用或重写此调用方法，派生类便可以间接调用该事件。

namespace BaseClassEvents 
{ 
    using System; 
    using System.Collections.Generic; 
    public class ShapeEventArgs : EventArgs 
    { 
        private double newArea; 
 
        public ShapeEventArgs(double d) 
        { 
            newArea = d; 
        } 
        public double NewArea 
        { 
            get { return newArea; } 
        } 
    } 
    public abstract class Shape 
    { 
        protected double area; 
 
        public double Area 
        { 
            get { return area; } 
            set { area = value; } 
        } 
        public event EventHandler<ShapeEventArgs> ShapeChanged; 
        public abstract void Draw(); 
        protected virtual void OnShapeChanged(ShapeEventArgs e) 
        { 
            EventHandler<ShapeEventArgs> handler = ShapeChanged; 
            if (handler != null) 
            { 
                handler(this, e); 
            } 
        } 
    } 
    public class Circle : Shape 
    { 
        private double radius; 
        public Circle(double d) 
        { 
            radius = d; 
            area = 3.14 * radius; 
        } 
        public void Update(double d) 
        { 
            radius = d; 
            area = 3.14 * radius; 
            OnShapeChanged(new ShapeEventArgs(area)); 
        } 
        protected override void OnShapeChanged(ShapeEventArgs e) 
        { 
            base.OnShapeChanged(e); 
        } 
        public override void Draw() 
        { 
            Console.WriteLine("Drawing a circle"); 
        } 
    } 
    public class Rectangle : Shape 
    { 
        private double length; 
        private double width; 
        public Rectangle(double length, double width) 
        { 
            this.length = length; 
            this.width = width; 
            area = length * width; 
        } 
        public void Update(double length, double width) 
        { 
            this.length = length; 
            this.width = width; 
            area = length * width; 
            OnShapeChanged(new ShapeEventArgs(area)); 
        } 
        protected override void OnShapeChanged(ShapeEventArgs e) 
        { 
            base.OnShapeChanged(e); 
        } 
        public override void Draw() 
        { 
            Console.WriteLine("Drawing a rectangle"); 
        } 
 
    } 
    public class ShapeContainer 
    { 
        List<Shape> _list; 
 
        public ShapeContainer() 
        { 
            _list = new List<Shape>(); 
        } 
 
        public void AddShape(Shape s) 
        { 
            _list.Add(s); 
            s.ShapeChanged += HandleShapeChanged; 
        } 
        private void HandleShapeChanged(object sender, ShapeEventArgs e) 
        { 
            Shape s = (Shape)sender; 
            Console.WriteLine("Received event. Shape area is now {0}", e.NewArea); 
            s.Draw(); 
        } 
    } 
    class Test 
    { 
 
        static void Main(string[] args) 
        { 
            Circle c1 = new Circle(54); 
            Rectangle r1 = new Rectangle(12, 9); 
            ShapeContainer sc = new ShapeContainer(); 
            sc.AddShape(c1); 
            sc.AddShape(r1); 
            c1.Update(57); 
            r1.Update(7, 7); 
            Console.WriteLine(); 
            Console.WriteLine("Press Enter to exit"); 
            Console.ReadLine(); 
        } 
    } 
} 

#p#

实现接口事件

接口可声明事件。下面的示例演示如何在类中实现接口事件。接口事件的实现规则与任何接口方法或属性的实现规则基本相同。

public interface IDrawingObject 
{ 
    event EventHandler ShapeChanged; 
} 
public class MyEventArgs : EventArgs {…} 
public class Shape : IDrawingObject 
{ 
    event EventHandler ShapeChanged; 
    void ChangeShape() 
    { 
        // Do something before the event… 
        OnShapeChanged(new MyEventsArgs(…)); 
        // or do something after the event.  
    } 
    protected virtual void OnShapeChanged(MyEventArgs e) 
    { 
        if(ShapeChanged != null) 
        { 
           ShapeChanged(this, e); 
        } 
    } 
} 

下面的示例演示如何处理以下的不常见情况：您的类是从两个以上的接口继承的，每个接口都含有同名事件）。在这种情况下，您至少要为其中一个事件提供显式接口实现。为事件编写显式接口实现时，必须编写 add 和 remove 事件访问器。这两个事件访问器通常由编译器提供，但在这种情况下编译器不能提供。

您可以提供自己的访问器，以便指定这两个事件是由您的类中的同一事件表示，还是由不同事件表示。例如，根据接口规范，如果事件应在不同时间引发，则可以将每个事件与类中的一个单独实现关联。在下面的示例中，订户将形状引用强制转换为 IShape 或 IDrawingObject，从而确定自己将会接收哪个 OnDraw 事件。

namespace WrapTwoInterfaceEvents 
{ 
    using System; 
    public interface IDrawingObject 
    { 
        event EventHandler OnDraw; 
    } 
    public interface IShape 
    { 
        event EventHandler OnDraw; 
    } 
    public class Shape : IDrawingObject, IShape 
    { 
        event EventHandler PreDrawEvent; 
        event EventHandler PostDrawEvent; 
        event EventHandler IDrawingObject.OnDraw 
        { 
            add { PreDrawEvent += value; } 
            remove { PreDrawEvent -= value; } 
        } 
        event EventHandler IShape.OnDraw 
        { 
            add { PostDrawEvent += value; } 
            remove { PostDrawEvent -= value; } 
        } 
        public void Draw() 
        { 
            EventHandler handler = PreDrawEvent; 
            if (handler != null) 
            { 
                handler(this, new EventArgs()); 
            } 
            Console.WriteLine("Drawing a shape."); 
            handler = PostDrawEvent; 
            if (handler != null) 
            { 
                handler(this, new EventArgs()); 
            } 
        } 
    } 
    public class Subscriber1 
    { 
        public Subscriber1(Shape shape) 
        { 
            IDrawingObject d = (IDrawingObject)shape; 
            d.OnDraw += new EventHandler(d_OnDraw); 
        } 
        void d_OnDraw(object sender, EventArgs e) 
        { 
            Console.WriteLine("Sub1 receives the IDrawingObject event."); 
        } 
    } 
    public class Subscriber2 
    { 
        public Subscriber2(Shape shape) 
        { 
            IShape d = (IShape)shape; 
            d.OnDraw += new EventHandler(d_OnDraw); 
        } 
 
        void d_OnDraw(object sender, EventArgs e) 
        { 
            Console.WriteLine("Sub2 receives the IShape event."); 
        } 
    } 
    public class Program 
    { 
        static void Main(string[] args) 
        { 
            Shape shape = new Shape(); 
            Subscriber1 sub = new Subscriber1(shape); 
            Subscriber2 sub2 = new Subscriber2(shape); 
            shape.Draw(); 
 
            Console.WriteLine("Press Enter to close this window."); 
            Console.ReadLine(); 
        } 
    } 
} 

使用字典存储事件实例

accessor-declarations 的一种用法是公开大量的事件但不为每个事件分配字段，而是使用字典来存储这些事件实例。这只有在具有非常多的事件、但您预计大部分事件都不会实现时才有用。

public delegate void EventHandler1(int i); 
public delegate void EventHandler2(string s); 
public class PropertyEventsSample 
{ 
    private System.Collections.Generic.Dictionary<string, System.Delegate> eventTable; 
    public PropertyEventsSample() 
    { 
        eventTable = new System.Collections.Generic.Dictionary<string, System.Delegate>(); 
        eventTable.Add("Event1", null); 
        eventTable.Add("Event2", null); 
    } 
    public event EventHandler1 Event1 
    { 
        add 
        { 
            eventTable["Event1"] = (EventHandler1)eventTable["Event1"] + value; 
        } 
        remove 
        { 
            eventTable["Event1"] = (EventHandler1)eventTable["Event1"] - value; 
        } 
    } 
    public event EventHandler2 Event2 
    { 
        add 
        { 
            eventTable["Event2"] = (EventHandler2)eventTable["Event2"] + value; 
        } 
        remove 
        { 
            eventTable["Event2"] = (EventHandler2)eventTable["Event2"] - value; 
        } 
    } 
    internal void RaiseEvent1(int i) 
    { 
        EventHandler1 handler1; 
        if (null != (handler1 = (EventHandler1)eventTable["Event1"])) 
        { 
            handler1(i); 
        } 
    } 
    internal void RaiseEvent2(string s) 
    { 
        EventHandler2 handler2; 
        if (null != (handler2 = (EventHandler2)eventTable["Event2"])) 
        { 
            handler2(s); 
        } 
    } 
} 
public class TestClass 
{ 
    public static void Delegate1Method(int i) 
    { 
        System.Console.WriteLine(i); 
    } 
    public static void Delegate2Method(string s) 
    { 
        System.Console.WriteLine(s); 
    } 
    static void Main() 
    { 
        PropertyEventsSample p = new PropertyEventsSample(); 
 
        p.Event1 += new EventHandler1(TestClass.Delegate1Method); 
        p.Event1 += new EventHandler1(TestClass.Delegate1Method); 
        p.Event1 -= new EventHandler1(TestClass.Delegate1Method); 
        p.RaiseEvent1(2); 
 
        p.Event2 += new EventHandler2(TestClass.Delegate2Method); 
        p.Event2 += new EventHandler2(TestClass.Delegate2Method); 
        p.Event2 -= new EventHandler2(TestClass.Delegate2Method); 
        p.RaiseEvent2("TestString"); 
    } 
} 

事件的异步模式

有多种方式可向客户端代码公开异步功能。基于事件的异步模式为类规定了用于显示异步行为的建议方式。对于相对简单的多线程应用程序，BackgroundWorker 组件提供了一个简单的解决方案。对于更复杂的异步应用程序，请考虑实现一个符合基于事件的异步模式的类。

原文链接：http://www.cnblogs.com/liusuqi/p/3145324.html