Expressão Lambda
Autor: Alexis Moura | Publicado: 2011-12-12T10:29:00-08:00




Expressão lambda é uma função ou sub-rotina sem um nome que pode ser usado sempre que um delegado é válido. As expressões lambda podem ser funções ou sub-rotinas e podem ser a única linha ou multilinha. Você pode passar valores do escopo atual para uma expressão lambda. [1]
Expressões lambda, uma das evoluções mais importantes da versão 3,0 do C# em que todo o suporte para LINQ [2] são apenas um recurso do mundo de programação funcional. Em LISP e seus dialetos, como Scheme, construção lambda é um mecanismo para a definição de funções. Por exemplo, a expressão:
LISP&nbsp; - (define Quadrado(lambda (x) (* xx)))
C# - Func &lt;int,int&gt; fatorial = x =&gt; x*x;
Quadrado define uma variável cujo valor é uma função que calcula o quadrado de seu argumento. neste contexto é uma característica muito importante para um desenvolvedor .NET , é que as funções lambda pode ser tratada não só como pedaços de código que podem ser invocados, as funções lambda facilitam a metaprogramming - escrever programas que podem manipular outros programas.
Condições que devem ser tidas em conta na definição de uma expressão lambda: 

As expressões lambda são definidas usando o operador lambda =&gt;. 
Para retornar o valor não usar a instrução return (a menos que o conteúdo da expressão lambda é um bloco entre chaves). 
Os tipos dos parâmetros das expressões lambda sempre inferida, como um delegado estará sempre associado com o uso da expressão lambda. Se em vez do tipo de um dos parâmetros, temos de dizer a todos, independentemente de eles pode-se inferir o tipo. 
Os parâmetros da expressão lambda não pode ser opcional, portanto, não podemos usar params. 
Os parâmetros não podem ser ref ou tipo fora. 
Não podemos especificar os parâmetros genéricos. 
Os nomes dos parâmetros não podem ser as mesmas que as de outros elementos que estão na mesma área. 
Os parâmetros de uma expressão lambda só são visíveis dentro dessa função. 
A expressão lambda que podemos usar para qualquer delegado, seja definido por nós ou conforme definido na NET.

O código abaixo mostra uma implementação de expressão lambda fazendo refletion esta classe implementa dois métodos :



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;


    /// &lt;summary&gt;
    ///  Principal
    /// &lt;/summary&gt;
    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 =&gt; x.id = 10);

            // recupera o valor 10 do id
            // Equivalente a: user.GetType().GetPropety("id").GetValue();
            var id = Refect.GetValue(user, x =&gt; x.id);
        }
    }

    /// &lt;summary&gt;
    ///  Classe de usuario
    ///  Objeto de teste
    /// &lt;/summary&gt;
    class User
    {
        /// &lt;summary&gt;
        ///  Codigo
        /// &lt;/summary&gt;
        public int id { get; set; }
    }

    /// &lt;summary&gt;
    ///  Classe que implementa metodos do refletion
    ///     Para expressão lambda
    /// &lt;/summary&gt;
    class Refect
    {
        /// &lt;summary&gt;
        ///  Delegate de expressão recursiva (tipo delegate genérico)
        ///  detalhes: 
        /// &lt;/summary&gt;
        /// &lt;typeparam name="T"&gt;tipo da expressão&lt;/typeparam&gt;
        /// &lt;param name="self"&gt;valor da expressão&lt;/param&gt;
        delegate T SelfApplicable&lt;T&gt;(SelfApplicable&lt;T&gt; self);
        
        /// &lt;summary&gt;
        ///  Retorna o valor do objeto
        /// &lt;/summary&gt;
        /// &lt;typeparam name="T"&gt;type do objeto&lt;/typeparam&gt;
        /// &lt;param name="model"&gt;objeto&lt;/param&gt;
        /// &lt;param name="expression"&gt;expression lambda&lt;/param&gt;
        /// &lt;returns&gt;object&lt;/returns&gt;
        public static object GetValue&lt;T&gt;(T model,Expression&lt;Func&lt;T, object&gt;&gt; expression)
        {
            SelfApplicable&lt;Func&lt;T, object&gt;&gt; myDelegate = x =&gt; expression.Compile();
            Func&lt;T, object&gt; Fix = myDelegate(myDelegate);
            return Fix(model);
        }

        /// &lt;summary&gt;
        ///  Seta o valor no objeto
        /// &lt;/summary&gt;
        /// &lt;typeparam name="T"&gt;type do objeto&lt;/typeparam&gt;
        /// &lt;param name="model"&gt;objeto&lt;/param&gt;
        /// &lt;param name="expression"&gt;expression lambda&lt;/param&gt;
        /// &lt;returns&gt;objeto&lt;/returns&gt;
        public static object SetValue&lt;T&gt;(T model, Func&lt;T, object&gt; expression)
        {
            SelfApplicable&lt;Func&lt;T, object&gt;&gt; myDelegate = x =&gt; expression;
            Func&lt;T, object&gt; Fix = myDelegate(myDelegate);
            return Fix(model);
        }
    }



Baixar projeto.

Espero que possa ter esclarecido um pouco do mundo escuro da expressão lambda ate mais.
Referências

http://msdn.microsoft.com/pt-br/library/bb531253.aspx
Hernández, Octavio "O que vai trazer Orcas: LINQ tecnologia", publicado em dotNetManía n º 25, abril de 2006.