evento (Estensioni del componente C++)
La parola chiave event dichiara un evento, ovvero una notifica ai sottoscrittori registrati (gestori eventi) che qualcosa di interessante si è verificato.
Tutti i runtime
C++/CX supporta la dichiarazione di un membro di evento o di un blocco di evento.Un membro di evento è abbreviazione per la dichiarazione di un blocco di evento.Per impostazione predefinita, un membro di evento dichiara le funzioni add(), remove() e raise() dichiarate in modo esplicito in un blocco di evento.Per personalizzare le funzioni di un membro di evento, dichiarare un blocco di evento e quindi eseguire l'override delle funzioni necessarie.
Sintassi
// event data member
modifier event delegate^ event_name;
// event block
modifier event delegate^ event_name
{
modifier return_value add(delegate^ name);
modifier void remove(delegate^ name);
modifier void raise(parameters);
}
Parametri
modifier
Un modificatore che può essere utilizzato in una dichiarazione di evento o in un metodo della funzione di accesso agli eventi.I valori possibili sono static e virtual.delegate
Il delegato, la cui firma deve corrispondere al gestore di eventi.event_name
nome dell'evento.return_value
Il valore restituito del metodo della funzione di accesso.Per essere verificabile, il tipo restituito deve essere void.parameters
(facoltativo) Parametri per il metodo raise, che corrispondono alla firma del parametro delegate.
Note
Un evento è un'associazione tra un delegato e una funzione membro (un gestore eventi) che risponde all'attivazione dell'evento e che consente ai client di qualsiasi classe di registrare i metodi conformi con la firma e il tipo restituito del delegato sottostante.
Esistono due tipi di dichiarazioni di eventi:
membro dati di evento
Il compilatore crea automaticamente la memoria per l'evento sotto forma di membro di tipo delegato e crea le funzioni membro interne add(), remove() e raise().Un membro dati di evento deve essere dichiarato all'interno di una classe.Il tipo restituito del tipo restituito del delegato deve corrispondere al tipo restituito del gestore eventi.blocco di evento
Un blocco di evento consente di dichiarare in modo esplicito e di personalizzare il comportamento dei metodi add(), remove() e raise().
È possibile utilizzare operators+= e operator-= per aggiungere e rimuovere un gestore eventi, oppure si possono chiamare in modo esplicito i metodi add() e remove().
event è una parola chiave sensibile al contesto, vedere la pagina Parole chiave sensibili al contesto (Estensioni del componente C++) per ulteriori informazioni.
Windows Runtime
.gif "4b612y2s.collapse_all(it-it,VS.110).gif")
Note
Per ulteriori informazioni, vedere la pagina relativa agli eventi (C++/CX).
Se si desidera aggiungere e poi rimuovere un gestore eventi, è necessario salvare la struttura EventRegistrationToken restituita dall'operazione di aggiunta.Poi nell'operazione di rimozione, è necessario utilizzare la struttura salvata EventRegistrationToken per identificare il gestore eventi da rimuovere.
Requisiti
Opzione del compilatore: /ZW
Common Language Runtime
La parola chiave event consente di dichiarare un evento.Un evento è un modo per fornire ad una classe delle notifiche su una situazione di interesse.
Sintassi
// event data member
modifier event delegate^ event_name;
// event block
modifier event delegate^ event_name
{
modifier return_value add(delegate^ name);
modifier void remove(delegate^ name);
modifier void raise(parameters);
}
Parametri
modifier
Un modificatore che può essere utilizzato in una dichiarazione di evento o in un metodo della funzione di accesso agli eventi.I valori possibili sono static e virtual.delegate
Il delegato, la cui firma deve corrispondere al gestore di eventi.event_name
nome dell'evento.return_value
Il valore restituito del metodo della funzione di accesso.Per essere verificabile, il tipo restituito deve essere void.parameters
(facoltativo) Parametri per il metodo raise, che corrispondono alla firma del parametro delegate.
Note
Un evento è un'associazione tra un delegato e una funzione membro (un gestore eventi) che risponde all'attivazione dell'evento e che consente ai client di qualsiasi classe di registrare i metodi conformi con la firma e il tipo restituito del delegato sottostante.
Il delegato può contenere uno o più metodi associati che verranno invocati quando il codice indica che si è verificato l'evento.Un evento in un programma può essere reso disponibile ad altri programmi destinati al Common Language Runtime di .NET Framework.Vedere la pagina relativa alla generazione di un evento definito in un assembly diverso per un esempio.
Esistono due tipi di dichiarazioni di eventi:
membri dati di eventi
L'archiviazione per l'evento, sotto forma di membro di tipo delegato, viene creata dal compilatore per gli eventi del membro dati.Un membro dati di evento deve essere dichiarato all'interno di una classe.Questo è anche noto come evento semplice (vedere l'esempio di codice riportato di seguito).blocchi di eventi
I blocchi di eventi consentono di personalizzare il comportamento dei metodi add, remove e raise, implementando i metodi add, remove e raise.La firma dei metodi add, remove e raise deve corrispondere a quella del delegato.Gli eventi del blocco di evento non sono membri dati e qualsiasi utilizzo come membro dati genererà un errore del compilatore.Vedere la pagina relativa alla definizione dei metodi della funzione di accesso agli eventi per un esempio.
Il tipo restituito del gestore eventi deve corrispondere al tipo restituito del delegato.
In .NET Framework, è possibile trattare un membro dati come se fosse un metodo (ovvero il metodo Invoke del delegato corrispondente).È necessario predefinire il tipo del delegato per la dichiarazione del membro dati di eventi gestiti.In contrasto, un metodo gestito di evento definisce in modo implicito il delegato gestito corrispondente se questo non è già stato definito.Vedere il codice di esempio alla fine di questa sezione per un esempio.
Quando si dichiara un evento gestito, si possono specificare le funzioni di accesso add e remove che verranno chiamate quando i gestori eventi vengono aggiunti o rimossi mediante gli operatori += e -=.I metodi add, remove e raise possono essere chiamati in modo esplicito.
I passaggi seguenti devono essere eseguiti in ordine per creare e utilizzare gli eventi in Visual C++:
Creare o identificare un delegato.Se si definisce un proprio evento, è inoltre necessario assicurarsi che esista un delegato da utilizzare con la parola chiave event.Se l'evento è predefinito, in .NET Framework ad esempio, i consumatori dell'evento dovranno conoscere soltanto il nome del delegato.
Creare una classe che contiene:
Un evento creato dal delegato.
(facoltativo) Un metodo che verifica l'esistenza di un'istanza del delegato dichiarato con la parola chiave event.In caso contrario, questa logica deve essere inserita nel codice che genera l'evento.
I metodi che chiamano l'evento.Questi metodi possono essere l'override di alcune funzionalità della classe base.
Questa classe definisce l'evento.
Definire una o più classi che connettono i metodi all'evento.Ciascuna di queste classi dovrà associare uno o più metodi all'evento nella classe base.
Utilizzare l'evento:
Creare un oggetto della classe che contiene la dichiarazione dell'evento.
Creare un oggetto della classe che contiene la definizione dell'evento.
Per ulteriori informazioni sugli eventi C++/CLI, vedere
Requisiti
Opzione del compilatore: /clr
Esempi
Esempio
Nell'esempio di codice seguente viene illustrata la dichiarazione di coppie di delegati, di eventi e di gestori eventi; la sottoscrizione (aggiunta) di gestori eventi; l'invocazione dei gestori eventi; quindi l'annullamento della sottoscrizione (rimozione) di gestori eventi.
// mcppv2_events.cpp
// compile with: /clr
using namespace System;
// declare delegates
delegate void ClickEventHandler(int, double);
delegate void DblClickEventHandler(String^);
// class that defines events
ref class EventSource {
public:
event ClickEventHandler^ OnClick; // declare the event OnClick
event DblClickEventHandler^ OnDblClick; // declare OnDblClick
void FireEvents() {
// raises events
OnClick(7, 3.14159);
OnDblClick("Hello");
}
};
// class that defines methods that will called when event occurs
ref class EventReceiver {
public:
void OnMyClick(int i, double d) {
Console::WriteLine("OnClick: {0}, {1}", i, d);
}
void OnMyDblClick(String^ str) {
Console::WriteLine("OnDblClick: {0}", str);
}
};
int main() {
EventSource ^ MyEventSource = gcnew EventSource();
EventReceiver^ MyEventReceiver = gcnew EventReceiver();
// hook handler to event
MyEventSource->OnClick += gcnew ClickEventHandler(MyEventReceiver, &EventReceiver::OnMyClick);
MyEventSource->OnDblClick += gcnew DblClickEventHandler(MyEventReceiver, &EventReceiver::OnMyDblClick);
// invoke events
MyEventSource->FireEvents();
// unhook handler to event
MyEventSource->OnClick -= gcnew ClickEventHandler(MyEventReceiver, &EventReceiver::OnMyClick);
MyEventSource->OnDblClick -= gcnew DblClickEventHandler(MyEventReceiver, &EventReceiver::OnMyDblClick);
}
Output
Esempio
Nell'esempio di codice seguente viene illustrata la logica utilizzata per generare il metodo raise per un evento semplice: Se un evento dispone di uno o più sottoscrittori, chiamare in modo implicito il metodo raise o chiamare in modo esplicito il delegato.Se il tipo restituito del delegato non è void e se non ci sono sottoscrittori di eventi, il metodo raise restituisce il valore predefinito per il tipo delegato.Se non vi sono sottoscrittori di eventi, la chiamata al metodo raise ritorna semplicemente e nessuna eccezione verrà generata.Se il tipo restituito del delegato non è void, viene restituito il tipo del delegato.
// trivial_events.cpp
// compile with: /clr /c
using namespace System;
public delegate int Del();
public ref struct C {
int i;
event Del^ MyEvent;
void FireEvent() {
i = MyEvent();
}
};
ref struct EventReceiver {
int OnMyClick() { return 0; }
};
int main() {
C c;
c.i = 687;
c.FireEvent();
Console::WriteLine(c.i);
c.i = 688;
EventReceiver^ MyEventReceiver = gcnew EventReceiver();
c.MyEvent += gcnew Del(MyEventReceiver, &EventReceiver::OnMyClick);
Console::WriteLine(c.i);
}
Output