Las expresiones lambda son una sintaxis más simple para delegados anónimos y se pueden usar en todas partes donde se puede usar un delegado anónimo. Sin embargo, lo contrario no es cierto; Las expresiones lambda se pueden convertir en árboles de expresión, lo que permite mucha magia como LINQ to SQL.
El siguiente es un ejemplo de una expresión LINQ to Objects que utiliza delegados anónimos y luego expresiones lambda para mostrar qué tan fáciles de ver son:
// anonymous delegate
var evens = Enumerable
.Range(1, 100)
.Where(delegate(int x) { return (x % 2) == 0; })
.ToList();
// lambda expression
var evens = Enumerable
.Range(1, 100)
.Where(x => (x % 2) == 0)
.ToList();
Las expresiones Lambda y los delegados anónimos tienen una ventaja sobre escribir una función separada: implementan cierres que pueden permitirle pasar el estado local a la función sin agregar parámetros a la función o crear objetos de un solo uso.
Los árboles de expresión son una nueva característica muy poderosa de C # 3.0 que permite que una API mire la estructura de una expresión en lugar de simplemente obtener una referencia a un método que se puede ejecutar. Una API solo tiene que convertir un parámetro delegado en un Expression<T>
parámetro y el compilador generará un árbol de expresión a partir de una lambda en lugar de un delegado anónimo:
void Example(Predicate<int> aDelegate);
llamado como:
Example(x => x > 5);
se convierte en:
void Example(Expression<Predicate<int>> expressionTree);
A este último se le pasará una representación del árbol de sintaxis abstracta que describe la expresión x > 5
. LINQ to SQL se basa en este comportamiento para poder convertir expresiones C # en las expresiones SQL deseadas para el filtrado / pedido / etc. en el lado del servidor.
delegate
hay en C #, les recomiendo leer esto antes de leer el resto de esta página: stackoverflow.com/questions/2082615/…