Delegates und Lambdas erkunden

Lambdas können Delegates direkt zugewiesen werden. Beispiel:

Ein Delegate ist ein Typ, der Verweise auf Methoden mit einer bestimmten Signatur enthält. Delegates ermöglichen es, Methoden als Parameter zu übergeben oder dynamisch zuzuweisen.

Beispiel: Delegates werden häufig für Rückrufe und die Ereignisbehandlung verwendet.

Sie können einen Delegate mithilfe des Schlüsselworts delegate definieren. Beispiel:

Wichtiger Punkt: Delegates bieten eine Möglichkeit, Methoden zu kapseln.

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

Ein Lambda-Ausdruck ist eine prägnante Möglichkeit, eine anonyme Methode in C# darzustellen. Er verwendet die Syntax (parameters) => expression.

Beispiel: (x, y) => x + y stellt eine Methode dar, die zwei Zahlen addiert.

Tipp: Lambdas werden häufig mit LINQ und Delegates verwendet, um kürzeren und klareren Code zu schreiben.

Lambdas mit Delegates verwenden

Lambdas können Delegates direkt zugewiesen werden. Beispiel:

Wichtiger Punkt: Lambdas machen Ihren Code kürzer und lesbarer.

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

Ein einzelner Delegate kann auf mehrere Methoden verweisen. Alle Methoden werden der Reihe nach aufgerufen. Beispiel:

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

Erstellen Sie ein Programm, das einen Delegate StringOperation verwendet, um Zeichenfolgen zu bearbeiten, beispielsweise durch die Umwandlung in Großbuchstaben und das Umkehren einer Zeichenfolge. Beispiel:

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

Hier sind einige bewährte Vorgehensweisen:

• Verwenden Sie Delegates, um Rückrufe und die Ereignisbehandlung zu implementieren.
• Bevorzugen Sie Lambda-Ausdrücke für kurzen und klaren Code.
• Kombinieren Sie Lambdas mit LINQ für eine effiziente Datenverarbeitung.
• Vermeiden Sie übermäßig komplexe Lambdas, damit der Code lesbar bleibt.

Tipp: Verwenden Sie aussagekräftige Parameternamen in Lambdas, um die Verständlichkeit des Codes zu verbessern.

Herzlichen Glückwunsch! Sie haben gelernt, wie Sie Delegates und Lambda-Ausdrücke verwenden, um funktionalen und ereignisgesteuerten Code in C# zu schreiben. In der nächsten Lektion beschäftigen wir uns mit Reflection in C#, einer leistungsfähigen Funktion zur Laufzeitanalyse von Typen. Programmieren wir weiter!