Apresentação utilizada para a apresentação do InfoTech2012 onde apresentamos a utilização de lambda e os benefícios de sua utilização.

1. LAMBDA
EXPRESSIONS
Charles Fortes | Marcus Coelho
17 de Maio de 2012
@CharlesFortes

2. EXPRESSÕES LAMBDA

3. Uma expressão lambda é em sua
essência uma função anônima.
Estas funções anônimas são geralmente
passadas como argumentos para outras funções
de mais auto nível...

4. acessar
...por característica, podem
variáveis no escopo da função na
qual ela está declarada

5. FacaAlgo(item)
{
return ++item;
}
MinhaList.ForEach(item => {
var result = FacaAlgo(item);
if (result > 5)
FacaOutraCoisa();
});
FacaAlgo(item)
{
MessageBox.Show(item);
}
MinhaList.ForEach(item => FacaAlgo);

6. Suporte a Lambda Expressions nas Linguagens:

7. LAMBDA NO .NET

8. No .Net, todas as expressões lambda usam o operador
"=>" (que se lê "vai para" segundo a documentação oficial)
Func<int, bool> myFunc = x => x == 5;
bool result = myFunc(4); //retorna falso
O lado esquerdo da expressão contem os
parâmetros de entrada, enquanto o lado direito
possui a expressão ou bloco de instruções

9. O uso mais comum são em métodos de consultas
LINQ
var result = minhaListaDeClientes
.Where(cliente => cliente.Endereco.Estado == Estados.Acre)
.select(cliente => cliente.Nome);
retorna uma lista de strings com o nome de
todos os clientes do acre

10. public void Teste()
public void Teste()
{
{
public void Teste()
{ string[] nomes = { "Joao", ... };
string[] nomes = { "Joao", ... };
{
string filtro =="J";
string[] nomes { "Joao", ... };
string[] nomes = { "Joao", ... };
var resultado = nomes.Where(
var (string nome)!= null
resultado(string nome)
delegate = nomes.Where(Filtro);
=
nome => nomenomes.Where(
=>
var resultado
} { && nome.StartsWith(filtro)
nome => nome != null
); return nome.StartsWith("J")
&& nome != null
delegate (string nome)
public bool Filtro(string nome)
} ); && nome.StartsWith("J");
{
} }
return nome != null
);
} void Teste()&& nome.StartsWith("J");
public
}

11. Muitos métodos do .NET Framework pedem como
parâmetro um delegate, ou seja, um objeto
que poderá chamar indiretamente um
outro método, sem conhecê-lo.
O método “Where”, por exemplo, está disponível para todas as coleções
do .NET e recebe como parâmetro um método que será utilizado
internamente para avaliar cada item da coleção e verificar se
cada item atende a um critério especificado.

12. public void Teste()
{
string[] nomes = { "Joao", ... };
var resultado = nomes.Where(Filtro);
}
public bool Filtro(string nome)
{
return nome != null
&& nome.StartsWith("J");
}
“Where” utilizará o método “Filtro” para
No exemplo acima, o método
cada item da coleção “nomes”, verificando se o item atende a uma
condição específica, no caso, se o nome começa com a letra “J”.

13. No framework 2.0 foram criados os métodos anônimos,
que poderiam ser declarados dentro de outros
métodos, como se fossem variáveis.

14. O método anônimo em comparação a um método convencional:
•não tem modificador de acessibilidade (public, private) ou nome
(daí o nome “anônimo”)
•deve ser utilizado somente dentro de outros métodos ou variáveis
de escopo de classe;
•utiliza a palavra reservada “delegate”.

15. public void Teste()
{
string[] nomes = { "Joao", ... };
var resultado = nomes.Where(Filtro);
}
delegate (string nome)
{
return nome != null
&& nome.StartsWith("J");
}

16. public void Teste()
{
string[] nomes = { "Joao", ... };
var resultado = nomes.Where(delegate (string
nome)
{
return nome != null
&& nome.StartsWith("J");
});
}
Podemos utilizar o método anônimo direto na
chamada do método “Where”.

17. Para transformar um método anônimo em uma lambda
expression, basta somente remover a palavra “delegate” e
utilizar o símbolo “=>” entre os parâmetros de método, e o
corpo.
public void Teste()
{
string[] nomes = { "Joao", ... };
var resultado = nomes.Where((string nome) =>
{
return nome != null
&& nome.StartsWith("J");
});
}

18. public void Teste()
{
string[] nomes = { "Joao", ... };
var resultado = nomes.Where(nome =>
{
return nome != null
&& nome.StartsWith("J");
});
}
Você pode omitir os tipos dos parâmetros nas
lambdas expression, deixando somente o nome
deste. Quando há somente um único
parâmetro, os parênteses também são
opcionais.

19. Quando sua lambda expression possui somente uma linha que
retorna o resultado do método, você pode omitir também as
chaves, a palavra reservada “return” e o ponto-e-vírgula que finaliza
a linha de comando.

20. public void Teste()
{
string[] nomes = { "Joao", ... };
var resultado = nomes
.Where(nome => nome != null
&& nome.StartsWith("J"));
}

21. Lambdas expressions podem possuir
nenhum ou vários parâmetros...
 x => x > 3;
 (x, y) => x + y;
 () => 1;
...e para que executem mais de um
comando, basta colocá-los entre chaves
 x => {
x++;
return x;
}

22. Um exemplo de uso para a lambda expression é a
utilização para tratar eventos de controles:
public void Teste()
{
buttonSalvar.Click += (obj, args) =>
labelMensagem = "Registro salvo com
sucesso";
}

23. Vantagens ao usar

24. Ao se usar uma lambda expression, seu código
mais legível, menor, mais auto-explicativo...

25. Além disto, obtem-se mais desempenho pois são feitas
otimizações pelo compilador

26. Vamos fazer um teste simples
checar se um item pertence a lista, se pertencer
adiciona em uma segunda lista através de um
método
Há várias formas de fazer isto - inclusive de
forma melhor - mas escolhemos a que
achamos ser simples de ser compreendida
por todos, e ilustrasse a ideia

27. Método chamado caso o item exista na lista:
static long add(List<long>dest, long i)
{
dest.Add(i);
return i;
}

28. Fazendo a mesma coisa de várias formas
for (var i = 0; i < listaA.Count; i++ )
{
if (listaB.Contains(listaA[i])) add(dest, listaA[i]);
}
foreach (var t in listaA)
{
if (listaB.Contains(t)) add(dest, t);
}
listaA.Where(t => listaB.Contains(t)).Select(t => add(dest, t));
var x = (from t in listaA
where listaB.Contains(t)
select add(dest, t)).ToList();

29. Tempo gasto

30. EXPRESSÕES
DINÂMICAS

31. Através da classe Expression podemos criar
lambda expressions dinamicamente.
Classes específicas representam cada parte da
expressão.

32. c => c.Codigo == 1
<LambdaExpression>
c c.Codigo == 1
<ParameterExpression> <BinaryExpression>
c.Codigo 1
<MemberExpression> <ConstantExpression>

33. PERGUNTAS?

34. @CharlesFortes