Delegados e lambdas
Um delegado define um tipo que representa referências a métodos que têm uma lista de parâmetros específica e um tipo de retorno. Um método (estático ou instância) cuja lista de parâmetros e correspondência de tipo de retorno pode ser atribuído a uma variável desse tipo, então chamado diretamente (com os argumentos apropriados) ou passado como um argumento próprio para outro método e, em seguida, chamado. O exemplo a seguir demonstra o uso do delegado.
using System;
using System.Linq;
public class Program
{
public delegate string Reverse(string s);
static string ReverseString(string s)
{
return new string(s.Reverse().ToArray());
}
static void Main(string[] args)
{
Reverse rev = ReverseString;
Console.WriteLine(rev("a string"));
}
}
- A
public delegate string Reverse(string s);linha cria um tipo de delegado de um método que usa um parâmetro string e, em seguida, retorna um parâmetro string. - O
static string ReverseString(string s)método, que tem exatamente a mesma lista de parâmetros e tipo de retorno que o tipo de delegado definido, implementa o delegado. - A
Reverse rev = ReverseString;linha mostra que você pode atribuir um método a uma variável do tipo de delegado correspondente. - A
Console.WriteLine(rev("a string"));linha demonstra como usar uma variável de um tipo de delegado para invocar o delegado.
Para simplificar o processo de desenvolvimento, o .NET inclui um conjunto de tipos delegados que os programadores podem reutilizar e não precisam criar novos tipos. Esses tipos são Func<>, Action<> e Predicate<>, e podem ser usados sem ter que definir novos tipos de delegados. Existem algumas diferenças entre os três tipos que têm a ver com a forma como foram concebidos para serem utilizados:
Action<>é usado quando há necessidade de executar uma ação usando os argumentos do delegado. O método que ele encapsula não retorna um valor.Func<>é usado geralmente quando você tem uma transformação em mãos, ou seja, você precisa transformar os argumentos do delegado em um resultado diferente. As projeções são um bom exemplo. O método que ele encapsula retorna um valor especificado.Predicate<>é usado quando você precisa determinar se o argumento satisfaz a condição do delegado. Ele também pode ser escrito como umFunc<T, bool>, o que significa que o método retorna um valor booleano.
Agora podemos pegar nosso exemplo acima e reescrevê-lo usando o Func<> delegado em vez de um tipo personalizado. O programa continuará funcionando exatamente da mesma forma.
using System;
using System.Linq;
public class Program
{
static string ReverseString(string s)
{
return new string(s.Reverse().ToArray());
}
static void Main(string[] args)
{
Func<string, string> rev = ReverseString;
Console.WriteLine(rev("a string"));
}
}
Para este exemplo simples, ter um método definido fora do método parece um pouco supérfluo Main . O .NET Framework 2.0 introduziu o conceito de delegados anônimos, que permitem criar delegados "embutidos" sem precisar especificar nenhum tipo ou método adicional.
No exemplo a seguir, um delegado anônimo filtra uma lista apenas para os números pares e, em seguida, imprime-os no console.
using System;
using System.Collections.Generic;
public class Program
{
public static void Main(string[] args)
{
List<int> list = new List<int>();
for (int i = 1; i <= 100; i++)
{
list.Add(i);
}
List<int> result = list.FindAll(
delegate (int no)
{
return (no % 2 == 0);
}
);
foreach (var item in result)
{
Console.WriteLine(item);
}
}
}
Como você pode ver, o corpo do delegado é apenas um conjunto de expressões, como qualquer outro delegado. Mas, em vez de ser uma definição separada, introduzimo-la ad hoc na nossa chamada ao List<T>.FindAll método.
No entanto, mesmo com esta abordagem, ainda há muito código que podemos deitar fora. É aqui que as expressões lambda entram em jogo. As expressões lambda, ou apenas "lambdas", foram introduzidas no C# 3.0 como um dos principais blocos de construção do Language Integrated Query (LINQ). Eles são apenas uma sintaxe mais conveniente para usar delegados. Eles declaram uma lista de parâmetros e um corpo de método, mas não têm uma identidade formal própria, a menos que sejam atribuídos a um delegado. Ao contrário dos delegados, eles podem ser atribuídos diretamente como o lado direito do registro do evento ou em várias cláusulas e métodos LINQ.
Como uma expressão lambda é apenas outra maneira de especificar um delegado, devemos ser capazes de reescrever o exemplo acima para usar uma expressão lambda em vez de um delegado anônimo.
using System;
using System.Collections.Generic;
public class Program
{
public static void Main(string[] args)
{
List<int> list = new List<int>();
for (int i = 1; i <= 100; i++)
{
list.Add(i);
}
List<int> result = list.FindAll(i => i % 2 == 0);
foreach (var item in result)
{
Console.WriteLine(item);
}
}
}
No exemplo anterior, a expressão lambda usada é i => i % 2 == 0. Mais uma vez, é apenas uma sintaxe conveniente para usar delegados. O que acontece debaixo das capas é semelhante ao que acontece com o delegado anónimo.
Novamente, lambdas são apenas delegados, o que significa que eles podem ser usados como um manipulador de eventos sem problemas, como ilustra o trecho de código a seguir.
public MainWindow()
{
InitializeComponent();
Loaded += (o, e) =>
{
this.Title = "Loaded";
};
}
Neste contexto, o += operador é utilizado para subscrever um evento. Para obter mais informações, consulte Como se inscrever e cancelar a assinatura de eventos.
