¿Cómo utilizar delegados en C#?
La delegación es un tipo recién agregado en C#. Puedes considerarlo como un tipo similar a Class, similar al uso de clases. Cuando se utiliza la delegación, se requieren dos pasos. Primero, necesitas definir un delegado, tal como lo harías con una clase. Luego puede crear una o más instancias de ese delegado.
La sintaxis para definir un delegado es la siguiente:
[público/protegido/privado] delegado returnType nombre del delegado(tipo de parámetro parámetro 1,…)
Este soy yo. La escritura parece un poco extraña. Déjame explicarte: privado/protegido/privado son calificadores, así que no entraré en detalles. delegado es la palabra clave que declara al delegado, tipo de retorno es el tipo de retorno y nombre delegado es el nombre que le da al delegado. Puedes escribir cualquier nombre que quieras, tipo de parámetro param1... que es una lista de parámetros. Habiendo dicho tanto, puede que no parezca fácil de entender. Yo también lo creo. En la práctica, la definición de delegación consiste en agregar una palabra clave delegada a la definición de función. Su función es similar a declarar una clase:
Nombre de clase de clase pública {…}
Crear una instancia de un delegado:
[público/protegido/privado ]nombre del delegado deleInstanceName = nuevo nombre del delegado(nombre del método)
Esto es similar a crear una instancia de una clase. Nombre de la clase pública nombre de la instancia = nuevo nombre de la clase (...). El método MethodName debe ser el mismo que el delegado. Las firmas son consistentes. ¿Qué es la coherencia de la firma? Es decir, la lista de parámetros y el valor de retorno de MethodName deben ser coherentes con returnType y (paramtype param1,...) respectivamente. Permítanme dar un ejemplo para ilustrar:
Cadena de delegado público DelegateDemo(string name, int age);
Por ejemplo, definimos un delegado como se indicó anteriormente. En términos de escritura, en realidad agregamos una palabra clave Delegate delante de la demostración de delegado de cadena de función (nombre de cadena, Intage). Creemos una función:
Cadena pública AgentDemo(nombre de cadena, edad entera)
{
cadena rev =
…
Devolver rev
}
Esta función se pasa como parámetro a una instancia de DelegateDemo y luego crea una instancia de DelegateDemo:
nombre delegado instancia demo = nuevo nombre delegado (demo del agente);
En este momento, necesitamos hablar sobre coherencia, es decir, los valores de retorno de las dos funciones AgentDemo y delegadoDemo (vamos eliminar delegado) debería ser el mismo. Finalmente, no sé si la gente que mira lo entenderá.
A continuación, podemos usar este delegado (llamar al delegado) de la siguiente manera:
string name = " cshape
int age = 20
instanceDemo(nombre, edad);
Cuando se ejecuta instanciaDemo, la función AgentDemo se ejecutará. instanciaDemo es equivalente a un puntero de función en C, y ahora este puntero apunta a la dirección de entrada de función de AgentDemo.
2. Delegación multipunto
La delegación anterior solo contiene una llamada a un método. Si necesita llamar a varios métodos y necesita mostrar esta delegación varias veces, tenemos. Otra opción: dejar que un delegado contenga varios métodos para que se puedan llamar a varios métodos de forma secuencial llamando explícitamente al delegado una vez.
Consulte el siguiente ejemplo:
Delegado público void MultiDelegate(nombre de cadena);
public void AgentDemo1(cadena de cadena)
{
Consola. WriteLine(str+" este es agentdemo 1 \ n ");
}
public void AgentDemo2(string s)
{
Consola. WriteLine(s +"Esta es la demostración del agente 2 \ n ");
}
multi delegado multi demo = nuevo multi delegado (agentdemo 1);
multi demo+= new multi delegado(agent demo 2);
multi demo(" prueba de demostración múltiple:");
La salida debe ser:
Multi -mode Test: Este es AgentDemo1
Prueba mutliDemo: Este es AgentDemo2
Puedes ver que llamamos al delegado uno a la vez, que ejecuta los métodos AgentDemo1 y AgentDemo2 en secuencia ( según el orden en que agregó los métodos). Hay algunas cosas a tener en cuenta aquí:
●Los delegados admiten operadores como += y -=, que corresponden a agregar o eliminar métodos.
●La delegación multipunto no puede definir un valor de retorno porque el valor de retorno de múltiples métodos no se puede procesar, por lo que si desea utilizar la delegación multipunto, debe usar void; de lo contrario, su compilación devolverá un error.
●Para la delegación multipunto, no se recomienda tener un tipo de salida en la lista de parámetros. Esto solo eliminará el valor del último método y se perderán otros valores.
3. Comprensión de la delegación
En primer lugar, permítanme afirmar que este es solo un ejemplo que di para ayudar a comprender el proceso de delegación. Muchos de ellos no pueden resistir el escrutinio. Espero que lo sepas. Más cerca de casa,
Quieres comer,
pero no puedo hacerlo yo mismo (el cliente no conoce los detalles de implementación).
Planeas buscar un restaurante y pedir arroz con cerdo al estilo de Sichuan (definir comisión).
Decides buscar un restaurante llamado a al que vas con frecuencia (comisión instanciada)
Llamas al hotel A (número de teléfono de la comisión)
Hotel A Sichuan Se prepara arroz con cerdo al estilo (agente).
Fue agradable cenar.
4. Cuándo usar la delegación
Cuando necesites pasar un método a otro, puedes considerar usar la delegación. No parece fácil de entender. También se puede decir que cuando esté seguro de querer manejar algo pero no esté seguro de cómo hacerlo, puede considerar utilizar la delegación. De hecho, parece un poco descabellado decir que la aplicación de la delegación es más una aplicación en eventos.
5. Ejemplo de delegación
Utilizo dos clases para hacer este ejemplo. Una clase, la llamo principal y la otra clase, la llamo agente, el código es el siguiente:
Usa el sistema;
Espacio de nombres Visen. Representante de demostración
{
///& lt; Resumen>
///Iniciar la entrada del programa en la demostración de delegación, incluido el director.
///</summary>
Inicio del curso
{
#Método público de región
#regionEl principal punto de entrada de la aplicación.
///<Summary>
///El punto de entrada principal de la aplicación.
///</summary>
[hilo estático]
static void Main(string[] args)
{
Consola. WriteLine("Esta es una demostración encargada\n ");
Wesson.
demo. delegado. Agente ag = nuevo Agente();
//Definir el objeto del tipo de delegado.
eliminación única del mensaje de salida = nuevo mensaje de salida (ag.show message);
meth eliminada del mensaje de salida = nuevo mensaje de salida (agent.SShowMessage);
//Definir varios delegados.
mensaje de salida multi dele = nuevo mensaje de salida (ag. mostrar mensaje);
MultiDele += nuevo mensaje de salida (agent. SShowMessage);
singleDele(); "Delegar instancia única ");
deleStaticMeth("Delegar instancia deleStaticMeth ");
MultiDele("Este es un elemento múltiple"); Torre de control. read();
}
#endregionEl punto de entrada principal de la aplicación.
Método público #endregion
Campo privado #Región
///<Summary>
///Definir tipo de delegado.
///</summary>
Delegado privado void OutMessage(String msg);
#endregionCampo privado
}
}
Los siguientes son proxies:
Usar sistema;
Espacio de nombres Visen. Representante de demostración
{
///& lt; Resumen& gt
/// La clase Agente es el agente del principal y maneja los asuntos encomendados por el director.
///</summary>
Agente colectivo público
{
#Método público de región
#constructor nulo de región
///& lt; Resumen& gt
///Constructor vacío
///& lt;/summary>
PublicProxy()
{
}
#endregionEmpty constructor
#region muestra mensajes a la consola y a la clase Las funciones miembro actúan como representantes.
///<Summary>
///Utilice funciones de miembros de clase como agentes para mostrar mensajes en la consola.
///</summary>
///<param name = "msg">Mostrar contenido
Public void ShowMessage(mensaje de cadena)
{
Consola. WriteLine(" Método show message out:"+msg+" \ n ");
}
#endregion muestra un mensaje en la consola y la función miembro de la clase actúa como proxy .
#region muestra un mensaje a la consola, una función estática de clase actúa como proxy.
///<Summary>
///Muestra un mensaje en la consola, utilizando una función estática de clase como proxy.
///</summary>
///<param name = "msg">Mostrar información
SShowMessage vacío estático público (mensaje de cadena)
{
Consola.
WriteLine(" static Method SShowMessage out:"+msg+" \ n ");
}
#endregion muestra un mensaje en la consola, utilizando una función estática de clase como proxy.
#endregionMétodos públicos
}
}
El resultado es:
Esta es una demostración representativa
Método de salida ShowMessage: instancia delegada singleDele
Método estático ShowMessage de salida: instancia delegada deleStaticMeth
Método de salida ShowMessage: este es un elemento múltiple
Método estático ShowMessage out: Este es un elemento múltiple
Se puede ver que la función del método puede ser una función miembro de la clase o un miembro estático, siempre que tenga la misma firma que el delegado. .
Si hay algún error, por favor critíquelo y corríjalo. ¡Gracias a todos!