C# Delegados (Delegate)
En C#, un delegado (Delegate) es un puntero a función seguro de tipos que permite pasar métodos como parámetros a otros métodos.
Los delegados (Delegate) en C# son similares a los punteros a funciones en C o C++.Delegados (Delegate)Es una variable de tipo de referencia que contiene una referencia a un método, y la referencia puede cambiarse en tiempo de ejecución.
Los delegados son muy comunes en C# y se utilizan para el manejo de eventos, funciones de devolución de llamada (callbacks), LINQ y otras operaciones.
Todos los delegados (Delegate) derivan deSystem.Delegatela clase.
Declaración de delegados (Delegate)
Un delegado es un tipo de referencia que define una firma de método y puede usarse para almacenar un método que coincida con esa firma. A través de un delegado, puedes invocar métodos de otras clases.
La declaración del delegado determina qué métodos puede referenciar el delegado. Un delegado puede apuntar a un método que tenga la misma firma.
La sintaxis para declarar un delegado es la siguiente:
public delegate <return type> <delegate-name> <parameter list>
Descripción del formato en chino:
public delegate 返回类型 委托名(参数类型 参数名, ...);
Por ejemplo, en el siguiente código, definimos un delegado que acepta dos enteros y devuelve un entero:
public delegate int MathOperation(int x, int y);
El delegado del siguiente ejemplo se puede usar para referenciar cualquier método que tenga un únicostringparámetro y devuelva unaintvariable de tipo.
public delegate int MyDelegate (string s);
Instanciación de delegados (Delegate)
Una vez que se ha declarado el tipo de delegado, el objeto delegado debe crearse usando la palabra clavenewnew, y asociado a un método específico. Al crear el delegado, los argumentos pasados a lanewsentencia se escriben como una llamada a método, pero sin parámetros. Por ejemplo:
...
printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);
El siguiente ejemplo demuestra la declaración, instanciación y uso de un delegado. Dicho delegado se puede utilizar para referenciar un método que tenga un parámetro entero y devuelva un valor entero.
Ejemplo
delegate int NumberChanger(int n);
namespace DelegateAppl
{
class TestDelegate
{
static int num = 10;
public static int AddNum(int p)
{
num += p;
return num;
}
public static int MultNum(int q)
{
num *= q;
return num;
}
public static int getNum()
{
return num;
}
static void Main(string[] args)
{
// Crear una instancia del delegado
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
// Usar el objeto delegado para llamar al método
nc1(25);
Console.WriteLine("Value of Num: {0}", getNum());
nc2(5);
Console.WriteLine("Value of Num: {0}", getNum());
Console.ReadKey();
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
Value of Num: 35 Value of Num: 175
Multidifusión de delegados (Multicasting of a Delegate)
Los objetos delegados se pueden combinar usando el+operador + para combinarse.
Un delegado combinado invoca a los dos delegados que lo componen. Solo los delegados del mismo tipo pueden combinarse.
-El operador - se puede usar para quitar un delegado componente de un delegado combinado.
Usando esta útil característica de los delegados, puede crear una lista de invocación de métodos que se llamarán cuando se invoque al delegado. Esto se conoce comomultidifusión (multicasting), también llamado multicast.
El siguiente programa demuestra la multidifusión de delegados:
Ejemplo
delegate int NumberChanger(int n);
namespace DelegateAppl
{
class TestDelegate
{
static int num = 10;
public static int AddNum(int p)
{
num += p;
return num;
}
public static int MultNum(int q)
{
num *= q;
return num;
}
public static int getNum()
{
return num;
}
static void Main(string[] args)
{
// Crear una instancia del delegado
NumberChanger nc;
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
nc = nc1;
nc += nc2;
// Llamar a la multidifusión
nc(5);
Console.WriteLine("Value of Num: {0}", getNum());
Console.ReadKey();
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
Value of Num: 75
Usos de los delegados (Delegate)
El siguiente ejemplo demuestra el uso de delegados. El delegadoprintStringse puede utilizar para referenciar un método que recibe una cadena como entrada y no devuelve nada.
Usamos este delegado para llamar a dos métodos: el primero imprime la cadena en la consola, y el segundo imprime la cadena en un archivo:
Ejemplo
using System.IO;
namespace DelegateAppl
{
class PrintString
{
static FileStream fs;
static StreamWriter sw;
// Declaración del delegado
public delegate void printString(string s);
// Este método imprime en la consola
public static void WriteToScreen(string str)
{
Console.WriteLine("The String is: {0}", str);
}
// Este método imprime en un archivo
public static void WriteToFile(string s)
{
fs = new FileStream("c:\\message.txt", FileMode.Append, FileAccess.Write);
sw = new StreamWriter(fs);
sw.WriteLine(s);
sw.Flush();
sw.Close();
fs.Close();
}
// Este método toma un delegado como parámetro y lo usa para llamar al método
public static void sendString(printString ps)
{
ps("Hello World");
}
static void Main(string[] args)
{
printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);
sendString(ps1);
sendString(ps2);
Console.ReadKey();
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
The String is: Hello World
Eliminar delegados
Si ya no necesitas un método, puedes-=usar el operador - para quitar ese método de la cadena de delegados.
Ejemplo
{
public delegate void PrintMessage(string message);
public static void PrintUpperCase(string message)
{
Console.WriteLine(message.ToUpper());
}
public static void PrintLowerCase(string message)
{
Console.WriteLine(message.ToLower());
}
public static void Main()
{
PrintMessage print = PrintUpperCase;
print += PrintLowerCase;
// Quitar el método PrintLowerCase
print -= PrintLowerCase;
// Llamar al delegado (solo llamará a PrintUpperCase)
print("Hello, C#"); // Salida: HELLO, C#
}
}
Delegados y eventos
Los delegados se usan a menudo junto con los eventos (Event). Un evento es un tipo especial de delegado utilizado para el mecanismo de publicación y suscripción.
En C#, un evento es esencialmente un tipo que encapsula un delegado y se utiliza para responder a ciertas operaciones en el programa.
Ejemplo
{
// Definir un evento
public event EventHandler Click;
// Método para provocar el evento
public void OnClick()
{
if (Click != null)
{
Click(this, EventArgs.Empty); // Llamar al evento
}
}
}
public class Program
{
public static void Main()
{
Button button = new Button();
// Suscribirse al evento
button.Click += Button_Click;
// Generar el evento
button.OnClick(); // Salida "Button clicked!"
}
private static void Button_Click(object sender, EventArgs e)
{
Console.WriteLine("Button clicked!");
}
}
Tipos de delegados
C# proporciona varios tipos de delegados comunes:
1、Action
ActionAction: representa un método que no devuelve valor. Puede aceptar hasta 16 parámetros.
Action<string> printMessage = Console.WriteLine;
printMessage("Hello");
2、Func
FuncFunc: representa un método que devuelve un valor. Acepta hasta 16 parámetros; el primer parámetro es el parámetro de entrada, y el último es el tipo de valor de retorno.
Func<int, int, int> add = (x, y) => x + y; Console.WriteLine(add(3, 4)); // 输出 7
3、Predicate
PredicatePredicate: representa un método que devuelve un valor bool, generalmente usado para condiciones.
Predicate<int> isEven = x => x % 2 == 0; Console.WriteLine(isEven(4)); // 输出 True
Consideraciones sobre delegados
Seguridad de tipos:Los delegados son seguros con respecto a los tipos, lo que significa que solo los métodos con firmas coincidentes pueden asignarse a un delegado.
Métodos anónimos y expresiones lambda: Puedes usar métodos anónimos o expresiones lambda para crear instancias de delegados, simplificando el código.
Func<int, int, int> add = (x, y) => x + y; Console.WriteLine(add(5, 3)); // 输出 8
Llamadas asincrónicas: Puedes usar delegados con los métodos BeginInvoke y EndInvoke para realizar llamadas asincrónicas.
Los delegados son una característica muy potente y flexible de C#. Ayudan a implementar programación controlada por eventos, mecanismos de devolución de llamada y estilos de programación funcional. No solo proporcionan capacidad de reutilización de código, sino que también mejoran la modularidad del programa. Comprender y dominar el uso de delegados es muy importante para la programación en C#.
Otras extensiones