C#中在派生类触发基类事件及实现接口事件的方法

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

  // 自定义 EventArgs，携带形状面积变更数据
  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; }
    }

    // 1. 声明事件
    // 使用泛型 EventHandler<T>，无需单独声明委托类型
    public event EventHandler<ShapeEventArgs> ShapeChanged;

    public abstract void Draw();

    // 2. 提供受保护的虚方法用于派生类调用
    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 * radius; }

    public void Update(double d)
    {
      radius = d;
      area = 3.14 * radius * 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 ShapeContainer
{
    List<Shape> _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 Program
{
    static void Main(string[] args)
    {
      ShapeContainer sc = new ShapeContainer();
      Circle c1 = new Circle(54);
      Rectangle r1 = new Rectangle(12, 9); // 假设已有Rectangle实现
      
      sc.AddShape(c1);
      sc.AddShape(r1);

      // 触发更新事件
      c1.Update(57);
      r1.Update(7, 7);

      Console.WriteLine("Press any key to exit.");
      Console.ReadKey();
    }
}

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

public interface IDrawingObject
{
    // 要求在绘制对象之前触发
    event EventHandler OnDraw;
}

public interface IShape
{
    // 要求在绘制形状之后触发
    event EventHandler OnDraw;
}

public class Shape : IDrawingObject, IShape
{
    // 类内部维护两个不同的事件通道
    event EventHandler PreDrawEvent;
    event EventHandler PostDrawEvent;

    object objectLock = new Object();

    // 显式实现 IDrawingObject 的 OnDraw -> 关联 PreDrawEvent
    event EventHandler IDrawingObject.OnDraw
    {
      add
      {
        lock (objectLock)
        {
          PreDrawEvent += value;
        }
      }
      remove
      {
        lock (objectLock)
        {
          PreDrawEvent -= value;
        }
      }
    }

    // 显式实现 IShape 的 OnDraw -> 关联 PostDrawEvent
    event EventHandler IShape.OnDraw
    {
      add
      {
        lock (objectLock)
        {
          PostDrawEvent += value;
        }
      }
      remove
      {
        lock (objectLock)
        {
          PostDrawEvent -= value;
        }
      }
    }

    // 公共绘图方法，按顺序触发不同接口的事件
    public void Draw()
    {
      // 1. 触发绘制前的信号
      EventHandler handler = PreDrawEvent;
      if (handler != null) handler(this, new EventArgs());

      Console.WriteLine("Drawing a shape.");

      // 2. 触发绘制后的信号
      handler = PostDrawEvent;
      if (handler != null) handler(this, new EventArgs());
    }
}

public class Subscriber1
{
    public Subscriber1(Shape shape)
    {
      // 仅订阅作为“绘图对象”时的行为
      IDrawingObject d = (IDrawingObject)shape;
      d.OnDraw += (s, e) => Console.WriteLine("Sub1 receives the IDrawingObject event.");
    }
}

public class Subscriber2
{
    public Subscriber2(Shape shape)
    {
      // 仅订阅作为“形状”时的行为
      IShape d = (IShape)shape;
      d.OnDraw += (s, 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();
    }
}

  Sub1 receives the IDrawingObject event.
  Drawing a shape.
  Sub2 receives the IShape event.