Jak: implementace rozhraní události (Příručka programování C#)

Rozhraní deklarovat událost.Následující příklad ukazuje, jak implementovat rozhraní události ve třídě.Podstatě pravidla jsou stejné jako při provádění všech rozhraní metody nebo vlastnosti.

Implementovat rozhraní události ve třídě

• Událost ve své třídě deklarovat a potom vyvolat v příslušných oblastech.

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

Příklad

Následující příklad ukazuje, jak zpracovat méně běžné situace, ve které vaše třída dědí ze dvou nebo více rozhraní a každé rozhraní má událost se stejným názvem.V takovém případě je nutné zadat explicitní implementace rozhraní pro alespoň jednu z událostí.Při zápisu explicitní implementace rozhraní události, musíte také napsat add a remove přístupové objekty událostí.Obvykle jsou poskytovány kompilátorem, ale v tomto případě kompilátor nelze předat.

Zajištěním vlastní přístupové objekty můžete určit, zda dvě události představují stejné události ve své třídě nebo jiné události.Například pokud měla zvýšit události v různých časech podle specifikace rozhraní, můžete přiřadit každé události samostatné implementace ve své třídě.V následujícím příkladu předplatitelům určit, které OnDraw událostí, které obdrží podle obsazení obrazec odkaz buď IShape nebo 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.
*/

Viz také

Úkoly

Jak: vyvolat události základní třídy v odvozených tříd (Příručka programování C#)

Referenční dokumentace

Události (Příručka programování C#)

Delegáti (Příručka programování C#)

Explicitní implementace rozhraní (Příručka programování C#)

Koncepty

Příručka programování C#