چطور: پیاده سازی رویدادهای رابط

رابط (interface) می تواند یک رویداد را اعلان کند. مثال زیر چگونگی پیاده سازی رویدادهای رابطی را در یک کلاس نشان می دهد. بطور مقدماتی قواعد و قوانین کار مانند پیاده سازی متد ها یا پراپرتی های رابطی می باشد.
برای پیاده سازی رویدادهای رابطی در یک کلاس

• رویداد را در کلاستان اعلان کرده، سپس آنرا در مکان دلخواه فراخوانی کنید.
  

  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 را بنویسید. در حالت عادی اینها توسط کامپایلر فراهم می شوند، اما در این مورد کامپایلر نمی تواند آنها را فراهم کند.
با تهیه کردن دسیابی کننده های خودتان، می توانید تعیین کنید که آن دو رویداد، در کلاس شما توسط رویدادی مشابه نمایندگی می شود یا اینکه با رویدادهایی متفاوت. برای مثال، اگر قرار است رویدادها برطبق خصوصیات رابط در زمان ها مختلفی برپا شوند، شما می توانید هر رویداد را با پیاده سازی جداگانه ای در کلاستان مرتبط کنید. در مثال زیر، متعهدها با قالبریزی (casting) مرجع shape به IShape یا IDrawingObject ، تصمیم می گیرند که چه رویدادی را دریافت خواهند کرد.

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

}
/* Output:
    Sub1 receives the IDrawingObject event.
    Drawing a shape.
    Sub2 receives the IShape event.
*/