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...
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";
}
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();