__event
Declara un evento.
__event method-declarator;
__event __interface interface-specifier;
__event member-declarator;
Comentarios
La palabra clave __event se puede aplicar a una declaración de método, una declaración de interfaz, o declaración de miembro de datos.Sin embargo, no puede utilizar la palabra clave de __event para calificar a un miembro de una clase anidada.
Dependiendo de si el origen de eventos y receptor son C++ nativo, COM, o administrado (.NET Framework), puede utilizar las siguientes construcciones como eventos:
C++ nativo |
COM |
Administrado (.NET Framework) |
|---|---|---|
Método |
— |
método |
— |
interfaz |
— |
— |
— |
miembro de datos |
Uso __hook en un receptor de eventos de asociar un método controlador con un método de evento.Observe que después de crear un evento con la palabra clave de __event , llamará a todos los controladores de eventos enlazados posteriormente a ese evento cuando se llama al evento.
Una declaración de método de __event no puede tener una definición; una definición se genera implícitamente, por lo que el método del evento puede llamar como si fuera cualquier método normal.
[!NOTA]
Una clase o struct basada en plantilla no puede contener eventos.
Eventos nativos
Eventos nativos son métodos.El tipo de valor devuelto es normalmente HRESULT o void, pero puede ser cualquier tipo entero, incluido enum.Cuando un evento utiliza un tipo de valor devuelto entero, se define una condición de error a un controlador de eventos devuelve un valor distinto de cero, en cuyo caso el evento que provoca llama a los otros delegados.
// Examples of native C++ events:
__event void OnDblClick();
__event HRESULT OnClick(int* b, char* s);
Vea Control de eventos en C++ nativo para el código de ejemplo.
Eventos COM
Los eventos COM son interfaces.Los parámetros de un método de una interfaz del origen de eventos deben ser parámetros de in (pero éste rigurosamente no se aplica), porque un parámetro de out no es útil al multicasting.Una advertencia de nivel 1 se emitirá si utiliza un parámetro de out .
El tipo de valor devuelto es normalmente HRESULT o void, pero puede ser cualquier tipo entero, incluido enum.Cuando un evento utiliza especificado de un tipo de valor devuelto entero y un controlador de eventos un valor distinto de cero, es una condición de error, en cuyo caso el evento que es anulaciones provocados llama a los otros delegados.Observe que el compilador automáticamente marcará una interfaz del origen de eventos como origen en el archivo IDL generado.
La palabra clave de __interface siempre se requiere después de __event para un origen de eventos COM.
// Example of a COM event:
__event __interface IEvent1;
Vea control de eventos en COM para el código de ejemplo.
Eventos administrados
Para obtener información sobre eventos de codificación en la nueva sintaxis, vea evento (Visual C++).
Los eventos administrados son miembros de datos o métodos.Cuando se utiliza con un evento, el tipo de valor devuelto de un delegado debe ser compatible con Common language specification.El del controlador de eventos debe coincidir con el del delegado.Para obtener más información en delegados, vea __delegate.Si un evento administrado es un miembro de datos, el tipo debe ser un puntero a un delegado.
En.NET Framework, puede tratarse de un miembro de datos como si fuera un método propio (es decir, el método de Invoke del delegado correspondiente).Debe predefinir el tipo de delegado para declarar un miembro administrado de los datos de eventos.En cambio, un método administrado event define implícitamente el delegado administrado correspondiente si no se ha definido.Por ejemplo, puede declarar un valor de evento como OnClick como evento como sigue:
// Examples of managed events:
__event ClickEventHandler* OnClick; // data member as event
__event void OnClick(String* s); // method as event
El implícitamente declarar un evento administrado, puede especificar agregue y quite los descriptores de acceso que se llamará cuando se agregan o quitan controladores de eventos.También puede definir el método que llama (mejoras) el evento desde fuera de la clase.
Ejemplo: eventos nativos
// EventHandling_Native_Event.cpp
// compile with: /c
[event_source(native)]
class CSource {
public:
__event void MyEvent(int nValue);
};
Ejemplo: eventos COM
// EventHandling_COM_Event.cpp
// compile with: /c
#define _ATL_ATTRIBUTES 1
#include <atlbase.h>
#include <atlcom.h>
[ module(dll, name="EventSource", uuid="6E46B59E-89C3-4c15-A6D8-B8A1CEC98830") ];
[ dual, uuid("00000000-0000-0000-0000-000000000002") ]
__interface IEventSource {
[id(1)] HRESULT MyEvent();
};
[ coclass, uuid("00000000-0000-0000-0000-000000000003"), event_source(com) ]
class CSource : public IEventSource {
public:
__event __interface IEventSource;
HRESULT FireEvent() {
__raise MyEvent();
return S_OK;
}
};
Ejemplo: eventos administrados
// EventHandling_Managed_Event.cpp
// compile with: /clr:oldSyntax /c
using namespace System;
[event_source(managed)]
public __gc class CPSource {
public:
__event void MyEvent(Int16 nValue);
};
Al aplicar un atributo a un evento, puede especificar que el atributo se aplica a los métodos generados o el método invoke de delegado generado.El valor predeterminado (event:) es aplicar el atributo al evento.
// EventHandling_Managed_Event_2.cpp
// compile with: /clr:oldSyntax /c
using namespace System;
[attribute(All, AllowMultiple=true)]
public __gc class Attr {};
public __delegate void D();
public __gc class X {
public:
[method:Attr] __event D* E;
[returnvalue:Attr] __event void noE();
};