C# Academy · Lektion

delegate, Action/Func, Closures

Übergeben Sie Verhalten über Delegates: Deklarieren Sie eigene Delegates, verwenden Sie die integrierten Typen Action/Func und sehen Sie, wie Lambdas Variablen erfassen (Closures).

delegate, Action/Func, Closures ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.

Überblick über Delegaten

Ziel: Behandeln Sie Methoden als Daten.

Definieren Sie einen delegate-Typ.
Verwenden Sie Action/Func.
Erstellen Sie Lambdas.
Verstehen Sie Closures (erfasste Variablen).

Grundlagen benutzerdefinierter Delegaten

Ein delegate ist ein typsicherer Funktionszeiger. Weisen Sie kompatible Methoden zu und rufen Sie sie wie eine Funktion auf.

using System;

// Custom delegate type: a method taking two ints and returning int
public delegate int Op(int x, int y);

public class Program
{
  static int Add(int a, int b) { return a + b; }
  static int Mul(int a, int b) { return a * b; }

  public static void Main(string[] args)
  {
    Op f = Add;                // method group conversion
    Console.WriteLine(f(2, 3)); // 5
    f = Mul;
    Console.WriteLine(f(2, 3)); // 6
  }
}

Action & Func

Action steht für Methoden ohne Rückgabewert; Func gibt einen Wert zurück. Verwenden Sie Methodengruppen oder Lambdas.

using System;

public class Program
{
  static void Log(string s) { Console.WriteLine("LOG: " + s); }

  public static void Main(string[] args)
  {
    Action<string> a = Log;                        // no return
    a("hello");

    Func<int, int, int> sum = delegate(int x, int y) { return x + y; }; // lambda/anon method
    Console.WriteLine(sum(3, 4)); // 7

    // Method group to Func
    Func<string, int> len = GetLen;
    Console.WriteLine(len("abc")); // 3
  }

  static int GetLen(string s) { return s == null ? 0 : s.Length; }
}

Closure-Demo

Eine Closure erfasst Variablen aus dem äußeren Gültigkeitsbereich. Die Variable bleibt länger bestehen als die Methode, die den Delegaten erstellt hat.

using System;

public class Program
{
  public static void Main(string[] args)
  {
    int counter = 0; // captured variable (lives as long as delegate)
    Action inc = delegate() { counter = counter + 1; Console.WriteLine(counter); };

    inc(); // 1
    inc(); // 2
    Console.WriteLine("Final=" + counter); // 2
  }
}

Methode höherer Ordnung

Übergeben Sie ein Func oder Action, um das Verhalten anzupassen. Dies ist die Grundlage vieler APIs (und von LINQ).

using System;

public class Program
{
  // Apply a transform to each number and sum the results
  static int SumBy(int[] xs, Func<int, int> transform)
  {
    int total = 0;
    for (int i = 0; i < xs.Length; i++)
    {
      total += transform(xs[i]);
    }
    return total;
  }

  public static void Main(string[] args)
  {
    int[] data = new int[] { 1, 2, 3 };
    int sumSquares = SumBy(data, delegate(int x) { return x * x; });
    Console.WriteLine(sumSquares); // 14
  }
}

Tipps zu Delegaten

Tipps:

Bevorzugen Sie Action/Func, um zusätzliche benutzerdefinierte Delegattypen zu vermeiden.
Halten Sie Lambdas kurz und verständlich.
Achten Sie auf erfasste Variablen; ihr Wert kann sich später ändern.
Verwenden Sie Methodengruppen, wenn eine benannte Methode bereits zur Signatur passt.

Bedeutung von Func und Action

Schnelltest: Welcher integrierte Delegattyp steht für eine Methode, die einen Wert zurückgibt?

Zusammenfassung

Zusammenfassung: Deklarieren Sie Delegaten, verwenden Sie Action/Func und schreiben Sie kleine Lambdas. Closures ermöglichen es Lambdas, lokale Variablen zu erfassen – verwenden Sie sie mit Bedacht.

Häufig gestellte Fragen

Ist die Lektion „delegate, Action/Func, Closures“ kostenlos?

Ja — der vollständige Text von „delegate, Action/Func, Closures“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „delegate, Action/Func, Closures“?

Übergeben Sie Verhalten über Delegates: Deklarieren Sie eigene Delegates, verwenden Sie die integrierten Typen Action/Func und sehen Sie, wie Lambdas Variablen erfassen (Closures). Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.

Wie lange dauert die Lektion „delegate, Action/Func, Closures“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

delegate, Action/Func, Closures
Events: Publish/Subscribe, event-Schlüsselwort
Event-Muster und Fallstricke (Speicherlecks)

← Zurück zu C# Academy