Warum Ereignisse für das, was ich mit Delegaten tun kann, verwenden?

Question

Ich weiß, Ereignisse sind immer Delegaten zugeordnet. Aber ich vermisse etwas Kernnutzung von Events und versuche das zu verstehen.

Ich erstellte ein einfaches Event-Programm, wie unten, und es funktioniert einwandfrei.

namespace CompleteRef3._0 
{ 
delegate void someEventDelegate(); 

class EventTester 
{ 
    public event someEventDelegate someEvent; 

    public void doEvent() 
    { 
     if (someEvent != null) someEvent(); 
    } 

} 

class Program 
{ 
    static void EventHandler1() 
    { 
     Console.WriteLine("Event handler 1 called.."); 
    } 

    static void EventHandler2() 
    { 
     Console.WriteLine("Event handler 2 called.."); 
    } 
    static void EventHandler3() 
    { 
     Console.WriteLine("Event handler 3 called.."); 
    } 


    static void Main(string[] args) 
    { 
     EventTester evt = new EventTester(); 
     evt.someEvent += EventHandler1; 
     evt.someEvent += EventHandler2; 
     evt.someEvent += EventHandler3; 
     evt.doEvent(); 
     Console.ReadKey(); 

    } 
} 
} 

Ich ersetzte die Event-Deklaration durch Delegaten. Das ist ich ersetzte die Linie öffentliches Ereignis someEventDelegate someEvent; mit someEventDelegate someEvent; auf das obige Programm, und ich bekomme immer noch das gleiche Ergebnis. Jetzt war ich verwirrt, warum wir Ereignisse verwenden müssen, wenn es nur von Delegierten erreicht werden kann. Wie werden Events wirklich genutzt?

Das modifizierte Programm ohne Ereignisse ist als unten -

namespace CompleteRef3._0 
{ 
delegate void someEventDelegate(); 

class EventTester 
{ 
    someEventDelegate someEvent; 

    public void doEvent() 
    { 
     if (someEvent != null) someEvent(); 
    } 

} 

class Program 
{ 
    static void EventHandler1() 
    { 
     Console.WriteLine("Event handler 1 called.."); 
    } 

    static void EventHandler2() 
    { 
     Console.WriteLine("Event handler 2 called.."); 
    } 
    static void EventHandler3() 
    { 
     Console.WriteLine("Event handler 3 called.."); 
    } 


    static void Main(string[] args) 
    { 
     EventTester evt = new EventTester(); 
     evt.someEvent += EventHandler1; 
     evt.someEvent += EventHandler2; 
     evt.someEvent += EventHandler3; 
     evt.doEvent(); 
     Console.ReadKey(); 

    } 
} 
} 

Answer 1

Sicher, können Sie Delegaten verwenden, weil hinter den Kulissen ein Ereignis ist ein Konstrukt, das einen Delegaten einwickelt.

Aber die Logik der Verwendung von Ereignissen anstelle von Delegaten ist die gleiche wie für die Verwendung von Eigenschaften anstelle von Feldern - Datenkapselung. Es ist eine schlechte Praxis, Felder (was auch immer sie sind - primitive Felder oder Delegaten) direkt verfügbar zu machen.

Übrigens, Sie vermissten ein Schlüsselwort public vor Ihrem Delegiertenfeld, um es im zweiten Snippet zu ermöglichen.

Ein weiteres "nebenbei" mit dem zweiten Ausschnitt: Für Delegierte sollten Sie Delegate.Combine anstelle von "+ =" verwenden.

Answer 2

Der Hauptzweck der Ereignisse ist Abonnenten stören miteinander zu verhindern. Wenn Sie Ereignisse nicht verwenden, können Sie:

andere Teilnehmer ersetzen durch Delegierte Neuzuweisung (statt mit dem Operator + =), Löschen Sie alle Abonnenten (indem Delegierten auf null), Übertragung an andere Teilnehmer durch die Berufung delegieren.

Quelle: C# in a Nutshell

Answer 3

Stellen Sie sich vor Sie haben 3 Abonnenten, die an Ihrem someEvent interessiert sind.Sie haben sich an die selbst wie folgt gezeichnet:

-Client 1

EventTester evt = new EventTester(); 
evt.someEvent += Client1Handler1; 
evt.someEvent += Cleint1Handler2; 

Kunde 2

EventTester evt = new EventTester(); 
evt.someEvent += Client2Handler1; 
evt.someEvent += Client2Handler2; 

-Client 3

EventTester evt = new EventTester(); 
evt.someEvent += Client2Handler1; 
evt.someEvent += Client2Handler2; 

nun einen anderen Client vorstellen, tut dies:

EventTester = null; 

Client 1, 2 und 3 werden keine Ereignisse bekommen, weil Sie diese Codezeile haben:

if (someEvent != null) someEvent(); 

Es ist nichts falsch mit der obigen Codezeile, aber es ist das Problem mit den Delegierten mit .

Das andere Problem, wie Alexei wies darauf hin, ist:

someEvent = new someEventDelegate(EventHandler2) 

Wenn Sie ein event und einer der Kunden die oben versucht, sie werden nicht erlaubt und einen Compiler-Fehler erhalten werden, wie folgt aus: