Esta documentación está archivada y no tiene mantenimiento.

Expresiones lambda (Guía de programación de C#)

Actualización: noviembre 2007

Una expresión lambda es una función anónima que puede contener expresiones e instrucciones y se puede utilizar para crear delegados o tipos de árboles de expresión.

Todas las expresiones lambda utilizan el operador lambda = >, que se lee como "va a". El lado izquierdo del operador lambda especifica los parámetros de entrada (si existe alguno), mientras que el lado derecho contiene el bloque de expresiones o instrucciones. La expresión lambda x => x * x se lee "x va a x veces x". Esta expresión se puede asignar a un tipo de delegado del siguiente modo:

delegate int del(int i);
del myDelegate = x => x * x;
int j = myDelegate(5); //j = 25

Para crear un tipo de árbol de expresión:

using System.Linq.Expressions;
// ...
Expression<del> = x => x * x;

El operador => tiene la misma prioridad que la asignación (=) y es asociativo por la derecha.

Las expresiones lambda se utilizan en consultas de LINQ basadas en métodos como argumentos para métodos de operador de consulta estándar, tales como Where y Where.

Cuando se utiliza la sintaxis de método para llamar al método Where en la clase Enumerable (como se hace en LINQ to Objects y LINQ to XML), el parámetro es un tipo delegado System.Func<T, TResult>. Una expresión lambda constituye la manera más práctica de crear ese delegado. Cuando se llama al mismo método en, por ejemplo, la clase System.Linq.Queryable (como se hace en LINQ to SQL), el tipo de parámetro es System.Linq.Expressions.Expression<Func>, donde Func es cualquier delegado de Func que tenga hasta cinco parámetros de entrada. De nuevo, una expresión lambda constituye una manera muy concisa de construir ese árbol de expresión. Las expresiones lambda permiten que las llamadas a Where tengan un aspecto similar, aunque, de hecho, el tipo de objeto creado desde la expresión lambda sea diferente.

En el ejemplo anterior, observe que la firma de delegado tiene un parámetro de entrada con tipo implícito int y devuelve un int. La expresión lambda se puede convertir en un delegado de ese tipo porque también tiene un parámetro de entrada (x) y un valor devuelto que el compilador puede convertir implícitamente al tipo int. (La inferencia de tipo se analiza con más detalle en las siguientes secciones.) Cuando el delegado se invoca utilizando un parámetro de entrada de 5, devuelve un resultado de 25.

Las expresiones lambda no se permiten en el lado izquierdo del operador is o as.

Todas las restricciones que se aplican a los métodos anónimos también se aplican a las expresiones lambda. Para obtener más información, vea Métodos anónimos (Guía de programación de C#).

Una expresión lambda con una expresión en el lado derecho se denomina lambda de expresión. Las lambdas de expresión se utilizan ampliamente en la construcción de Árboles de expresiones. Una lambda de expresión devuelve el resultado de la expresión y presenta la siguiente forma básica:

(input parameters) => expression

Los paréntesis sólo son opcionales si la lambda tiene un parámetro de entrada; de lo contrario, son obligatorios. Dos o más parámetros de entrada se separan por comas y se encierran entre paréntesis:

(x, y) => x == y

A veces, es difícil o imposible para el compilador deducir los tipos de entrada. Cuando esto ocurre, puede especificar los tipos explícitamente como se muestra en el ejemplo siguiente:

(int x, string s) => s.Length > x

Para especificar cero parámetros de entrada, utilice paréntesis vacíos:

() => SomeMethod()

Observe en el ejemplo anterior que el cuerpo de una lambda de expresión puede estar compuesto de una llamada a método. Sin embargo, si va a crear árboles de expresión que se utilizarán en otro dominio, como SQL Server, no debería utilizar llamadas a métodos en expresiones lambda. Los métodos no tendrán ningún significado fuera del contexto de .NET Common Language Runtime.

Una lambda de instrucciones es similar a un lambda de expresión, salvo que las instrucciones se encierran entre llaves:

(input parameters) => {statement;}

El cuerpo de una lambda de instrucciones puede estar compuesto de cualquier número de instrucciones; sin embargo, en la práctica, generalmente no hay más de dos o tres.

delegate void TestDelegate(string s);
…
TestDelegate myDel = n => { string s = n + " " + "World"; Console.WriteLine(s); };
myDel("Hello");

Las lambdas de instrucciones, como los métodos anónimos, no se pueden utilizar para crear árboles de expresión.

Muchos operadores de consulta estándar tienen un parámetro de entrada cuyo tipo es uno de la familia Func<T, TResult> de delegados genéricos. El delegado Func<T, TResult> usa parámetros de tipo para definir el número y tipo de parámetros de entrada, y el tipo de valor devuelto del delegado. Los delegados Func son muy útiles para encapsular expresiones definidas por el usuario que se aplican a cada elemento en un conjunto de datos de origen. Por ejemplo, considere el siguiente tipo delegado:

public delegate TResult Func<TArg0, TResult>(TArg0 arg0)

Se pueden crear instancias del delegado como Func<int,bool> myFunc, donde int es un parámetro de entrada y bool es el valor devuelto. El valor devuelto siempre se especifica en el último parámetro de tipo. Func<int, string, bool> define un delegado con dos parámetros de entrada, int y string, y un tipo de valor devuelto bool. El siguiente delegado Func, cuando se invoca, devolverá verdadero o falso para indicar si el parámetro de entrada es igual a 5:

    Func<int, bool> myFunc = x => x == 5;
    bool result = myFunc(4); // returns false of course

También puede proporcionar una expresión lambda cuando el tipo de argumento es Expression<Func>, por ejemplo, en los operadores de consulta estándar que se definen en System.Linq.Queryable. Al especificar un argumento Expression<Func>, la expresión lambda se compilará en un árbol de expresión.

A continuación, se muestra un operador de consulta estándar, el método Count:

    int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
    int oddNumbers = numbers.Count(n => n % 2 == 1);

El compilador puede deducir el tipo del parámetro de entrada, o también se puede especificar explícitamente. Esta expresión lambda particular cuenta aquellos enteros (n) que divididos por dos dan como resto 1.

El método siguiente generará una secuencia que contiene todos los elementos de la matriz de números que aparecen antes del "9", ya que ése es el primer número de la secuencia que no cumple la condición:

    var firstNumbersLessThan6 = numbers.TakeWhile(n => n < 6);

Este ejemplo muestra cómo especificar varios parámetros de entrada encerrándolos entre paréntesis. El método devuelve todos los elementos de la matriz de números hasta encontrar un número cuyo valor sea menor que su posición. No confunda el operador lambda (=>) con el operador mayor o igual que (>=).

    var firstSmallNumbers = numbers.TakeWhile((n, index) => n >= index);

Al escribir expresiones lambda, no tiene por qué especificar un tipo para los parámetros de entrada, ya que el compilador puede deducir el tipo según el cuerpo de la lambda, el tipo de delegado subyacente y otros factores que se describen en la especificación del lenguaje C# 3.0. Para la mayoría de los operadores de consulta estándar, la primera entrada es el tipo de los elementos en la secuencia de origen. Así, si está realizando una consulta sobre un IEnumerable<Customer>, se deducirá que la variable de entrada será un objeto Customer, lo cual significa que se podrá tener acceso a sus métodos y propiedades:

customers.Where(c => c.City == "London");

Las reglas generales para las expresiones lambda son las siguientes:

  • La lambda debe contener el mismo número de parámetros que el tipo delegado.

  • Cada parámetro de entrada en la lambda se debe poder convertir implícitamente a su parámetro de delegado correspondiente.

  • El valor devuelto de la lambda (si existe) se debe poder convertir implícitamente al tipo de valor devuelto del delegado.

Observe que las expresiones lambda, en sí mismas, no tienen tipo, ya que el sistema de tipos comunes no tiene ningún concepto intrínseco de "expresión lambda". Sin embargo, a veces resulta práctico hablar informalmente del "tipo" de una expresión lambda. En estos casos, el tipo hace referencia al tipo del delegado o el tipo de Expression en el que se convierte la expresión lambda.

Las expresiones lambda pueden hacer referencia a variables externas que se encuentran dentro del ámbito del método o tipo que las engloba y en el cual se definen. Las variables que se capturan de esta manera se almacenan para su uso en la expresión lambda, cuando de otro modo quedarían fuera de ámbito y serían eliminadas por el recolector de elementos no utilizados. Para poder utilizar una variable externa en una expresión lambda, debe estar previamente asignada. En el ejemplo siguiente se muestran estas reglas.

delegate bool D();
    delegate bool D2(int i);

    class Test
    {
        D del;
        D2 del2;
        public void TestMethod(int input)
        {
            int j = 0;
            // Initialize the delegates with lambda expressions.
            // Note access to 2 outer variables.
            // del will be invoked within this method.
            del = () => { j = 10;  return j > input; };

            // del2 will be invoked after TestMethod goes out of scope.
            del2 = (x) => {return x == j; };
            
            // Demonstrate value of j:
            // Output: j = 0 
            // The delegate has not been invoked yet.
            Console.WriteLine("j = {0}", j);

            // Invoke the delegate.
            bool boolResult = del();

            // Output: j = 10 b = True
            Console.WriteLine("j = {0}. b = {1}", j, boolResult);
        }

        static void Main()
        {
            Test test = new Test();
            test.TestMethod(5);

            // Prove that del2 still has a copy of
            // local variable j from TestMethod.
            bool result = test.del2(10);

            // Output: True
            Console.WriteLine(result);
            
            Console.ReadKey();
        }
    }

Las reglas siguientes se aplican al ámbito de variables en expresiones lambda:

  • Una variable que se captura no será eliminada por el recolector de elementos no utilizados hasta que el delegado que hace referencia a ella quede fuera del ámbito.

  • Las variables introducidas dentro de una expresión lambda no son visibles en el método externo.

  • Una expresión lambda no puede capturar directamente un parámetro ref o out desde un método que la englobe.

  • Una instrucción return en una expresión lambda no hace que el método que la engloba vuelva.

  • Una expresión lambda no puede contener una instrucción goto, una instrucción break o una instrucción continue cuyo destino esté fuera del cuerpo o en el cuerpo de una función anónima contenida.

Para obtener más información, vea la siguiente sección de Especificación del lenguaje C#.

  • 5.3.3.29 Funciones anónimas

Mostrar: