delegate (C++/CLI y C++/CX)
Declara un tipo que representa un puntero de función.
Todos los runtimes
Windows Runtime y Common Language Runtime admiten delegados.
Comentarios
delegate es una palabra clave contextual. Para obtener más información, consulte Context-Sensitive Keywords (Palabras clave contextuales).
Para detectar en tiempo de compilación si un tipo es un delegado, use el rasgo de tipo __is_delegate(). Para más información, consulte Compatibilidad del compilador con rasgos de tipo.
Windows en tiempo de ejecución
C++/CX admite delegados con la sintaxis siguiente.
Sintaxis
access
delegate
return-type
delegate-type-identifier
(
[ parameters ]
)
Parámetros
acceso
(Opcional) La accesibilidad del delegado, que puede ser public (el valor predeterminado) o private. El prototipo de función también se puede calificar con las palabras clave const o volatile.
return-type
El tipo de valor devuelto del prototipo de función.
delegate-type-identifier
El nombre del tipo de delegado declarado.
parameters
(Opcional) Los tipos e identificadores del prototipo de función.
Comentarios
Use delegate-type-identifier para declarar un evento con el mismo prototipo que el delegado. Para información, consulte Delegados (C++/CX).
Requisitos
Opción del compilador: /ZW
Common Language Runtime
Common language runtime admite delegados con la sintaxis siguiente.
Sintaxis
access
delegate
function_declaration
Parámetros
acceso
(opcional) La accesibilidad del delegado fuera del ensamblado puede ser pública o privada. El valor predeterminado es privada. Dentro de una clase, un delegado puede tener cualquier accesibilidad.
function_declaration
La signatura de la función que se puede enlazar al delegado. El tipo de valor devuelto de un delegado puede ser cualquier tipo administrado. Por motivos de interoperabilidad, se recomienda que el tipo de valor devuelto de un delegado sea un tipo CLS.
Para definir un delegado sin enlazar, el primer parámetro de function_declaration debe tener el tipo del puntero this del objeto.
Comentarios
Los delegados son multidifusión: el "puntero de función" se puede enlazar a uno o más métodos dentro de una clase administrada. La palabra clave delegate define un tipo de delegado de multidifusión con una signatura de método específica.
Un delegado también se puede enlazar a un método de una clase de valor, como un método estático.
Un delegado tiene las siguientes características:
Hereda de
System::MulticastDelegate.Tiene un constructor que toma dos argumentos: un puntero a una clase administrada o NULL (en el caso del enlace a un método estático) y un método completo del tipo especificado.
Tiene un método denominado
Invoke, cuya signatura coincide con la signatura declarada del delegado.
Cuando se invoca un delegado, sus funciones se llaman en el orden en que se asociaron.
El valor devuelto de un delegado es el valor devuelto por su última función miembro asociada.
Los delegados no se pueden sobrecargar.
Los delegados se pueden enlazar o desenlazar.
Cuando se crea una instancia de un delegado enlazado, el primer argumento será una referencia a un objeto. El segundo argumento de una instancia de delegado será la dirección de un método de un objeto de clase administrada o un puntero a un método de un tipo de valor. El segundo argumento de una instancia de delegado debe nombrar el método con la sintaxis de ámbito de clase completa y aplicar la dirección del operador.
Cuando se crea una instancia de un delegado sin enlazar, el primer argumento será la dirección de un método de un objeto de clase administrada o un puntero a un método de un tipo de valor. El argumento debe nombrar el método con la sintaxis de ámbito de clase completa y aplicar la dirección del operador.
Cuando se crea un delegado a una función global o estática, solo se requiere un parámetro: la función (opcionalmente, la dirección de la función).
Para más información sobre delegados, consulte
Requisitos
Opción del compilador: /clr
Ejemplos
En el ejemplo siguiente se muestra cómo declarar, inicializar e invocar delegados.
// mcppv2_delegate.cpp
// compile with: /clr
using namespace System;
// declare a delegate
public delegate void MyDel(int i);
ref class A {
public:
void func1(int i) {
Console::WriteLine("in func1 {0}", i);
}
void func2(int i) {
Console::WriteLine("in func2 {0}", i);
}
static void func3(int i) {
Console::WriteLine("in static func3 {0}", i);
}
};
int main () {
A ^ a = gcnew A;
// declare a delegate instance
MyDel^ DelInst;
// test if delegate is initialized
if (DelInst)
DelInst(7);
// assigning to delegate
DelInst = gcnew MyDel(a, &A::func1);
// invoke delegate
if (DelInst)
DelInst(8);
// add a function
DelInst += gcnew MyDel(a, &A::func2);
DelInst(9);
// remove a function
DelInst -= gcnew MyDel(a, &A::func1);
// invoke delegate with Invoke
DelInst->Invoke(10);
// make delegate to static function
MyDel ^ StaticDelInst = gcnew MyDel(&A::func3);
StaticDelInst(11);
}
in func1 8
in func1 9
in func2 9
in func2 10
in static func3 11