Explorando delegados e lambdas

Usando expressões lambda com delegate

As expressões lambda podem ser atribuídas diretamente a objetos delegate. Exemplo:

O que é um delegate?

Um delegate é um tipo que armazena referências a métodos com uma assinatura específica. Os objetos delegate permitem que métodos sejam passados como parâmetros ou atribuídos dinamicamente.

Exemplo: os objetos delegate são frequentemente usados para retornos de chamada e tratamento de eventos.

Definindo e usando objetos delegate

Você pode definir um delegate usando a palavra-chave delegate. Exemplo:

Ponto principal: os objetos delegate oferecem uma forma de encapsular métodos.

using System;

class Program {
    // Define a delegate
    public delegate void PrintDelegate(string message);

    static void Main() {
        PrintDelegate print = PrintMessage; // Assign method to delegate
        print("Hello, Delegates!"); // Call the method via the delegate
    }

    static void PrintMessage(string message) {
        Console.WriteLine(message);
    }
}

O que é uma expressão lambda?

Uma expressão lambda é uma forma concisa de representar um método anônimo em C#. Ela usa a sintaxe (parameters) => expression.

Exemplo: (x, y) => x + y representa um método que soma dois números.

Dica: as expressões lambda são frequentemente usadas com LINQ e objetos delegate para obter concisão e clareza.

Usando expressões lambda com delegate

As expressões lambda podem ser atribuídas diretamente a objetos delegate. Exemplo:

Ponto principal: as expressões lambda tornam seu código mais conciso e legível.

using System;

class Program {
    public delegate int MathOperation(int x, int y);

    static void Main() {
        MathOperation add = (x, y) => x + y; // Lambda for addition
        Console.WriteLine("Result: " + add(10, 20)); // Outputs: Result: 30
    }
}

Delegates multicast

Um único delegate pode referenciar vários métodos. Todos os métodos são invocados em ordem. Exemplo:

using System;

class Program {
    public delegate void Notify(string message);

    static void Main() {
        Notify notify = PrintMessage;
        notify += LogMessage;

        notify("Hello, Multicast Delegates!"); // Calls both methods
    }

    static void PrintMessage(string message) {
        Console.WriteLine("Print: " + message);
    }

    static void LogMessage(string message) {
        Console.WriteLine("Log: " + message);
    }
}

Desafio prático

Crie um programa que use um delegate StringOperation para realizar manipulações de texto, como converter para maiúsculas e inverter uma string. Exemplo:

using System;

class Program {
    public delegate string StringOperation(string input);

    static void Main() {
        StringOperation operations = ToUpperCase;
        operations += ReverseString;

        string input = "Hello";
        foreach (var operation in operations.GetInvocationList()) {
            Console.WriteLine(((StringOperation)operation)(input));
        }
    }

    static string ToUpperCase(string input) {
        return input.ToUpper();
    }

    static string ReverseString(string input) {
        char[] chars = input.ToCharArray();
        Array.Reverse(chars);
        return new string(chars);
    }
}

Práticas recomendadas para delegates e expressões lambda

Veja algumas práticas recomendadas:

• Use objetos delegate para implementar retornos de chamada e tratamento de eventos.
• Prefira expressões lambda para obter código conciso e claro.
• Combine expressões lambda com LINQ para processar dados com eficiência.
• Evite expressões lambda excessivamente complexas para manter a legibilidade.

Dica: use nomes de parâmetros significativos nas expressões lambda para melhorar a clareza do código.

Ótimo trabalho!

Parabéns! Você aprendeu a usar delegates e expressões lambda para escrever código funcional e orientado a eventos em C#. Na próxima lição, exploraremos a reflexão em C#, um recurso avançado para análise de tipos em tempo de execução. Vamos continuar programando!