Comparteix via

operador delegado

El delegate operador crea un método anónimo que se puede convertir en un tipo delegado.

La documentación de referencia del lenguaje C# cubre la versión más reciente publicada del lenguaje C#. También contiene documentación inicial sobre las características de las versiones preliminares públicas de la próxima versión del lenguaje.

La documentación identifica cualquier característica introducida por primera vez en las últimas tres versiones del idioma o en las versiones preliminares públicas actuales.

Sugerencia

Para buscar cuándo se introdujo por primera vez una característica en C#, consulte el artículo sobre el historial de versiones del lenguaje C#.

Puede convertir un método anónimo en tipos como System.Action y System.Func<TResult>. Muchos métodos usan estos tipos como argumentos.

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 obtener más información sobre las características de las expresiones lambda, como capturar variables externas, vea Expresiones lambda.

Al usar el delegate operador , puede omitir la lista de parámetros. Si omite la lista de parámetros, cree un método anónimo que pueda convertir a un tipo delegado con cualquier lista de parámetros, 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 funcionalidad es la única característica de métodos anónimos que las expresiones lambda no admiten. En todos los demás casos, use una expresión lambda para escribir código insertado. Puede usar descartes 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

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

Use el static modificador al declarar 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 estado de instancia de ámbitos envolventes.

Use la delegate palabra clave para declarar un tipo de delegado.

El compilador puede almacenar en caché el objeto delegado que crea a partir de un grupo de métodos. Tenga en cuenta el método siguiente:

static void StaticFunction() { }

Al asignar el grupo de métodos a un delegado, el compilador almacena en caché el 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

  • Last updated on