Compreender as expressões Lambda e os delegados [fechado]

O delegado é um objeto que possui uma referência a uma função. Vários delegados diferentes podem apontar para a mesma função. Adelegate 's type defines the footprint of a function it may point to.

A expressão Lambda é uma função que não tem nome. A única maneira de executar esta função é ter um delegado apontando para a função. As expressões Lambda são normalmente definidas no local onde é necessário um delegado para uma função com uma dada pegada. Isto é útil para tornar o código menos descritivo e ao mesmo tempo mais descritivo e flexível

Outro ponto a considerar escrever uma função separada é a complexidade do Código. Não vai ajudar ninguém se escreveres um todo o programa dentro de uma expressão lambda.

Por outro lado, você muitas vezes precisa de algum processamento trivial que você quer ser executado de uma forma de callback. Este é o ponto onde você pode amar as expressões lambda.

O que é muito bom sobre as expressões lambda que eles herdam o escopo em que foram definidos, de modo que você pode facilmente suas variáveis dentro da expressão lambda, e, assim, passar um monte de informações dentro. Você deve ter cuidado no entanto, veja a seção Observações de Este artigo.

Para concluir, tenho de citar mais uma secção must-read msdn:

Quando você usa a sintaxe baseada em métodos para chamar o método de onde na classe enumerável (como você faz em LINQ para objetos e LINQ para XML) o parâmetro é um sistema de tipo delegado.Funcao. Uma expressão lambda é a maneira mais conveniente para criar esse delegado. Quando você chama o mesmo método em, por exemplo, o Sistema.Linq.Classe Queryable (como você faz em LINQ para SQL) então o tipo de parâmetro é um sistema.Linq.Expressao.Expressão onde o Func é qualquer delegado do Func com até dezesseis parâmetros de entrada. Mais uma vez, uma expressão lambda é apenas uma forma muito concisa de construir essa árvore de expressão. Os lambdas permitem que as chamadas de onde pareçam semelhantes, embora de fato o tipo de objeto criado a partir do lambda seja diferente.

public void Action(Func<int, int> func);
...
Action(delegate(int x) { return x*x; });

Que é apenas uma versão mais descritiva da sintaxe lambda:

Action(x => x*x);

Note também que a sintaxe lambda tem inferência tipo mais agressiva. Outra diferença é que a notação lambda pode ser usada para declarar árvores de expressão:

public void Action(Expression<Func<int, int>>);
Action(x => x*x);

Nesse caso, o que se obtém não é uma função, mas uma árvore de análise que se pode examinar em tempo de execução. Presente é como linq queries construir seu sql, por exemplo.

Editar

Para responder mais directamente à questão de quando usar uma ou outra:

Ao criar uma função 'on THE fly', não há vantagem em usar a sintaxe de delegado anónimo em vez da sintaxe lambda. Uma vez que a sintaxe lambda é mais concisa e tipo-inferido, preferi-lo.

O delegado é apenas um indicador para a função. É como uma "variável", onde você pode salvar o endereço para outra função que será chamada

    public class test {
    Action<int> CallUserCode;

    public test(Action<int> proc){
        CallUserCode = proc;
    }

    void foo(){
        int someValue = 0;
        //do some stuff that needs to call the user procedure
        CallUserCode(someValue);
    }
}

Lambda Expressions is too a delegate, which has simplified syntax and can "create" functions "inline". Assim, o exemplo anterior seria chamado usando lambda da seguinte forma.

void bar(){
    var t = new test(x => { /* do something with the value i get from foo */});
    t.foo();  //here function foo gets called, which will call 'do something' AND call my lambda expression
}

private delegate int emptymethoddel();
// Delegate for method with no params and returns int

O tipo de delegado-quadro equivalente é:: Func<int>

Mas não pode criar uma nova instância/func de delegado a partir do método parametrizado.

private int TwoArgMethod(int i, int j)
{
    return i + j;
}

Mas, com lambda, você pode obter delegado para o método acima.

Func<int> retmethod = () => TwoArgMethod(10, 20);

emptymethoddel retmethod4 = new emptymethoddel(TwoArgMethod(10,20)); 
// mismatch method signature

string mystring = SomeObject.GetMyString();
AnotherObject.OnSomeEvent += (eventparams => 
{
  string newstring = string.Format(eventparams.Message, mystring);
  SomeService.PrintEvent(newstring);
}

Desta forma, mystring é incorporado no delegado e pode ser usado como uma variável.