Delegados e lambdas

  • Artigo

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 um Func<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.

Outras leituras e recursos