Ogni linguaggio di programmazione ha una sua gestione intrinseca degli eventi, per gli sviluppatori C# con .NET 3.5 e l’utilizzo delle Dependency Property il lavoro si è semplificato, ma i concetti alla base prima o poi riemergono, ed ecco quindi un breve ripasso per un loro utilizzo molto base!

C#, la guida completa

Supporrò che siate già in possesso dei concetti base (come per esempio dei delegati, una delle varie comodità del C# e fondamento degli eventi), quindi inserirò direttamente le classi con i commenti sul perché del codice! La fonte non sono io, ma il guru Herbert Schildt (lo consiglio per imparare anche Java e C++, oltre a C#), le classi create sono due: MyEvent, che è la proprietaria dell’evento, e Window1, che in pratica, con Window_Loaded, ha l’equivalente del Main (oramai ho preso l’abitudine di creare direttamente progetti WPF per tutto! ^_^)

Ah, considerato che leggere il codice con questo layout del blog è davvero ostico, in questo documento Word ci sono le classi con il testo formattato ed indentato come si deve! Per approfondire l’argomento ci sono queste slides del corso di Laboratorio di Ingegneria del Software L-A (troverete molto materiale utile su C# e .NET 2.0), mentre il libro da cui ho preso l’esempio sottostante è C#, La guida completa di Herbert Schildt.


namespace SimpleEvent

{

/// <summary>

/// Dichiara un delegato per un evento.

/// Tutti gli eventi vengono attivati attraverso un delegato. Pertanto il

/// delegato dell’evento ne definisce la firma. In questo caso non ci sono

/// parametri, tuttavia i parametri dell’evento sono ammessi.

/// Dato che gli eventi vengono in genere sotooposti a multicasting, un

/// evento dovrebbe restituire void.

/// Successivamente verrà creata una classe di eventi.

/// </summary>

delegate void MyEventHandler();

class MyEvent

{

/// <summary>

/// Dichiarazione di un oggetto dell’evento.

/// All’interno di MyEvent viene dichiarato anche il metodo OnSomeEvent(),

/// ossia il metodo che un programma chiamerà per segnalare (o “attivare”)

/// un evento (in altre parole, questo è il metodo chiamato quando si

/// verifica l’evento).

/// Infatti chiama un gestore di eventi tramite il delegato SomeEvent, nel

/// modo:

/// if (SomeEvent != null ) SomeEvent();

/// </summary>

public event MyEventHandler SomeEvent;

/// <summary>

/// Questo viene chiamato per attivare l’evento.

/// </summary>

public void OnSomeEvent()

{

// Un gestore viene chiamato solo nel caso in cui SomeEvent

// non sia null. Dato che altre parti del programma devono

// registrare un certo interesse per un evento per ricevere

// le notifiche dell’evento, può accadere che OnSomeEvent()

// venga chiamato quando non è stato ancora registrato alcun

// gestore di eventi. Per evitare di chiamare un oggetto null,

// dovrete verificare il delegato dell’evento per assicurarvi

// che non sia null.

if (SomeEvent != null)

SomeEvent();

}

}

}


namespace SimpleEvent

{

/// <summary>

/// Interaction logic for Window1.xaml

/// </summary>

public partial class Window1 : Window

{

public Window1()

{

InitializeComponent();

}

/// <summary>

/// Un gestore di eventi.

/// In questo esempio, il gestore di eventi visualizza semplicemente

/// un messaggio, tuttavia altri gestori potrebbero eseguire azioni

/// più importanti.

/// </summary>

static void handler()

{

Console.WriteLine(“L’evento si è verificato.”);

}

private void Window_Loaded(object sender, RoutedEventArgs e)

{

// Viene creato un oggetto MyEvent:

MyEvent evt = new MyEvent();

// Aggiunge handler() alla lista di eventi, ovvero handler() viene

// registrato come gestore per questo evento.

// Notare che il gestore è stato aggiunto usando l’operatore +=. Gli

// eventi supportano solamente += e -=. In questo caso handler() è

// static, tuttavia i gestori di eventi possono essere anche dei metodi

// di istanza.

evt.SomeEvent += new MyEventHandler(handler);

// Nota: se volessi registrare più oggetti ad un evento ecco la bozza

// di soluzione:

//      OggettoX xObj = new OggettoX();

//      OggettoY yObj = new OggettoY();

//      evt.SomeEvent += new MyEventHandler(xObj.Xhandler);

//      evt.SomeEvent += new MyEventHandler(yObj.Yhandler);

// Attiva l’evento.

// La chiamata OnSomeEvent() comporta la chiamata di tutti i gestori

// di eventi registrati. In questo caso c’è un solo gestore registrato,

// ma ce ne potrebbero essere di più.

evt.OnSomeEvent();

// Se avessi registrato più handler verrebbero chiamati tutti.

}

}

}