Creo que somos muchos (me incluyo) los que usamos las expresiones lambda por inercia y sin saber de dónde salen y cómo sarles su jugo.
Recordemos que una expresión lambda es algo así:
Ctx.articulos.where(art=>art.codigo==’40’)
Pues bien, las expresiones lambda no son más que funciones empaquetadas como un parámetro de una función.
En este ejemplo estamos diciendo que del ienumerable artículos, por cada artículo, devuelva una lista con los elementos que la ejecución de la función "art.codigo=='40'" sea True.
¿De dónde salen las expresiones lambda?
Seguro que este caso os es muy familiar:
static void main()
{
int resultado=multiplica(5,2); // ejecutamos la función
}
static int multiplica(int a,
int b)
{
return
a * b;
}
Pues bien, compliquemos un poco esto.
Un delegado es un puntero a una función; es decir, a una
variable de tipo “delegado” le asignamos una función.
El delegado debe de tener los mismos parámetros tanto de entrada como de
retorno.
Vamos a usar un delegado para llamar a la función “multiplica”.
delegate int miDelegado(int a, int b); //declaramos el delegado
static void main()
{
miDelegado deleg = multiplica; // asignamos la
función al delegado
int resultado = deleg(5, 2); // ejecutamos el
delegado
}
static int multiplica(int a,
int b)
{
return
a * b;
}
Podemos simplificar un poco esta función llamando a Func<>,
que es una nueva forma genérica de crear delegados. (apareció en el
Framework 3.5)
static void main()
{
Func<int,int,int> miMetodo
= multiplica; //
asignamos la función al delegado
int resultado = miMetodo(5, 2); // ejecutamos el
delegado
}
static int multiplica(int a,
int b)
{
return
a * b;
}
En la función Func<int,int,int>, el 1er y el 2º int corresponden a los parámetros de entrada de la función Multiplica, y el último int es la variable de retorno.
Ahora declaremos la función dentro del método Main
static void main()
{
Func<int, int, int> miMetodo = delegate(int a, int b) { return a * b; };
int resultado = miMetodo(5, 2); // ejecutamos el
delegado
}
Esto se puede traducir a una expresión lambda.
static void main()
{
Func<int, int, int> miMetodo = (a, b)=> { return a * b; };
int resultado = miMetodo(5, 2); // ejecutamos el
delegado
}
Y como el cuerpo de la función es sencillo, podríamos
incluso resumirlo de esta manera:
static void main()
{
Func<int, int, int> miMetodo = (a, b)=> a * b ;
int resultado = miMetodo(5, 2); // ejecutamos el
delegado
}
Uso de expresiones lambda
Expresiones lambda como parámetros
En este ejemplo tenemos 4 funciones de operaciones básicas,
y en la función “opera” le pasamos una expresión lambda como parámetro, tanto
declarada como “al vuelo”
static void main()
{
Func<int, int, int> suma = (x, y) => x + y;
Func<int, int, int> rest = (x, y) => x - y;
Func<int, int, int> mult = (x, y) => x * y;
Func<int, int, int> divi = (x, y) => x / y;
int
result=opera(5, 2, mult);
int result2=opera(5, 2, (x,y)=>x*y);
}
static int opera(int x, int y, Func<int, int, int> operacion)
{
return operacion(x, y);
}
Otro ejemplo: contamos y obtenemos los múltipos de 3
static void main()
{
int[]
numeros = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
int
divisiblesx3 = numeros.Count(x =>x % 3 == 0);
IEnumerable<int> lista =
numeros.Where(x => x % 3 == 0);
}
Aquí fijémonos en el intellisense de la función Count.
Nos dice que devuelve un entero, que Count cuelga de un
IEnumerable<int> (array números) y que admite una función que probará
cada elemento. Esta función admite un int y devuelve un bool, que si cumple la
condición, será un count acertado.
El where lo mismo; nos devolverá una lista con los múltiplos
de 3.
Expresión lambda de una función sin parámetros de entrada
Aunque no hayan parámetros de entrada, debemos de poner los
paréntesis.
static void main()
{
Func<string> saludo= () => string.Format("Hola");
string result = saludo();
}
Expresión
lambda de una function compleja
En este ejemplo, vemos
cómo la función no debe de ser una simple operación, sino que puede ser de
cualquier tamaño
static void main()
{
Func<string> ObtieneNombre = () =>
{
Console.WriteLine("Dime tu nombre");
string nombre = Console.ReadLine();
return
nombre;
};
Console.WriteLine("Hola,
" + ObtieneNombre());
}
Expresión
lambda de una función que no devuelve datos
Para este caso, sustituyamos
la instrucción “func” por “action”
static void main()
{
Action
Saludo = () =>
{
Console.WriteLine("Dime tu nombre");
string nombre = Console.ReadLine();
Console.WriteLine("Hola, " + nombre);
};
Saludo();
}
Espero que este artículo os ayude a que entendáis un poco más las expresiones lambda
Enlaces
Expresiones lambda
http://msdn.microsoft.com/es-es/library/bb397687.aspx
Libro C# 3.0 y LINQ, de Octavio Hernández.
http://www.campusmvp.com/catalogo/Product-C-3.0-y-LINQ_1.aspx
