a definicao de funcoes. Por exemplo, a expressao:LISP - (define Quadrado(lambda (x) (* xx)))C# - Func <int,int> fatorial = x => x*x;Quadrado define uma variavel cujo valor e uma funcao que calcula o quadrado de seu argumento. neste contexto e uma caracteristica muito importante para um desenvolvedor .NET , e que as funcoes lambda pode ser tratada nao so como pedacos de codigo que podem ser invocados, as funcoes lambda facilitam a metaprogramming - escrever programas que podem manipular outros programas.Condicoes que devem ser tidas em conta na definicao de uma expressao lambda: As expressoes lambda sao definidas usando o operador lambda =>. Para retornar o valor nao usar a instrucao return (a menos que o conteudo da expressao lambda e um bloco entre chaves). Os tipos dos parametros das expressoes lambda sempre inferida, como um delegado estara sempre associado com o uso da expressao lambda. Se em vez do tipo de um dos parametros, temos de dizer a todos, independentemente de eles pode-se inferir o tipo. Os parametros da expressao lambda nao pode ser opcional, portanto, nao podemos usar params. Os parametros nao podem ser ref ou tipo fora. Nao podemos especificar os parametros genericos. Os nomes dos parametros nao podem ser as mesmas que as de outros elementos que estao na mesma area. Os parametros de uma expressao lambda so sao visiveis dentro dessa funcao. A expressao lambda que podemos usar para qualquer delegado, seja definido por nos ou conforme definido na NET.O codigo abaixo mostra uma implementacao de expressao lambda fazendo refletion esta classe implementa dois metodos :using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Linq.Expressions; /// <summary> /// Principal /// </summary> class Program { static void Main(string[] args) { // Vamos instanciar a class User user = new User(); // Seta o valor 10 no id // Equivalente a: user.GetType().GetPropety("id").SetValue(user,10); Refect.SetValue(user, x => x.id = 10); // recupera o valor 10 do id // Equivalente a: user.GetType().GetPropety("id").GetValue(); var id = Refect.GetValue(user, x => x.id); } } /// <summary> /// Classe de usuario /// Objeto de teste /// </summary> class User { /// <summary> /// Codigo /// </summary> public int id { get; set; } } /// <summary> /// Classe que implementa metodos do refletion /// Para expressao lambda /// </summary> class Refect { /// <summary> /// Delegate de expressao recursiva (tipo delegate generico) /// detalhes: /// </summary> /// <typeparam name="T">tipo da expressao</typeparam> /// <param name="self">valor da expressao</param> delegate T SelfApplicable<T>(SelfApplicable<T> self); /// <summary> /// Retorna o valor do objeto /// </summary> /// <typeparam name="T">type do objeto</typeparam> /// <param name="model">objeto</param> /// <param name="expression">expression lambda</param> /// <returns>object</returns> public static object GetValue<T>(T model,Expression<Func<T, object>> expression) { SelfApplicable<Func<T, object>> myDelegate = x => expression.Compile(); Func<T, object> Fix = myDelegate(myDelegate); return Fix(model); } /// <summary> /// Seta o valor no objeto /// </summary> /// <typeparam name="T">type do objeto</typeparam> /// <param name="model">objeto</param> /// <param name="expression">expression lambda</param> /// <returns>objeto</returns> public static object SetValue<T>(T model, Func<T, object> expression) { SelfApplicable<Func<T, object>> myDelegate = x => expression; Func<T, object> Fix = myDelegate(myDelegate); return Fix(model); } }Baixar projeto.Espero que possa ter esclarecido um pouco do mundo escuro da expressao lambda ate