结合.net框架在C#派生类中触发基类事件及实现接口事件

在派生类中引发基类事件
以下简单示例演示了在基类中声明可从派生类引发的事件的标准方法。此模式广泛应用于 .NET Framework 类库中的 Windows 窗体类。
在创建可用作其他类的基类的类时,应考虑如下事实:事件是特殊类型的委托,只可以从声明它们的类中调用。派生类无法直接调用基类中声明的事件。尽管有时需要事件仅由基类引发,但在大多数情形下,应该允许派生类调用基类事件。为此,您可以在包含该事件的基类中创建一个受保护的调用方法。通过调用或重写此调用方法,派生类便可以间接调用该事件。
注意:不要在基类中声明虚拟事件,也不要在派生类中重写这些事件。C# 编译器无法正确处理这些事件,并且无法预知的该派生的事件的用户是否真正订阅了基类事件。

namespace BaseClassEvents
{
  using System;
  using System.Collections.Generic;

  // Special EventArgs class to hold info about Shapes.
  public class ShapeEventArgs : EventArgs
  {
    private double newArea;

    public ShapeEventArgs(double d)
    {
      newArea = d;
    }
    public double NewArea
    {
      get { return newArea; }
    }
  }

  // Base class event publisher
  public abstract class Shape
  {
    protected double area;

    public double Area
    {
      get { return area; }
      set { area = value; }
    }
    // The event. Note that by using the generic EventHandler<T> event type
    // we do not need to declare a separate delegate type.
    public event EventHandler<ShapeEventArgs> ShapeChanged;

    public abstract void Draw();

    //The event-invoking method that derived classes can override.
    protected virtual void OnShapeChanged(ShapeEventArgs e)
    {
      // Make a temporary copy of the event to avoid possibility of
      // a race condition if the last subscriber unsubscribes
      // immediately after the null check and before the event is raised.
      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 * radius;
    }
    public void Update(double d)
    {
      radius = d;
      area = 3.14 * radius * radius;
      OnShapeChanged(new ShapeEventArgs(area));
    }
    protected override void OnShapeChanged(ShapeEventArgs e)
    {
      // Do any circle-specific processing here.

      // Call the base class event invocation method.
      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)
    {
      // Do any rectangle-specific processing here.

      // Call the base class event invocation method.
      base.OnShapeChanged(e);
    }
    public override void Draw()
    {
      Console.WriteLine("Drawing a rectangle");
    }

  }

  // Represents the surface on which the shapes are drawn
  // Subscribes to shape events so that it knows
  // when to redraw a shape.
  public class ShapeContainer
  {
    List<Shape> _list;

    public ShapeContainer()
    {
      _list = new List<Shape>();
    }

    public void AddShape(Shape s)
    {
      _list.Add(s);
      // Subscribe to the base class event.
      s.ShapeChanged += HandleShapeChanged;
    }

    // ...Other methods to draw, resize, etc.

    private void HandleShapeChanged(object sender, ShapeEventArgs e)
    {
      Shape s = (Shape)sender;

      // Diagnostic message for demonstration purposes.
      Console.WriteLine("Received event. Shape area is now {0}", e.NewArea);

      // Redraw the shape here.
      s.Draw();
    }
  }

  class Test
  {

    static void Main(string[] args)
    {
      //Create the event publishers and subscriber
      Circle c1 = new Circle(54);
      Rectangle r1 = new Rectangle(12, 9);
      ShapeContainer sc = new ShapeContainer();

      // Add the shapes to the container.
      sc.AddShape(c1);
      sc.AddShape(r1);

      // Cause some events to be raised.
      c1.Update(57);
      r1.Update(7, 7);

      // Keep the console window open in debug mode.
      System.Console.WriteLine("Press any key to exit.");
      System.Console.ReadKey();
    }
  }
}

输出:

    Received event. Shape area is now 10201.86
    Drawing a circle
    Received event. Shape area is now 49
    Drawing a rectangle

实现接口事件

接口可声明事件。下面的示例演示如何在类中实现接口事件。实现接口事件的规则与实现任何接口方法或属性的规则基本相同。
在类中实现接口事件
在类中声明事件,然后在适当的区域调用该事件。

namespace ImplementInterfaceEvents
{
  public interface IDrawingObject
  {
    event EventHandler ShapeChanged;
  }
  public class MyEventArgs : EventArgs
  {
    // class members
  }
  public class Shape : IDrawingObject
  {
    public event EventHandler ShapeChanged;
    void ChangeShape()
    {
      // Do something here before the event…

      OnShapeChanged(new MyEventArgs(/*arguments*/));

      // or do something here 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
  {
    // Raise this event before drawing
    // the object.
    event EventHandler OnDraw;
  }
  public interface IShape
  {
    // Raise this event after drawing
    // the shape.
    event EventHandler OnDraw;
  }

  // Base class event publisher inherits two
  // interfaces, each with an OnDraw event
  public class Shape : IDrawingObject, IShape
  {
    // Create an event for each interface event
    event EventHandler PreDrawEvent;
    event EventHandler PostDrawEvent;

    object objectLock = new Object();

    // Explicit interface implementation required.
    // Associate IDrawingObject's event with
    // PreDrawEvent
    event EventHandler IDrawingObject.OnDraw
    {
      add
      {
        lock (objectLock)
        {
          PreDrawEvent += value;
        }
      }
      remove
      {
        lock (objectLock)
        {
          PreDrawEvent -= value;
        }
      }
    }
    // Explicit interface implementation required.
    // Associate IShape's event with
    // PostDrawEvent
    event EventHandler IShape.OnDraw
    {
      add
      {
        lock (objectLock)
        {
          PostDrawEvent += value;
        }
      }
      remove
      {
        lock (objectLock)
        {
          PostDrawEvent -= value;
        }
      }

    }

    // For the sake of simplicity this one method
    // implements both interfaces.
    public void Draw()
    {
      // Raise IDrawingObject's event before the object is drawn.
      EventHandler handler = PreDrawEvent;
      if (handler != null)
      {
        handler(this, new EventArgs());
      }
      Console.WriteLine("Drawing a shape.");

      // RaiseIShape's event after the object is drawn.
      handler = PostDrawEvent;
      if (handler != null)
      {
        handler(this, new EventArgs());
      }
    }
  }
  public class Subscriber1
  {
    // References the shape object as an IDrawingObject
    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.");
    }
  }
  // References the shape object as an IShape
  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();

      // Keep the console window open in debug mode.
      System.Console.WriteLine("Press any key to exit.");
      System.Console.ReadKey();
    }
  }

}

输出:

  Sub1 receives the IDrawingObject event.
  Drawing a shape.
  Sub2 receives the IShape event.
(0)

相关推荐

  • 结合Visual C#开发环境讲解C#中事件的订阅和取消订阅

    类或对象可以通过事件向其他类或对象通知发生的相关事情.发送(或引发)事件的类称为"发行者",接收(或处理)事件的类称为"订户". 在典型的 C# Windows 窗体或 Web 应用程序中,可订阅由控件(如按钮和列表框)引发的事件.可使用 Visual C# 集成开发环境 (IDE) 来浏览控件发布的事件,选择要处理的事件.IDE 会自动添加空事件处理程序方法和订阅事件的代码. 事件概述 事件具有以下特点: 发行者确定何时引发事件,订户确定执行何种操作来响应该事件.

  • C#事件用法实例浅析

    本文实例讲述了C#事件用法.分享给大家供大家参考.具体分析如下: EventHandler<TEventArgs>的定义如下 public delegate void EventHandler<TEventArgs>(object sender,TEventArgs e) where TEventArgs:EventArgs 第一个参数必须是object类型(是一个对象,包含事件的发送者) 第二个参数是T类型(即泛型),定义了一个T的约束,它必须派生自基类EventArgs Car

  • 在C#使用字典存储事件示例及实现自定义事件访问器

    使用字典存储事件实例 accessor-declarations 的一种用法是公开很多事件但不为每个事件分配字段,而是使用字典来存储这些事件实例.这只在具有很多事件但您预计大多数事件都不会实现时才有用. public delegate void EventHandler1(int i); public delegate void EventHandler2(string s); public class PropertyEventsSample { private System.Collecti

  • 理解C#中的事件

    前面文章中介绍了委托相关的概念,委托实例保存这一个或一组操作,程序中将在某个特定的时刻通过委托实例使用这些操作. 如果做过GUI程序开发,可能对上面的描述会比较熟悉.在GUI程序中,单击一个button会触发一个click事件,然后会执行一系列的操作,这一系列的操作就被存放在一个委托实例中. 接下来我们就看看事件. 使用委托中的问题 回到前面文章中苹果和富士康的例子,苹果将iphone的组装.包装和运输的工作全部委托给了富士康. 根据上面的描述,我们修改了一下代码,在Apple这个类中加入一个订

  • C#获取USB事件API实例分析

    本文实例讲述了C#获取USB事件API.分享给大家供大家参考.具体如下: const int WM_DEVICECHANGE = 0x2190; const int DBT_DEVICEARRIVAL = 0x8000; const int DBT_DEVICEREMOVECOMPLETE = 0x8004; protected override void WndProc(ref Message m) { try { //if (m.Msg == WM_DEVICECHANGE) //{ swi

  • C#委托与事件初探

    委托给了C#操作函数的灵活性,我们可使用委托像操作变量一样来操作函数,其实这个功能并不是C#的首创,早在C++时代就有函数指针这一说法,而在我看来委托就是C#的函数指针,首先先简要的介绍一下委托的基本知识: 委托的定义 委托的声明原型是 delegate <函数返回类型> <委托名> (<函数参数>) 例子:public delegate void CheckDelegate(int number);//定义了一个委托CheckDelegate,它可以注册返回void类

  • C#通过委托调用Button单击事件的方法

    这里介绍通过委托取消Button事件switch-case的方法.需要注意的是,事先要按顺序在各个Button的Tag属性中设置0.1.2.3--等序号,其作用请详看代码. /*定义委托*/ public delegate 类型或viod MethodDelegate(参数1, 参数2); private void buttonC_Click(object sender, EventArgs e) { Button button = (Button)sender; /*向委托添加方法*/ Met

  • C#自定义事件及用法实例

    本文实例讲述了C#自定义事件及用法.分享给大家供大家参考.具体分析如下: 事件是C#中一个重要的内容,MSDN上有一个自定义事件的演示示例.我看了半天有点晕,所以新建了一个winform工程添加了一个按钮,然后找出调用的程序,一对比做了一个类似的示例,就明白了.看代码有时候比看文档来得更快. 所以还是一贯的原则,来干的,不来稀的. using System; namespace TestEventArgs { /// <summary> /// 这个类对应于EventArgs,做对比学习. /

  • C#动态生成按钮及定义按钮事件的方法

    本文实例讲述了C#动态生成按钮及定义按钮事件的方法.分享给大家供大家参考.具体实现方法如下: 1.后台生成input的button按钮 复制代码 代码如下: HtmlGenericControl control = new HtmlGenericControl("input"); control.Attributes.Add("type", "button"); control.Attributes.Add("onclick"

  • C#移除所有事件绑定的方法

    本文实例讲述了C#移除所有事件绑定的方法.分享给大家供大家参考.具体分析如下: private delegate int DEL_TEST_EventHandler(int m, int n); private event DEL_TEST_EventHandler DelTestEventHandler; /// <summary> /// 移除所有的事件绑定 /// </summary> /// <param name="clearEvent">

  • 详解C#编程中.NET的弱事件模式

    引言 你可能知道,事件处理是内存泄漏的一个常见来源,它由不再使用的对象存留产生,你也许认为它们应该已经被回收了,但不是,并有充分的理由. 在这个短文中(期望如此),我会在 .Net 框架的上下文事件处理中展示这个问题,之后我会教你这个问题的标准解决方案,弱事件模式.有两种方法,即: "传统"方法 (嗯,在 .Net 4.5 前,所以也没那么老),它实现起来比较繁琐 .Net 4.5 框架提供的新方法,它则是尽其可能的简单 (源代码在 这里 可供使用.) 从常见事物开始 在一头扎进本文核

  • C#中事件的定义和使用

    事件的声明和使用与代理有很密切的关系,事件其实是一个或多个方法的代理,当对象的某个状态发生了变化,代理会被自动调用,从而代理的方法就被自动执行. 声明和使用一个事件需要如下步骤: 1.创建一个代理. 2.在类的内部利用event关键字声明事件,并且在类中定义调用事件的方法,也可以定义一个处理事件消息的方法. 声明一个事件的基本形式有两种: 修饰符  event   类型   标识符 修饰符  event   类型   标识符{get{};set{};} 其中: 修饰符是指C#语言的访问修饰符:类

  • C#自定义事件监听实现方法

    本文实例讲述了C#自定义事件监听实现方法.分享给大家供大家参考.具体实现方法如下: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApp { /// <summary> /// 定义事件 /// </summary> class CustomEvent { /// <summary> /// 定义委托 /// &

随机推荐