C# Academy · Lektion

Lokale Funktionen versus Lambdas

Wählen Sie zwischen lokalen Funktionen und Lambdas.

Lokale Funktionen versus Lambdas ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. 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 4 Lektionen.

Lokale Funktionen und Lambdas

Sowohl mit lokalen Funktionen als auch mit Lambdas können Sie kleine Funktionen innerhalb einer Methode definieren. Sie überschneiden sich in vielerlei Hinsicht, unterscheiden sich aber in Syntax, Möglichkeiten und Leistung. Wenn Sie die passende Variante wählen, bleibt der Code übersichtlich und effizient.

Zwei Möglichkeiten, eine Hilfsfunktion zu schreiben

Hier wird dieselbe Hilfsfunktion zum Quadrieren sowohl als lokale Funktion als auch als einem Delegate zugewiesenes Lambda geschrieben. Beide liefern dasselbe Ergebnis.

using System;

public class Program
{
    public static void Main()
    {
        int SquareFn(int n) => n * n;       // local function
        Func<int, int> squareLambda = n => n * n; // lambda

        Console.WriteLine(SquareFn(4));
        Console.WriteLine(squareLambda(4));
    }
}

Lokale Funktionen ermöglichen einfache Rekursion

Eine lokale Funktion kann sich über ihren Namen selbst aufrufen. Ein Lambda kann während seiner Initialisierung nicht auf seine eigene Variable verweisen, daher ist Rekursion mit Lambdas umständlich.

using System;

public class Program
{
    public static void Main()
    {
        // Clean recursion with a local function
        int Factorial(int n) => n <= 1 ? 1 : n * Factorial(n - 1);
        Console.WriteLine(Factorial(5));
    }
}

Lokale Funktionen können generisch sein

Lokale Funktionen unterstützen eigene Typparameter. Lambdas können nicht generisch sein. Für wiederverwendbare typisierte Hilfsfunktionen ist daher eine lokale Funktion die passende Wahl.

using System;

public class Program
{
    public static void Main()
    {
        T First<T>(T[] items) => items[0]; // generic local function

        Console.WriteLine(First(new[] { 9, 8, 7 }));
        Console.WriteLine(First(new[] { "a", "b" }));
    }
}

Leistung: Delegate-Allokationen vermeiden

Ein einem Delegate zugewiesenes Lambda kann ein Delegate-Objekt und bei Erfassung zusätzlich eine Closure allokieren. Eine direkt aufgerufene lokale Funktion vermeidet beides, was in häufig ausgeführten Schleifen wichtig ist.

using System;

public class Program
{
    public static void Main()
    {
        // Direct call, no delegate or closure allocation
        static int Add(int a, int b) => a + b;

        int total = 0;
        for (int i = 0; i < 5; i++) total = Add(total, i);
        Console.WriteLine(total);
    }
}

out- und ref-Parameter

Lokale Funktionen können out- und ref-Parameter deklarieren; Lambdas können dies über die üblichen Func/Action-Delegates nicht. Dadurch eignen sich lokale Funktionen besonders gut für Try-Parse-ähnliche Hilfsfunktionen.

using System;

public class Program
{
    public static void Main()
    {
        bool TryGetFirstDigit(string s, out int digit)
        {
            digit = 0;
            foreach (var c in s)
                if (char.IsDigit(c)) { digit = c - '0'; return true; }
            return false;
        }

        if (TryGetFirstDigit("abc4", out int d))
            Console.WriteLine(d);
    }
}

Lambdas glänzen als Inline-Argumente

Wenn Sie Verhalten direkt an eine Methode wie LINQ Where oder Select übergeben müssen, ist ein Lambda-Ausdruck die prägnanteste und lesbarste Option.

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        var nums = new List<int> { 1, 2, 3, 4, 5, 6 };
        var evens = nums.Where(n => n % 2 == 0).Select(n => n * 10);
        Console.WriteLine(string.Join(", ", evens));
    }
}

Beide können Variablen erfassen

Beide Formen können Variablen aus dem umgebenden Kontext erfassen. Der Unterschied liegt hauptsächlich in der Syntax und den Allokationskosten, nicht darin, ob eine Erfassung möglich ist.

using System;

public class Program
{
    public static void Main()
    {
        int bonus = 10;
        int WithBonusFn(int n) => n + bonus;     // captures
        Func<int, int> withBonusLambda = n => n + bonus; // captures

        Console.WriteLine(WithBonusFn(5));
        Console.WriteLine(withBonusLambda(5));
    }
}

Definite Assignment und Reihenfolge

Eine lokale Funktion kann in der Methode vor ihrer Deklaration aufgerufen werden; eine Lambda-Variable muss vor ihrer Verwendung zugewiesen sein. Dadurch können lokale Funktionen flexibler platziert werden.

using System;

public class Program
{
    public static void Main()
    {
        Console.WriteLine(Triple(4)); // allowed before declaration

        int Triple(int n) => n * 3;
    }
}

Die richtige Wahl treffen

Verwenden Sie eine lokale Funktion für benannte, wiederverwendbare, rekursive oder generische Hilfsfunktionen sowie für Hilfsfunktionen in häufig ausgeführten Codepfaden. Verwenden Sie ein Lambda für kurzes Inline-Verhalten, das direkt an eine andere Methode übergeben wird. Beide sind Werkzeuge – wählen Sie nach der Absicht.

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        static bool IsPrime(int n)
        {
            if (n < 2) return false;
            for (int i = 2; i * i <= n; i++)
                if (n % i == 0) return false;
            return true;
        }

        var primes = Enumerable.Range(2, 20).Where(IsPrime);
        Console.WriteLine(string.Join(", ", primes));
    }
}

Probieren Sie es selbst aus

Verwenden Sie eine rekursive lokale Funktion für die Kernlogik und ein Lambda für die Inline-LINQ-Projektion, sodass jedes Konstrukt seine Stärken ausspielen kann.

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        // Local function: recursive, named, reusable
        static int DigitCount(int n) => Math.Abs(n) < 10 ? 1 : 1 + DigitCount(n / 10);

        var nums = new List<int> { 5, 42, 1000, 7, 88 };
        // Lambda: concise inline projection
        var report = nums.Select(n => n + " has " + DigitCount(n) + " digits");
        foreach (var line in report) Console.WriteLine(line);
    }
}

Schnelltest

Vergleichen Sie die beiden Konstrukte.

Zusammenfassung

Lokale Funktionen und Lambdas überschneiden sich in ihren Einsatzmöglichkeiten, unterscheiden sich aber in wichtigen Punkten.

Lokale Funktionen können rekursiv und generisch sein sowie out/ref verwenden.
Bei direkten Aufrufen vermeiden sie Delegate- und Closure-Allokationen.
Lambdas sind als Inline-Argumente für Methoden wie LINQ besonders prägnant.
Wählen Sie nach der Absicht: benannte, wiederverwendbare Hilfsfunktion oder kurzes Inline-Verhalten.

Häufig gestellte Fragen

Ist die Lektion „Lokale Funktionen versus Lambdas“ kostenlos?

Ja — der vollständige Text von „Lokale Funktionen versus Lambdas“ 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 4 Lektionen.

Was lerne ich in „Lokale Funktionen versus Lambdas“?

Wählen Sie zwischen lokalen Funktionen und Lambdas. 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 4 von 4.

Wie lange dauert die Lektion „Lokale Funktionen versus Lambdas“?

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

← Zurück zu C# Academy