So versenden Sie Ereignisse in C #

Es ist ein Muster, das verwendet wird, in allen Klassen-Bibliothek. Es wird empfohlen, für Ihre eigenen Klassen zu, vor allem für framework/library-code. Aber niemand wird Sie stoppen, wenn Sie abweichen oder überspringen Sie ein paar Schritte.

Hier ist ein Schema, basierend auf das einfachste event-delegate System.Eventhandler.

//The delegate type. This one is already defined in the library, in the System namespace
//the `void (object, EventArgs)` signature is also the recommended pattern
public delegate void Eventhandler(object sender, Eventargs args);  

//your publishing class
class Foo  
{
    public event EventHandler Changed;    //the Event

    protected virtual void OnChanged()    //the Trigger method, called to raise the event
    {
        //make a copy to be more thread-safe
        EventHandler handler = Changed;   

        if (handler != null)
        {
            //invoke the subscribed event-handler(s)
            handler(this, EventArgs.Empty);  
        }
    }

    //an example of raising the event
    void SomeMethod()
    {
       if (...)        //on some condition
         OnChanged();  //raise the event
    }
}

Und wie es zu benutzen:

//your subscribing class
class Bar
{       
    public Bar()
    {
        Foo f = new Foo();
        f.Changed += Foo_Changed;    //Subscribe, using the short notation
    }

    //the handler must conform to the signature
    void Foo_Changed(object sender, EventArgs args)  //the Handler (reacts)
    {
        //the things Bar has to do when Foo changes
    }
}

Und wenn Sie Informationen weitergeben:

class MyEventArgs : EventArgs    //guideline: derive from EventArgs
{
    public string Info { get; set; }
}

class Foo  
{
    public event EventHandler<MyEventArgs> Changed;    //the Event
    ...
    protected virtual void OnChanged(string info)      //the Trigger
    {
        EventHandler handler = Changed;   //make a copy to be more thread-safe
        if (handler != null)
        {
           var args = new MyEventArgs(){Info = info};  //this part will vary
           handler(this, args);  
        }
    }
}

class Bar
{       
   void Foo_Changed(object sender, MyEventArgs args)  //the Handler
   {
       string s = args.Info;
       ...
   }
}

Update

Beginnend mit C# 6 der aufrufende code ist in der "Trigger" - Methode hat sich zu einem viel einfacher, den null-test kann verkürzt werden mit dem null-conditional operator ?. ohne eine Kopie zu erstellen, während thread-Sicherheit:

protected virtual void OnChanged(string info)   //the Trigger
{
    var args = new MyEventArgs{Info = info};    //this part will vary
    Changed?.Invoke(this, args);
}

InformationsquelleAutor der Antwort Henk Holterman

Verwendung der typischen .NETZ-Ereignis-Muster, und vorausgesetzt, Sie brauchen keine speziellen Argumente in Ihre Veranstaltung. Der typische event-und Versand-Muster sieht wie folgt aus.

public class MyClassWithEvents
    {
        public event EventHandler MyEvent;

        protected void OnMyEvent(object sender, EventArgs eventArgs)
        {
            if (MyEvent != null)
            {
                MyEvent(sender, eventArgs);
            }
        }

        public void TriggerMyEvent()
        {
            OnMyEvent(sender, eventArgs);
        }
    }

Binden, etwas in den event kann so einfach sein wie:

public class Program
{
    public static void Main(string[] args)
    {
        MyClassWithEvents obj = new MyClassWithEvents();

        obj.MyEvent += obj_myEvent;
    }

    private static void obj_myEvent(object sender, EventArgs e)
    {
        //Code called when my event is dispatched.
    }
}

Werfen Sie einen Blick auf die links auf dieser MSDN-Seite

InformationsquelleAutor der Antwort Sekhat