Delegados e lambdas

  • Artigo

Um delegado define um tipo que representa referências aos métodos que têm uma lista de parâmetros e um tipo de retorno específicos. Um método (estático ou instância) cuja correspondência de lista de parâmetros e tipo de retorno podem ser atribuídos a uma variável desse tipo, então chamado diretamente (com os argumentos adequados) ou passado como um argumento para outro método e, então, chamado. O exemplo a seguir demonstra o uso de um 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 linha public delegate string Reverse(string s); cria um tipo de delegado de um método que usa um parâmetro de cadeia de caracteres e retorna um parâmetro de cadeia de caracteres.
  • O método static string ReverseString(string s), que tem exatamente a mesma lista de parâmetros e tipo de retorno que o tipo de delegado definido, implementa o delegado.
  • A linha Reverse rev = ReverseString; mostra que você pode atribuir um método a uma variável do tipo de delegado correspondente.
  • A linha Console.WriteLine(rev("a string")); 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 de delegados que os programadores podem reutilizar, sem precisar criar novos tipos. Esses tipos são Func<>, Action<> e Predicate<>, e podem ser usados em vários locais das APIs .NET sem a necessidade de definir novos tipos de delegado. Há algumas diferenças entre os três tipos que têm a ver com a maneira como eles devem ser usados:

  • Action<> é usado quando é necessário executar uma ação usando os argumentos do delegado. O método que ele encapsula não retorna um valor.
  • Func<> é normalmente é usado quando você tem uma transformação à mão, ou seja, quando é necessário transformar os argumentos do delegado em um resultado diferente. 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 booliano.

Agora, podemos pegar nosso exemplo acima e reescrevê-lo usando o delegado Func<> em vez de um tipo personalizado. O programa continuará sendo executado 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 Main parece um pouco supérfluo. O .NET Framework 2.0 introduziu o conceito de representantes anônimos, que permitem criar delegados "embutidos" sem necessidade de 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 os imprime 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 aconteceria com qualquer outro delegado. Mas em vez de ele ser uma definição separada, nós o introduzimos ad hoc em nossa chamada ao método List<T>.FindAll.

No entanto, mesmo com essa abordagem, ainda há muito código que podemos descartar. É aí que as expressões lambda entram em cena. As expressões lambda ou apenas "lambdas" para abreviar, foram introduzidas no C# 3.0 como um dos principais elementos de construção da LINQ (Consulta integrada à linguagem). Elas são apenas uma sintaxe mais conveniente para usar delegados. Elas declaram uma lista de parâmetros e um corpo do método, mas não têm uma identidade formal própria, a menos que sejam atribuídas a um delegado. Ao contrário dos representantes, elas podem ser atribuídas diretamente como o lado direito do registro de eventos ou em várias cláusulas e métodos LINQ.

Como uma expressão lambda é apenas outra maneira de especificar um delegado, nós podemos 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 nos bastidores é semelhante ao que acontece com o delegado anônimo.

Novamente, as lambdas são apenas delegados, o que significa que podem ser usadas como um manipulador de eventos sem problemas, como o snippet de código a seguir ilustra.

public MainWindow()
{
    InitializeComponent();

    Loaded += (o, e) =>
    {
        this.Title = "Loaded";
    };
}

O operador += nesse contexto é usado para assinar um evento. Para obter mais informações, confira Como assinar e cancelar a assinatura de eventos.

Recursos e leituras adicionais