Perché utilizzare gli eventi?

Question

Capisco come funzionano gli eventi in C# (sono un buon novellino in questo campo). Quello che sto cercando di capire è il motivo per cui usiamo gli eventi.

Conoscete un'app ben codificata/architettonica che utilizza gli eventi?

** resto del messaggio snipped e mettere in come risposta **

Answer 1

Per fornire un esempio normale mondo concreto ....

Si dispone di un modulo, il modulo ha una casella di riepilogo. C'è una bella classe felice per la lista. Quando l'utente seleziona qualcosa dalla casella di riepilogo, desidera conoscere e modificare altre cose nel modulo.

Senza eventi:

È derivano dalla casella di riepilogo, ignorando le cose per assicurarsi che il vostro genitore è la forma che ci si aspetta di essere su. Esegui l'override di un metodo ListSelected o qualcosa che manipola altre cose sul tuo modulo padre.

Con eventi: Il modulo ascolta l'evento per indicare che un utente ha selezionato qualcosa e manipola altre cose nel modulo.

La differenza è che nel caso senza eventi è stata creata una classe con un solo scopo e anche una che è strettamente legata all'ambiente in cui si aspetta di trovarsi. Nel caso degli eventi, il codice che manipola il tuo la forma è localizzata nel tuo modulo, e la lista è solo, beh, una lista.

Answer 2

Si può sempre costruire il proprio modo di invio/ricezione di eventi, iscrizione/cancellazione di origini eventi. Ma il linguaggio ti dà un modo semplice/standard per farlo, quindi è una buona ragione per usare gli "eventi" linguistici invece della tua tecnica di eventi.

Inoltre, l'utilizzo del linguaggio "eventi" consente di eseguire tutti i tipi di cose interessanti utilizzando il riflesso perché è standardizzato.

Per quanto riguarda il motivo per cui utilizzare una tecnica di evento a tutti. Ci sono tutti i tipi di esempi di vita reale in cui questo è abbastanza utile e semplice da usare eventi. Gli eventi sono quasi simili nella loro utilità rispetto a quelli di Windows.

Answer 3

Al livello concettuale di base, gli eventi sono ciò che consente al computer di reagire a ciò che si fa, piuttosto che a chi richiede di reagire a ciò che fa il computer. Quando sei seduto di fronte al tuo PC con diverse applicazioni in esecuzione (incluso il sistema operativo) e diversi oggetti cliccabili disponibili in ogni contesto tra cui scegliere, gli eventi sono ciò che accade quando ne scegli uno e tutti i pezzi coinvolti possono essere correttamente notificato.

Anche spostare il mouse su un flusso di eventi (per spostare il cursore, ad esempio).

Answer 4

È possibile implementare Observer Pattern in C# con eventi e delegati.

Ecco un link ad un articolo che descrive come: http://blogs.msdn.com/bashmohandes/archive/2007/03/10/observer-pattern-in-c-events-delegates.aspx

---

alt text http://dofactory.com/Patterns/Diagrams/observer.gif

Answer 5

* questo era nel corpo domanda

Quale potrebbe essere molto utile è un non banale esempio di un'app che utilizza eventi (suppongo che aiuti davvero anche i test?)

I pensieri finora sono:

Perché utilizzare Eventi o pubblicare/iscriversi?

Qualsiasi numero di classi può essere notificato quando viene generato un evento.

La sottoscrizione classi non hanno bisogno di sapere come il metronomo (vedi codice qui sotto) funziona, e il metronomo non ha bisogno di sapere che cosa stanno andando a fare in risposta all'evento

L'editore e gli abbonati sono disaccoppiati dal delegato. Questo è altamente auspicabile in quanto rende il codice più flessibile e robusto. Il metronomo può cambiare il modo in cui rileva il tempo senza interrompere nessuna delle classi di iscrizione. Le classi di iscrizione possono cambiare il modo in cui rispondono alle variazioni di orario senza rompere il metronomo. Le due classi ruotano indipendentemente l'una dall'altra, il che rende il codice più facile da mantenere.

class Program 
{ 
    static void Main() 
    { 
     // setup the metronome and make sure the EventHandler delegate is ready 
     Metronome metronome = new Metronome(); 

     // wires up the metronome_Tick method to the EventHandler delegate 
     Listener listener = new Listener(metronome); 
     ListenerB listenerB = new ListenerB(metronome); 
     metronome.Go(); 
    } 
} 

public class Metronome 
{ 
    // a delegate 
    // so every time Tick is called, the runtime calls another method 
    // in this case Listener.metronome_Tick and ListenerB.metronome_Tick 
    public event EventHandler Tick; 

    // virtual so can override default behaviour in inherited classes easily 
    protected virtual void OnTick(EventArgs e) 
    { 
     // null guard so if there are no listeners attached it wont throw an exception 
     if (Tick != null) 
      Tick(this, e); 
    } 

    public void Go() 
    { 
     while (true) 
     { 
      Thread.Sleep(2000); 
      // because using EventHandler delegate, need to include the sending object and eventargs 
      // although we are not using them 
      OnTick(EventArgs.Empty); 
     } 
    } 
} 


public class Listener 
{ 
    public Listener(Metronome metronome) 
    { 
     metronome.Tick += new EventHandler(metronome_Tick); 
    } 

    private void metronome_Tick(object sender, EventArgs e) 
    { 
     Console.WriteLine("Heard it"); 
    } 
} 

public class ListenerB 
{ 
    public ListenerB(Metronome metronome) 
    { 
     metronome.Tick += new EventHandler(metronome_Tick); 
    } 

    private void metronome_Tick(object sender, EventArgs e) 
    { 
     Console.WriteLine("ListenerB: Heard it"); 
    } 
} 

Articolo completo che sto scrivendo sul mio sito: http://www.programgood.net/

nb alcune di questo testo è da http://www.akadia.com/services/dotnet_delegates_and_events.html

Cin cin.