Utforska delegater och lambdauttryck

Lambda-uttryck kan tilldelas delegater direkt. Exempel:

Vad är en delegat?

En delegat är en typ som innehåller referenser till metoder med en specifik signatur. Delegater gör det möjligt att skicka metoder som parametrar eller tilldela dem dynamiskt.

Exempel: Delegater används ofta för callback-funktioner och händelsehantering.

Ni kan definiera en delegat med hjälp av nyckelordet delegate. Exempel:

Viktig punkt: Delegater erbjuder ett sätt att kapsla in metoder.

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

Vad är ett lambda-uttryck?

Ett lambda-uttryck är ett kortfattat sätt att representera en anonym metod i C#. Det använder syntaxen (parameters) => expression.

Exempel: (x, y) => x + y representerar en metod som adderar två tal.

Tips: Lambda-uttryck används ofta tillsammans med LINQ och delegater för kortare och tydligare kod.

Använda lambda-uttryck med delegater

Lambda-uttryck kan tilldelas delegater direkt. Exempel:

Viktig punkt: Lambda-uttryck gör koden kortare och mer lättläst.

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

En enskild delegat kan referera till flera metoder. Alla metoder anropas i tur och ordning. Exempel:

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

Skapa ett program som använder en delegat StringOperation för att utföra strängbearbetning, till exempel konvertera en sträng till versaler och vända på den. Exempel:

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

Här följer några rekommenderade arbetssätt:

• Använd delegater för att implementera callback-funktioner och händelsehantering.
• Föredra lambda-uttryck för kortfattad och tydlig kod.
• Kombinera lambda-uttryck med LINQ för effektiv databearbetning.
• Undvik alltför komplexa lambda-uttryck för att bevara läsbarheten.

Tips: Använd meningsfulla parameternamn i lambda-uttryck för att göra koden tydligare.

Grattis! Ni har lärt er att använda delegater och lambda-uttryck för att skriva funktionell och händelsestyrd kod i C#. I nästa lektion utforskar vi reflection i C#, en kraftfull funktion för typanalys under körning. Fortsätt koda!