El operador expresión lambda (=>) define una expresión lambda

El => token se admite en dos formas: como operador lambda y como separador de un nombre de miembro y la implementación de miembro en una definición de cuerpo de expresión.

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.

Operador lambda

En las expresiones lambda, el operador => lambda separa los parámetros de entrada del lado izquierdo del cuerpo lambda del lado derecho.

En el ejemplo siguiente se usa la característica LINQ con sintaxis de método para demostrar el uso de expresiones lambda:

string[] words = { "bot", "apple", "apricot" };
int minimalLength = words
  .Where(w => w.StartsWith("a"))
  .Min(w => w.Length);
Console.WriteLine(minimalLength);   // output: 5

int[] numbers = { 4, 7, 10 };
int product = numbers.Aggregate(1, (interim, next) => interim * next);
Console.WriteLine(product);   // output: 280

Los parámetros de entrada de una expresión lambda se escriben fuertemente en tiempo de compilación. Cuando el compilador deduce los tipos de parámetros de entrada, como en el ejemplo anterior, puede omitir declaraciones de tipo. Si necesita especificar el tipo de parámetros de entrada, debe especificar el tipo para cada parámetro, como se muestra en el ejemplo siguiente:

int[] numbers = { 4, 7, 10 };
int product = numbers.Aggregate(1, (int interim, int next) => interim * next);
Console.WriteLine(product);   // output: 280

En el ejemplo siguiente se muestra cómo definir una expresión lambda sin parámetros de entrada:

Func<string> greet = () => "Hello, World!";
Console.WriteLine(greet());

Para obtener más información, vea Expresiones lambda.

Definición del cuerpo de expresión

Una definición de cuerpo de expresión usa la siguiente sintaxis general:

member => expression;

Para un miembro que devuelve un valor, el resultado de la expresión debe convertirse implícitamente en el tipo de valor devuelto del miembro. Para un void miembro, constructor, finalizador o setdescriptor de acceso , init, addo remove , el cuerpo debe ser una expresión de instrucción. Una expresión de instrucción puede ser una asignación, invocación de método, creación de objetos, operación de incremento o decremento o await expresión. Su resultado, si existe, se descarta.

En el ejemplo siguiente se muestra una definición de cuerpo de expresión para un Person.ToString método :

public override string ToString() => $"{fname} {lname}".Trim();

Es una versión abreviada de la siguiente definición de método:

public override string ToString()
{
   return $"{fname} {lname}".Trim();
}

Puede usar definiciones de cuerpo de expresión para los miembros siguientes:

• Métodos y funciones locales: Un miembro que devuelve un valor tiene el formato T M() => expression;. Un void miembro tiene el formato void M() => statementExpression;. Para obtener más información, vea Métodos y funciones locales.
• Operadores: Un operador tiene el formato public static T operator +(T left, T right) => expression;. Para obtener más información, vea Sobrecarga de operadores.
• Propiedades e indizadores: Una propiedad o indexador de solo lectura tiene el formulario T P => expression; o T this[int i] => expression;. También puede usar cuerpos de expresión para descriptores de acceso individuales. Un get descriptor de acceso tiene el formato get => expression;. Un set descriptor de acceso o init tiene el formato set => statementExpression; o init => statementExpression;. Para obtener más información, vea Propiedades e indizadores.
• Constructores y finalizadores: Estos miembros tienen el formulario C() => statementExpression; o ~C() => statementExpression;. Para obtener más información, vea Constructores y finalizadores.
• Descriptores de acceso de eventos: Un add descriptor de acceso o remove tiene el formato add => statementExpression; o remove => statementExpression;. Para obtener más información, vea Eventos.

Posibilidad de sobrecarga del operador

No se puede sobrecargar el => operador.

Especificación del lenguaje C#

Para obtener más información sobre el operador lambda, vea la sección Expresiones de función anónimas de la especificación del lenguaje C#.

Consulte también

• Operadores y expresiones de C#