Las expresiones Lambda son funciones anónimas no especificadas que crean delegados o árboles de expresión. Es una forma rápida y sencilla de definir delegados.
Las expresiones Lambda son métodos sin modificadores de acceso similares a declaraciones. Logrando que nuestro código sea más compacto, reduciendo líneas de código y facilitando mantenimiento y reutilización.
Con las expresiones Lambda podemos escribir nuestros métodos en el mismo lugar donde los vamos a usar.
Las expresiones lambdas son fundamentales en las consultas LINQ basadas en métodos que se pueden alimentar en los métodos de operador de consulta estándar como el WHERE.
La estructura básica es: Parámetros => Código ejecutado
Os pongo dos ejemplo muy sencillos:
Ejemplo 1:
using System;
namespace lambdaexpression
{
class Program
{
delegate int Del(int i);
static void Main(string[] args)
{
Del myDelegate = x => x * x;
int resultVariable = myDelegate(8);
}
}
}Ejemplo 2:
using System;
using System.Collections.Generic;
namespace lambdaexpression
{
class Program
{
static void Main(string[] args)
{
List<string> names = new List<string>();
names.Add("Hola");
names.Add("Hello");
names.Add("Hallo");
string resultString = names.Find(name => name.Equals("Hola"));
}
}
}Y sin embargo los árboles de expresión son estructuras de datos que contienen expresiones como las expresiones Lambda.
En esencia, los árboles de expresiones son piezas de código que tienen una estructura de árbol donde cada nodo puedes usarlo para ejecutar expresiones lambda. Son como un árbol binario.
Los árboles de expresión nos dan la capacidad de traducir el código ejecutable en datos, es decir cambios dinámicos en código. Por ejemplo, puede cambiar la expresión de una WHERE de LINQ para que funcione en otra entidad de base de datos SQL.
Ejemplo 1:
using System;
using System.Linq.Expressions;
namespace treeexpression
{
internal class Program
{
private static void Main(string[] args)
{
var numParam = Expression.Parameter(typeof(int), "num");
var five = Expression.Constant(5, typeof(int));
var numLessThanFive = Expression.LessThan(numParam, five);
var lambda1 =
Expression.Lambda<Func<int, bool>>(
numLessThanFive, numParam);
}
}
}Ejemplo 2:
using System;
using System.Collections.Generic;
using System.Linq;
namespace treeexpression
{
internal class Program
{
private static void Main(string[] args)
{
var companyNames = new[]
{
"Company A", "Company B", "Company C",
"Company D", "Company E"
};
var companyNamesSource = companyNames.AsQueryable();
var fixedQry = companyNames.OrderBy(x => x);
}
}
}
Y aquí es donde Visual Studio 2019 nos ofrece una herramienta visual, que es una gran desconocida y nos puede ayudar con nuestro productividad:
Y si no terminas por aclararte, existe un proyecto en GitHub: ExpressionTreeVisualizer, que nos lo pone aun más fácil, incluso puedes editar expresiones en el.
O esta otra extensión del MarketPlace: ReadableExpressionsVisualizers
