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 pode ter uma ou varias funções. 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# alem do LINQ [2] são apenas um recurso do mundo de programação funcional. Abaixo um exemplo de expressão usada no LISP e  C#:

LISP  – (define Quadrado(lambda (x) (* xx)))

C# – Func <int,int> fatorial = x => 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.

Para definir uma expressão lambda :

  • As expressões lambda são definidas usando o operador lambda =>.
  • 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;

    /// <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 expressão lambda
    /// </summary>
    class Refect
    {
        /// <summary>
        /// Delegate de expressão recursiva (tipo delegate genérico)
        /// detalhes: 
        /// </summary>
        /// <typeparam name="T">tipo da expressão</typeparam>
        /// <param name="self">valor da expressão</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 expressão lambda ate mais.

Referências

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