Compartir a través de

operador delegate

  • Artículo

El operador delegate crea un método anónimo que se puede convertir en un tipo delegado. Un método anónimo se puede convertir en tipos como System.Action y System.Func<TResult> que se usan como argumentos en muchos métodos.

Func<int, int, int> sum = delegate (int a, int b) { return a + b; };
Console.WriteLine(sum(3, 4));  // output: 7

Nota

Las expresiones lambda proporcionan una manera más concisa y expresiva de crear una función anónima. Use el operador=> para construir una expresión lambda:

Func<int, int, int> sum = (a, b) => a + b;
Console.WriteLine(sum(3, 4));  // output: 7

Para más información sobre las características de las expresiones lambda, como capturar las variables externas, consulte Expresiones lambda.

Al usar el operador delegate, puede omitir la lista de parámetros. Si lo hace, el método anónimo creado se puede convertir en un tipo delegado con cualquier lista de parámetros, tal como se muestra en el ejemplo siguiente:

Action greet = delegate { Console.WriteLine("Hello!"); };
greet();

Action<int, double> introduce = delegate { Console.WriteLine("This is world!"); };
introduce(42, 2.7);

// Output:
// Hello!
// This is world!

Esta es la única funcionalidad de los métodos anónimos que las expresiones lambda no admiten. En todos los demás casos, una expresión lambda es una de las maneras preferidas de escribir código alineado. Puede usar descarta para especificar dos o más parámetros de entrada de un método anónimo que el método no usa:

Func<int, int, int> constant = delegate (int _, int _) { return 42; };
Console.WriteLine(constant(3, 4));  // output: 42

Por compatibilidad con versiones anteriores, si solo un parámetro se denomina _, _ se trata como el nombre de ese parámetro dentro de un método anónimo.

Puede usar el modificador static en la declaración de un método anónimo:

Func<int, int, int> sum = static delegate (int a, int b) { return a + b; };
Console.WriteLine(sum(10, 4));  // output: 14

Un método anónimo estático no puede capturar variables locales ni el estado de la instancia desde el ámbito de inclusión.

También puede usar la palabra clave delegate para declarar un tipo delegado.

A partir de C# 11, el compilador puede almacenar en caché el objeto delegado creado a partir de un grupo de métodos. Observe el método siguiente:

static void StaticFunction() { }

Al asignar el grupo de métodos a un delegado, el compilador almacenará en caché el delegado:

Action a = StaticFunction;

Antes de C# 11, se tenía que usar una expresión lambda para reutilizar un solo objeto delegado:

Action a = () => StaticFunction();

Especificación del lenguaje C#

Para obtener más información, vea la sección Expresiones de función anónima de la Especificación del lenguaje C#.

Consulte también