Eventi (confronto tra C# e Java)
Aggiornamento: novembre 2007
Un evento consente a una classe di notificare gli utenti di un oggetto quando si verifica una situazione interessante per questo oggetto, ad esempio la selezione di un controllo in un'interfaccia utente grafica. Questa notifica viene chiamata generazione di un evento. L'oggetto che genera un evento viene definito origine dell'evento.
Diversamente da quanto avviene in Java, dove gli eventi vengono in genere gestiti implementando classi listener personalizzate, gli sviluppatori C# possono utilizzare delegati per la gestione degli eventi. Un delegato è un tipo che incapsula un metodo. Una volta che un delegato viene inizializzato con un metodo, si comporta esattamente come quel metodo e può essere richiamato con l'operatore (). È simile a un puntatore a una funzione del linguaggio C++, ma è indipendente dai tipi.
È possibile utilizzare il delegato come qualsiasi altro metodo, con parametri e un valore restituito, come illustrato nel seguente esempio:
public delegate int ReturnResult(int x, int y);
Per ulteriori informazioni sui delegati, vedere Delegati (Guida per programmatori C#).
Gli eventi, analogamente ai metodi, dispongono di una firma che comprende un nome e un elenco di parametri. Questa firma è definita da un tipo di delegato, ad esempio:
public delegate void MyEventHandler(object sender, System.EventArgs e);
Nella programmazione dell'interfaccia utente Windows, in genere il primo parametro è l'oggetto che fa riferimento all'origine dell'evento, mentre il secondo è l'oggetto che contiene i dati correlati all'evento. Questa struttura non è tuttavia richiesta né imposta dal linguaggio C#. La firma di un evento può essere uguale a qualsiasi firma di delegato valida, purché restituisca void.
È possibile dichiarare un evento utilizzando la parola chiave event, come nell'esempio seguente:
public event MyEventHandler TriggerIt;
Per avviare l'evento, definire il metodo da richiamare quando l'evento viene generato, come nel seguente esempio:
public void Trigger()
{
TriggerIt();
}
Per generare un evento, chiamare il delegato e passare i parametri correlati all'evento. Il delegato chiamerà quindi tutti i gestori che sono stati aggiunti all'evento. A ciascun evento è possibile assegnare più gestori per la ricezione dell'evento. In questo caso ogni ricevente viene chiamato automaticamente. La generazione di un evento richiede un'unica chiamata all'evento, indipendentemente dal numero di riceventi.
Se si desidera che una classe riceva un evento, effettuare la sottoscrizione a tale evento aggiungendovi il delegato mediante l'operatore +=, ad esempio:
myEvent.TriggerIt += myEvent.MyMethod;
Per annullare la sottoscrizione di un evento, rimuovere il delegato dall'evento tramite l'operatore -=, ad esempio:
myEvent.TriggerIt -= new MyEventHandler(myEvent.MyMethod);
Per ulteriori informazioni sugli eventi, vedere Eventi (Guida per programmatori C#).
.gif "Nota") Nota: |
|---|
In C# 2.0, i delegati possono incapsulare sia metodi denominati che metodi anonimi. Per ulteriori informazioni sui metodi anonimi, vedere Metodi anonimi (Guida per programmatori C#). |
Esempio
Descrizione
Nell'esempio riportato di seguito viene definito un evento con tre metodi a esso associati. I metodi vengono eseguiti al momento della generazione dell'evento. Un metodo viene quindi rimosso dall'evento e quest'ultimo viene nuovamente generato.
Codice
// Declare the delegate handler for the event:
public delegate void MyEventHandler();
class TestEvent
{
// Declare the event implemented by MyEventHandler.
public event MyEventHandler TriggerIt;
// Declare a method that triggers the event:
public void Trigger()
{
TriggerIt();
}
// Declare the methods that will be associated with the TriggerIt event.
public void MyMethod1()
{
System.Console.WriteLine("Hello!");
}
public void MyMethod2()
{
System.Console.WriteLine("Hello again!");
}
public void MyMethod3()
{
System.Console.WriteLine("Good-bye!");
}
static void Main()
{
// Create an instance of the TestEvent class.
TestEvent myEvent = new TestEvent();
// Subscribe to the event by associating the handlers with the events:
myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod1);
myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod2);
myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod3);
// Trigger the event:
myEvent.Trigger();
// Unsuscribe from the the event by removing the handler from the event:
myEvent.TriggerIt -= new MyEventHandler(myEvent.MyMethod2);
System.Console.WriteLine("\"Hello again!\" unsubscribed from the event.");
// Trigger the new event:
myEvent.Trigger();
}
}
Output
Hello!
Hello again!
Good-bye!
"Hello again!" unsubscribed from the event.
Hello!
Good-bye!