event parola chiave (C++/CLI e C++/CX)
La event parola chiave dichiara un evento, ovvero una notifica ai sottoscrittori registrati (gestori eventi) che si è verificato un evento di interesse.
Tutti i runtime
C++/CX supporta la dichiarazione di un membro evento o di un blocco eventi. Un membro evento è una forma abbreviata per la dichiarazione di un blocco eventi. Per impostazione predefinita, un membro evento dichiara le funzioni add, remove e raise che sono dichiarate in modo esplicito in un blocco eventi. Per personalizzare le funzioni in un membro evento, dichiarare un blocco eventi e quindi eseguire l'override delle funzioni richieste.
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 usato in una dichiarazione di evento o in un metodo della funzione di accesso all'evento. I valori possibili sono static e virtual.
delegate
Delegato, la firma deve corrispondere al gestore dell'evento.
event_name
Nome dell'evento.
return_value
Il valore restituito del metodo della funzione di accesso all'evento. Per essere verificabile, il tipo restituito deve essere void.
parameters
(Facoltativo) Parametri per il metodo raise che corrispondono alla firma del parametro delegate.
Osservazioni:
Un evento è un'associazione tra un delegato e un gestore eventi. Un gestore eventi è una funzione membro che risponde quando viene attivato l'evento. Consente ai client di qualsiasi classe di registrare metodi che corrispondono alla firma e al tipo restituito del delegato.
Esistono due tipi di dichiarazioni eventi:
event data member
Il compilatore crea automaticamente spazio di archiviazione per l'evento sotto forma di un membro del tipo delegato e crea le funzioni membro interne add, remove e raise. Un membro dati evento deve essere dichiarato all'interno di una classe. Il tipo restituito del delegato deve corrispondere al tipo restituito del gestore eventi.
event block
Un blocco eventi consente di dichiarare in modo esplicito e personalizzare il comportamento dei metodi add, remove e raise.
È possibile usare operator += e operator -= per aggiungere e rimuovere un gestore eventi oppure chiamare i add metodi e remove in modo esplicito.
event è una parola chiave sensibile al contesto. Per altre informazioni, vedere Parole chiave sensibili al contesto.
Windows Runtime
Osservazioni:
Per altre informazioni, vedere Eventi (C++/CX).
Per aggiungere e rimuovere in seguito un gestore eventi, salvare la EventRegistrationToken struttura restituita dall'operazione add . Nell'operazione remove usare quindi la struttura salvata EventRegistrationToken per identificare il gestore eventi da rimuovere.
Requisiti
Opzione del compilatore: /ZW
Common Language Runtime
La parola chiave event permette di dichiarare un evento. Un evento consente a una classe di inviare notifiche quando succede qualcosa 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 usato in una dichiarazione di evento o in un metodo della funzione di accesso all'evento. I valori possibili sono static e virtual.
delegate
Delegato, la firma deve corrispondere al gestore dell'evento.
event_name
Nome dell'evento.
return_value
Il valore restituito del metodo della funzione di accesso all'evento. Per essere verificabile, il tipo restituito deve essere void.
parameters
(Facoltativo) Parametri per il metodo raise che corrispondono alla firma del parametro delegate.
Osservazioni:
Un evento è un'associazione tra un delegato e un gestore eventi. Un gestore eventi è una funzione membro che risponde quando viene attivato l'evento. Consente ai client di qualsiasi classe di registrare metodi che corrispondono alla firma e al tipo restituito del delegato sottostante.
Il delegato può avere uno o più metodi associati. Questi metodi vengono chiamati quando il codice indica che si è verificato l'evento. Un evento in un programma può essere reso disponibile per altri programmi destinati a Common Language Runtime di .NET Framework.
Esistono due tipi di dichiarazioni di evento:
membri dati di evento
Il compilatore crea l'archiviazione per gli eventi del membro dati come membro del tipo delegato. Un membro dati evento deve essere dichiarato all'interno di una classe. Si tratta anche di un evento semplice. Vedere l'esempio di codice per un esempio.
blocchi eventi
I blocchi di eventi consentono di personalizzare il comportamento dei addmetodi , removee raise implementando addi metodi , removee raise . La firma dei addmetodi , removee raise deve corrispondere alla firma del delegato. Gli eventi del blocco di eventi non sono membri dati. Qualsiasi utilizzo come membro dati genera un errore del compilatore.
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). A tale scopo, predefinito il tipo delegato per dichiarare un membro dati dell'evento gestito. Al contrario, un metodo di evento gestito definisce in modo implicito il delegato gestito corrispondente, se non è già definito. Per un esempio, vedere l'esempio di codice alla fine di questo articolo.
Quando si dichiara un evento gestito, è possibile specificare add e remove le funzioni di accesso che verranno chiamate quando i gestori eventi vengono aggiunti o rimossi tramite operatori += e -=. I addmetodi , removee raise possono essere chiamati in modo esplicito.
Per creare e usare eventi in Microsoft C++, è necessario seguire questa procedura:
Creare o identificare un delegato. Se si definisce un evento personalizzato, è anche necessario assicurarsi che sia presente un delegato da usare con la
eventparola chiave . Se l'evento è predefinito, in .NET Framework ad esempio, i consumer dell'evento devono conoscere solo il nome del delegato.Creare una classe che contenga:
Un evento creato dal delegato.
(Facoltativo) Metodo che verifica che esista un'istanza del delegato dichiarato con la
eventparola chiave . In caso contrario, questa logica deve essere inserita nel codice che genera l'evento.Metodi che chiamano l'evento. Questi metodi possono essere override di alcune funzionalità della classe di base.
Questa classe definisce l'evento.
Definire una o più classi che consentano di connettere i metodi all'evento. Ognuna di queste classi verrà associata a uno o più metodi con l'evento nella classe di base.
Usare 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 altre informazioni sugli eventi C++/CLI, vedere Eventi in un'interfaccia.
Requisiti
Opzione del compilatore: /clr
Esempi
Nell'esempio di codice seguente viene illustrata la dichiarazione di coppie di delegati, eventi e gestori eventi. Illustra come sottoscrivere (aggiungere), richiamare e annullare la sottoscrizione (rimuovere) i 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);
}
OnClick: 7, 3.14159
OnDblClick: Hello
Nell'esempio di codice seguente viene illustrata la logica usata per generare il raise metodo di un evento semplice. Se l'evento ha uno o più sottoscrittori, la chiamata del metodo raise chiama in modo implicito o esplicito il delegato. Se il tipo restituito del delegato non void è e se sono presenti sottoscrittori di eventi zero, il raise metodo restituisce il valore predefinito per il tipo delegato. Se non sono presenti sottoscrittori di eventi, la chiamata al raise metodo restituisce immediatamente e non viene generata alcuna eccezione. Se il tipo restituito del delegato non voidè , viene restituito il tipo 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);
}
0
688
Vedi anche
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per