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);      }    }  }}

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.