Eventos e representantes
A maneira de declarar delegados e eventos foi alterado a partir de Managed Extensions for C++ para Visual C++ 2010.
O sublinhado duplo não é mais necessária, conforme mostrado no exemplo a seguir. Aqui um exemplo de código Managed Extensions:
__delegate void ClickEventHandler(int, double);
__delegate void DblClickEventHandler(String*);
__gc class EventSource {
__event ClickEventHandler* OnClick;
__event DblClickEventHandler* OnDblClick;
};
O mesmo código em que a nova sintaxe fica da seguinte maneira:
delegate void ClickEventHandler( int, double );
delegate void DblClickEventHandler( String^ );
ref class EventSource {
event ClickEventHandler^ OnClick;
event DblClickEventHandler^ OnDblClick;
};
Eventos (e delegados) são tipos de referência, que é claro em nova sintaxe causa do uso do Boné (^). Eventos oferecem suporte a uma sintaxe de declaração explícita e trivial formulário mostrado no código anterior. No formulário explícito, o usuário Especifica o add, raise, e remove métodos associados a eventos. (Somente o add e remove métodos são necessários; o raise método é opcional.)
Em extensões gerenciadas, se você fornecer esses métodos, você também não fornecer uma declaração explícita de evento, mas você deve decidir sobre um nome para o evento que não está presente. Cada método é especificado no formulário add_EventName, raise_EventName, e remove_EventName, como no exemplo a seguir, extraído da especificação de Managed Extensions:
// explicit implementations of add, remove, raise
public __delegate void f(int);
public __gc struct E {
f* _E;
public:
E() { _E = 0; }
__event void add_E1(f* d) { _E += d; }
static void Go() {
E* pE = new E;
pE->E1 += new f(pE, &E::handler);
pE->E1(17);
pE->E1 -= new f(pE, &E::handler);
pE->E1(17);
}
private:
__event void raise_E1(int i) {
if (_E)
_E(i);
}
protected:
__event void remove_E1(f* d) {
_E -= d;
}
};
A nova sintaxe simplifica a declaração, como a tradução do seguinte demonstra. Um evento Especifica as duas ou três métodos entre um par de chaves e colocado imediatamente após a declaração do evento e seu tipo de delegado associado, conforme mostrado aqui:
public delegate void f( int );
public ref struct E {
private:
f^ _E; // delegates are also reference types
public:
E() { // note the replacement of 0 with nullptr!
_E = nullptr;
}
// the new aggregate syntax of an explicit event declaration
event f^ E1 {
public:
void add( f^ d ) {
_E += d;
}
protected:
void remove( f^ d ) {
_E -= d;
}
private:
void raise( int i ) {
if ( _E )
_E( i );
}
}
static void Go() {
E^ pE = gcnew E;
pE->E1 += gcnew f( pE, &E::handler );
pE->E1( 17 );
pE->E1 -= gcnew f( pE, &E::handler );
pE->E1( 17 );
}
};