Exploración de delegados y lambdas

Usar lambdas con delegados

Las lambdas se pueden asignar directamente a delegados. Ejemplo:

¿Qué es un delegado?

Un delegado es un tipo que contiene referencias a métodos con una firma específica. Los delegados permiten pasar métodos como parámetros o asignarlos dinámicamente.

Ejemplo: Los delegados se utilizan habitualmente para devoluciones de llamada y gestión de eventos.

Definir y utilizar delegados

Puede definir un delegado mediante la palabra clave delegate. Ejemplo:

Punto clave: Los delegados proporcionan una 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);
    }
}

¿Qué es una expresión lambda?

Una expresión lambda es una forma concisa de representar un método anónimo en C#. Utiliza la sintaxis (parameters) => expression.

Ejemplo: (x, y) => x + y representa un método que suma dos números.

Consejo: Las lambdas se utilizan habitualmente con LINQ y los delegados para lograr mayor brevedad y claridad.

Usar lambdas con delegados

Las lambdas se pueden asignar directamente a delegados. Ejemplo:

Punto clave: Las lambdas hacen que el código sea más conciso y legible.

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
    }
}

Delegados multicast

Un único delegado puede hacer referencia a varios métodos. Todos los métodos se invocan en orden. Ejemplo:

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);
    }
}

Desafío práctico

Cree un programa que utilice un delegado StringOperation para realizar manipulaciones de cadenas, como convertir una cadena a mayúsculas e invertirla. Ejemplo:

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);
    }
}

Buenas prácticas para delegados y lambdas

Estas son algunas buenas prácticas:

• Utilice delegados para implementar devoluciones de llamada y gestionar eventos.
• Prefiera las expresiones lambda para obtener un código conciso y claro.
• Combine lambdas con LINQ para procesar datos de forma eficiente.
• Evite las lambdas excesivamente complejas para mantener la legibilidad.

Consejo: Utilice nombres de parámetros significativos en las lambdas para mejorar la claridad del código.

¡Excelente trabajo!

¡Enhorabuena! Ha aprendido a utilizar delegados y expresiones lambda para escribir código funcional y basado en eventos en C#. En la próxima lección, exploraremos la reflexión en C#, una función muy potente para analizar tipos en tiempo de ejecución. ¡Sigamos programando!