C# Academy · Lektion

Lokale Funktionen deklarieren

Definieren Sie Hilfsfunktionen innerhalb von Methoden.

Lokale Funktionen deklarieren ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Was ist eine lokale Funktion?

Eine lokale Funktion ist eine Methode, die innerhalb einer anderen Methode deklariert wird. Sie ist nur innerhalb ihres umgebenden Members sichtbar. Dadurch bleibt die Hilfslogik nahe an ihrem Verwendungsort und wird nicht Teil der Klassenoberfläche.

Eine lokale Funktion deklarieren

Schreiben Sie die lokale Funktion wie eine normale Methode verschachtelt innerhalb des Methodenrumpfs. Sie können sie innerhalb desselben Gültigkeitsbereichs vor oder nach ihrer Deklaration aufrufen.

using System;

public class Program
{
    public static void Main()
    {
        int Square(int n) => n * n;

        Console.WriteLine(Square(4));
        Console.WriteLine(Square(7));
    }
}

Lokale Funktionen mit Blockkörper

Lokale Funktionen können wie jede Methode vollständige Blockkörper mit mehreren Anweisungen, Schleifen und eigenen lokalen Variablen besitzen.

using System;

public class Program
{
    public static void Main()
    {
        int Factorial(int n)
        {
            int result = 1;
            for (int i = 2; i <= n; i++) result *= i;
            return result;
        }

        Console.WriteLine(Factorial(5));
    }
}

Bessere Lesbarkeit

Mit lokalen Funktionen können Sie einem Stück Logik einen Namen geben, ohne die Klasse mit einer privaten Methode aufzublähen, die nur von einer einzigen Methode verwendet wird. So bleibt zusammengehöriger Code beieinander.

using System;

public class Program
{
    public static void Main()
    {
        string Format(string label, int value) => label + ": " + value;

        Console.WriteLine(Format("Score", 90));
        Console.WriteLine(Format("Level", 3));
    }
}

Rekursion mit lokalen Funktionen

Eine lokale Funktion kann sich selbst aufrufen. Dadurch lässt sich Rekursion genau dort ausdrücken, wo sie benötigt wird.

using System;

public class Program
{
    public static void Main()
    {
        int Fib(int n) => n < 2 ? n : Fib(n - 1) + Fib(n - 2);

        for (int i = 0; i < 7; i++)
            Console.Write(Fib(i) + " ");
        Console.WriteLine();
    }
}

Lokale Funktionen können nach ihrer Verwendung deklariert werden

Anders als lokale Variablen kann eine lokale Funktion an einer früheren Stelle der Methode referenziert werden als an der Stelle ihrer Deklaration. Der Compiler löst den gesamten umgebenden Gültigkeitsbereich auf.

using System;

public class Program
{
    public static void Main()
    {
        Console.WriteLine(Greet("Ada")); // used before declared

        string Greet(string name) => "Hello, " + name;
    }
}

Parameter und Rückgabetypen

Lokale Funktionen unterstützen alles, was reguläre Methoden unterstützen: mehrere Parameter, Rückgabewerte, ref- und out-Parameter sowie Generics.

using System;

public class Program
{
    public static void Main()
    {
        bool TryHalve(int n, out int half)
        {
            half = n / 2;
            return n % 2 == 0;
        }

        if (TryHalve(10, out int result))
            Console.WriteLine("half is " + result);
    }
}

Generische lokale Funktionen

Eine lokale Funktion kann generisch sein und über eigene Typargumente parametrisiert werden, unabhängig von der umgebenden Methode.

using System;

public class Program
{
    public static void Main()
    {
        T Echo<T>(T value)
        {
            Console.WriteLine("echoing " + value);
            return value;
        }

        int n = Echo(42);
        string s = Echo("hi");
        Console.WriteLine(n + " " + s);
    }
}

Lokale Funktionen verschachteln

Lokale Funktionen können selbst lokale Funktionen enthalten. Innere Funktionen sind nur innerhalb ihrer übergeordneten Funktion sichtbar, wodurch sich eng begrenzte Hilfsebenen erstellen lassen.

using System;

public class Program
{
    public static void Main()
    {
        int Compute(int x)
        {
            int Double(int n) => n * 2;
            int AddOne(int n) => n + 1;
            return Double(AddOne(x));
        }

        Console.WriteLine(Compute(5));
    }
}

Lokale Funktionen zur Argumentvalidierung

Ein häufig verwendetes Muster: Validieren Sie Argumente sofort und verschieben Sie die eigentliche Arbeit anschließend in eine lokale Funktion. Das ist besonders bei Iteratoren nützlich, damit die Validierung unmittelbar ausgeführt wird.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> Range(int start, int count)
    {
        if (count < 0) throw new ArgumentOutOfRangeException(nameof(count));
        return Iterate();

        IEnumerable<int> Iterate()
        {
            for (int i = 0; i < count; i++) yield return start + i;
        }
    }

    public static void Main()
    {
        foreach (var n in Range(10, 3)) Console.WriteLine(n);
    }
}

Wann lokale Funktionen sinnvoll sind

Verwenden Sie eine lokale Funktion, wenn eine Hilfsfunktion genau von einer Methode verwendet wird, von einem beschreibenden Namen profitiert oder Zugriff auf den lokalen Zustand der Methode benötigt. So bleibt die Klasse übersichtlich und die Logik leicht auffindbar.

using System;

public class Program
{
    public static void Main()
    {
        int total = 0;
        void Add(int n) => total += n; // helper tied to this method
        Add(3); Add(4); Add(5);
        Console.WriteLine(total);
    }
}

Kurzer Check

Rufen Sie sich ins Gedächtnis, was eine lokale Funktion ist.

Zusammenfassung

Lokale Funktionen sind benannte Hilfsfunktionen, die innerhalb einer Methode verschachtelt sind.

Sie sind nur innerhalb ihres umgebenden Members sichtbar.
Sie unterstützen Parameter, Rückgabewerte, out/ref, Generics und Rekursion.
Sie können vor ihrer Deklaration referenziert werden.
Sie eignen sich hervorragend für nur einmal verwendete Hilfsfunktionen und die sofortige Argumentvalidierung in Iteratoren.

Häufig gestellte Fragen

Ist die Lektion „Lokale Funktionen deklarieren“ kostenlos?

Ja — der vollständige Text von „Lokale Funktionen deklarieren“ 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 deklarieren“?

Definieren Sie Hilfsfunktionen innerhalb von Methoden. 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 4.

Wie lange dauert die Lektion „Lokale Funktionen deklarieren“?

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