Gewusst wie: Veröffentlichen von Ereignissen, die den .NET Framework-Richtlinien entsprechen (C#-Programmierhandbuch)How to: Publish Events that Conform to .NET Framework Guidelines (C# Programming Guide)

Das folgende Verfahren veranschaulicht, wie Sie Ereignisse hinzufügen können, die dem .NET Framework.NET Framework-Standardmuster ihrer Klassen und Strukturen folgen.The following procedure demonstrates how to add events that follow the standard .NET Framework.NET Framework pattern to your classes and structs. Alle Ereignisse in der .NET Framework.NET Framework-Klassenbibliothek basieren auf dem EventHandler-Delegaten, der wie folgt definiert ist:All events in the .NET Framework.NET Framework class library are based on the EventHandler delegate, which is defined as follows:

public delegate void EventHandler(object sender, EventArgs e);  

Hinweis

Das .NET Framework 2.0.NET Framework 2.0 führt eine generische Version dieses Delegaten ein: EventHandler<TEventArgs>.The .NET Framework 2.0.NET Framework 2.0 introduces a generic version of this delegate, EventHandler<TEventArgs>. Die folgenden Beispiele zeigen, wie Sie beide Versionen verwenden können.The following examples show how to use both versions.

Auch wenn Ereignisse in von Ihnen definierten Klassen auf jedem beliebigen Delegattyp basiert sein können – sogar Delegate, die einen Wert zurückgeben –, wird allgemein empfohlen, dass Sie Ihre Ereignisse mit dem EventHandler auf dem .NET Framework.NET Framework-Muster basieren, wie in folgendem Beispiel gezeigt.Although events in classes that you define can be based on any valid delegate type, even delegates that return a value, it is generally recommended that you base your events on the .NET Framework.NET Framework pattern by using EventHandler, as shown in the following example.

So veröffentlichen Sie Ereignisse, die auf dem EventHandler-Muster basierenTo publish events based on the EventHandler pattern

  1. (Überspringen Sie diesen Schritt, und gehen Sie direkt zu Schritt 3a, wenn Sie keine benutzerdefinierten Daten mit Ihrem Ereignis senden müssen.) Deklarieren Sie die Klasse Ihrer benutzerdefinierten Daten in einem für Ihre Herausgeber- und Ihre Abonnentenklasse sichtbaren Geltungsbereich.(Skip this step and go to Step 3a if you do not have to send custom data with your event.) Declare the class for your custom data at a scope that is visible to both your publisher and subscriber classes. Fügen Sie dann die erforderlichen Member hinzu, die Ihre benutzerdefinierten Ereignisdaten enthalten sollen.Then add the required members to hold your custom event data. In diesem Beispiel wird eine einzelne Zeichenfolge zurückgegeben.In this example, a simple string is returned.

    public class CustomEventArgs : EventArgs  
    {  
        public CustomEventArgs(string s)  
        {  
            msg = s;  
        }  
        private string msg;  
        public string Message  
        {  
            get { return msg; }  
        }   
    }  
    
  2. (Überspringen Sie diesen Schritt, wenn Sie eine generische Version von EventHandler<TEventArgs> verwenden.) Deklarieren Sie einen Delegaten in Ihrer Herausgeberklasse.(Skip this step if you are using the generic version of EventHandler<TEventArgs> .) Declare a delegate in your publishing class. Geben Sie ihm einen Namen, der auf EventHandler endet.Give it a name that ends with EventHandler. Der zweite Parameter gibt Ihren benutzerdefinierten EventArgs-Typen an.The second parameter specifies your custom EventArgs type.

    public delegate void CustomEventHandler(object sender, CustomEventArgs a);  
    
  3. Deklarieren Sie das Ereignis in Ihrer Herausgeberklasse, indem Sie einen der folgenden Schritte verwenden.Declare the event in your publishing class by using one of the following steps.

    1. Wenn Sie keine benutzerdefinierte EventArgs-Klasse haben, ist Ihr Ereignistyp der nicht generische EventHandler-Delegat.If you have no custom EventArgs class, your Event type will be the non-generic EventHandler delegate. Sie müssen den Delegaten nicht deklarieren, da er schon im System-Namespace deklariert wurde, der bei der Erstellung Ihres C#-Projekts erstellt wird.You do not have to declare the delegate because it is already declared in the System namespace that is included when you create your C# project. Fügen Sie den folgenden Code in Ihre Herausgeberklasse ein.Add the following code to your publisher class.

      public event EventHandler RaiseCustomEvent;  
      
    2. Wenn Sie die nicht generische Version von EventHandler verwenden, und Sie eine benutzerdefinierte Klasse haben, die von EventArgs abgeleitet ist, deklarieren Sie Ihr Ereignis innerhalb Ihrer Herausgeberklasse, und verwenden Sie Ihren Delegaten aus Schritt 2 als Typ.If you are using the non-generic version of EventHandler and you have a custom class derived from EventArgs, declare your event inside your publishing class and use your delegate from step 2 as the type.

      public event CustomEventHandler RaiseCustomEvent;  
      
    3. Wenn sie die generische Version verwenden, benötigen Sie keinen benutzerdefinierten Delegaten.If you are using the generic version, you do not need a custom delegate. Stattdessen geben Sie in Ihrer Herausgeberklasse Ihren Ereignistypen als EventHandler<CustomEventArgs> an und fügen den Namen Ihrer eigenen Klasse in die eckigen Klammern ein.Instead, in your publishing class, you specify your event type as EventHandler<CustomEventArgs>, substituting the name of your own class between the angle brackets.

      public event EventHandler<CustomEventArgs> RaiseCustomEvent;  
      

BeispielExample

Das folgende Beispiel veranschaulicht die oben genannten Schritte durch das Verwenden von einer benutzerdefinierten EventArgs-Klasse und von EventHandler<TEventArgs> als Ereignistyp.The following example demonstrates the previous steps by using a custom EventArgs class and EventHandler<TEventArgs> as the event type.

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

    // Define a class to hold custom event info
    public class CustomEventArgs : EventArgs
    {
        public CustomEventArgs(string s)
        {
            message = s;
        }
        private string message;

        public string Message
        {
            get { return message; }
            set { message = value; }
        }
    }

    // Class that publishes an event
    class Publisher
    {

        // Declare the event using EventHandler<T>
        public event EventHandler<CustomEventArgs> RaiseCustomEvent;

        public void DoSomething()
        {
            // Write some code that does something useful here
            // then raise the event. You can also raise an event
            // before you execute a block of code.
            OnRaiseCustomEvent(new CustomEventArgs("Did something"));

        }

        // Wrap event invocations inside a protected virtual method
        // to allow derived classes to override the event invocation behavior
        protected virtual void OnRaiseCustomEvent(CustomEventArgs 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<CustomEventArgs> handler = RaiseCustomEvent;

            // Event will be null if there are no subscribers
            if (handler != null)
            {
                // Format the string to send inside the CustomEventArgs parameter
                e.Message += String.Format(" at {0}", DateTime.Now.ToString());

                // Use the () operator to raise the event.
                handler(this, e);
            }
        }
    }

    //Class that subscribes to an event
    class Subscriber
    {
        private string id;
        public Subscriber(string ID, Publisher pub)
        {
            id = ID;
            // Subscribe to the event using C# 2.0 syntax
            pub.RaiseCustomEvent += HandleCustomEvent;
        }

        // Define what actions to take when the event is raised.
        void HandleCustomEvent(object sender, CustomEventArgs e)
        {
            Console.WriteLine(id + " received this message: {0}", e.Message);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Publisher pub = new Publisher();
            Subscriber sub1 = new Subscriber("sub1", pub);
            Subscriber sub2 = new Subscriber("sub2", pub);

            // Call the method that raises the event.
            pub.DoSomething();

            // Keep the console window open
            Console.WriteLine("Press Enter to close this window.");
            Console.ReadLine();

        }
    }
}

Siehe auchSee Also

Delegate
C#-ProgrammierhandbuchC# Programming Guide
EreignisseEvents
DelegatenDelegates