Come spedire eventi in C #

Desidero creare i propri eventi e inviarli. Non l’ho mai fatto prima in C #, solo in Flex .. Credo che ci debbano essere molte differenze.

Qualcuno può darmi un buon esempio?

Esiste un modello che viene utilizzato in tutte le classi della libreria. È consigliato anche per le tue classi, specialmente per il codice framework / libreria. Ma nessuno ti fermerà quando devii o saltare qualche passo.

Ecco uno schema basato sul delegato di eventi più semplice, 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 } } 

E come usarlo:

 // 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 } } 

E quando hai informazioni da trasmettere:

 class MyEventArgs : EventArgs // guideline: derive from EventArgs { public string Info { get; set; } } class Foo { public event EventHandler 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; ... } } 

Aggiornare

A partire da C # 6 il codice chiamante nel metodo “Trigger” è diventato molto più semplice, il test Null può essere abbreviato con l’operatore null-condizionale ?. senza fare una copia mantenendo la sicurezza del thread:

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

Gli eventi in C # utilizzano i delegati.

 public static event EventHandler myEvent; static void Main() { //add method to be called myEvent += Handler; //call all methods that have been added to the event myEvent(this, EventArgs.Empty); } static void Handler(object sender, EventArgs args) { Console.WriteLine("Event Handled!"); } 

Utilizzando il tipico pattern di eventi .NET e assumendo che non siano necessari argomenti speciali nel proprio evento. Il tuo tipico evento e modello di spedizione è simile a questo.

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

Legare qualcosa all’evento può essere semplice come:

 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. } } 

Dai un’occhiata ai link su questa pagina MSDN

Guarda in “delegati”.

  • Definire un delegato
  • Usa il tipo di delegato come campo / proprietà (aggiungendo la parola chiave ‘Evento’)
  • Ora stai esponendo gli eventi a cui gli utenti possono connettersi con “+ = MyEventMethod;”

Spero che questo ti aiuti,