C# Academy · Lektion

Statische lokale Funktionen

Verhindern Sie Erfassungen für mehr Übersichtlichkeit und Leistung.

Statische lokale Funktionen ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Statische lokale Funktionen

Wenn Sie eine lokale Funktion mit static kennzeichnen, kann sie keine umgebenden Variablen und kein this erfassen. Dadurch ist die Funktion in sich abgeschlossen, übersichtlicher und frei von versteckten Closure-Allokationen.

Eine statische lokale Funktion deklarieren

Fügen Sie den Modifizierer static vor dem Rückgabetyp ein. Die Funktion kann weiterhin Parameter und Rückgabewerte besitzen, aber nicht auf lokale Variablen außerhalb ihrer selbst zugreifen.

using System;

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

        Console.WriteLine(Square(6));
    }
}

Kein Erfassen erlaubt

Eine statische lokale Funktion kann keine lokalen Variablen aus dem umgebenden Gültigkeitsbereich verwenden. Alles, was sie benötigt, muss als Parameter übergeben werden, wodurch ihre Eingaben explizit sind.

using System;

public class Program
{
    public static void Main()
    {
        int factor = 3;
        // factor must be passed in, not captured
        static int Scale(int n, int f) => n * f;

        Console.WriteLine(Scale(5, factor));
    }
}

Versteckte Allokationen vermeiden

Nicht statische lokale Funktionen, die Variablen erfassen, können ein verstecktes Closure-Objekt allokieren. Eine statische lokale Funktion erfasst nichts und vermeidet diese Allokation vollständig.

using System;

public class Program
{
    public static void Main()
    {
        // Pure helper, no closure object created
        static bool IsEven(int n) => n % 2 == 0;

        for (int i = 0; i < 5; i++)
            Console.WriteLine(i + ": " + IsEven(i));
    }
}

Selbstdokumentierende Absicht

Das Schlüsselwort static signalisiert den Lesenden, dass die Hilfsfunktion nur von ihren Argumenten abhängt. Diese Garantie erleichtert es, das Verhalten der Funktion nachzuvollziehen und sie zu testen.

using System;

public class Program
{
    public static void Main()
    {
        static int Clamp(int value, int lo, int hi)
            => value < lo ? lo : value > hi ? hi : value;

        Console.WriteLine(Clamp(15, 0, 10));
        Console.WriteLine(Clamp(-3, 0, 10));
    }
}

Der Compiler erzwingt das Erfassenverbot

Wenn Sie innerhalb einer statischen lokalen Funktion versehentlich auf eine lokale Variable aus dem umgebenden Gültigkeitsbereich verweisen, meldet der Compiler einen Fehler. So werden unbeabsichtigte Abhängigkeiten früh erkannt.

using System;

public class Program
{
    public static void Main()
    {
        int seed = 7;
        // Correct: seed is passed explicitly, not captured
        static int Mix(int x, int s) => x * 31 + s;

        Console.WriteLine(Mix(2, seed));
    }
}

Statische lokale Funktionen mit Rekursion

Statische lokale Funktionen unterstützen weiterhin Rekursion, da der Aufruf der eigenen Funktion nicht mit dem Erfassen einer Variablen gleichzusetzen ist.

using System;

public class Program
{
    public static void Main()
    {
        static int Power(int baseN, int exp)
            => exp == 0 ? 1 : baseN * Power(baseN, exp - 1);

        Console.WriteLine(Power(2, 10));
    }
}

Mit out-Parametern kombinieren

Wie jede Methode können statische lokale Funktionen out-Parameter verwenden. Das passt gut zu ihrer Eigenschaft, nichts zu erfassen, und eignet sich für Try-Parse-ähnliche Hilfsfunktionen.

using System;

public class Program
{
    public static void Main()
    {
        static bool TryParsePositive(string s, out int value)
        {
            value = 0;
            return int.TryParse(s, out value) && value > 0;
        }

        if (TryParsePositive("42", out int n))
            Console.WriteLine("got " + n);
        Console.WriteLine(TryParsePositive("-1", out _));
    }
}

Statische lokale Funktionen als Delegates übergeben

Da sie nichts erfassen, lassen sich statische lokale Funktionen in Delegates umwandeln, ohne eine Closure zu allokieren. Das kann in performancekritischen Pfaden wichtig sein.

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

public class Program
{
    public static void Main()
    {
        static bool IsBig(int n) => n > 100;

        var nums = new List<int> { 50, 150, 200, 10 };
        Console.WriteLine(nums.Count(IsBig));
    }
}

Wann static vorzuziehen ist

Bevorzugen Sie eine statische lokale Funktion, wenn die Hilfsfunktion keinen umgebenden Zustand benötigt. Sie dokumentiert die Seiteneffektfreiheit, verhindert versehentliches Erfassen und kann effizienter sein. Lassen Sie static nur weg, wenn Sie tatsächlich lokale Variablen erfassen müssen.

using System;

public class Program
{
    public static void Main()
    {
        static string Describe(int score)
        {
            if (score >= 90) return "A";
            if (score >= 80) return "B";
            return "C";
        }

        Console.WriteLine(Describe(95));
        Console.WriteLine(Describe(82));
    }
}

Probieren Sie es selbst aus

Schreiben Sie eine reine statische lokale Funktion und übergeben Sie sie als Prädikat an LINQ. Da sie nichts erfasst, wird sie ohne Closure in ein Delegate umgewandelt.

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

public class Program
{
    public static void Main()
    {
        static bool IsLeapYear(int year)
            => (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;

        var years = new List<int> { 1900, 2000, 2004, 2021, 2024 };
        Console.WriteLine(string.Join(", ", years.Where(IsLeapYear)));
    }
}

Kurzer Check

Rufen Sie sich ins Gedächtnis, was static zu einer lokalen Funktion hinzufügt.

Zusammenfassung

Eine lokale Funktion mit static erfasst nichts.

Sie kann keine lokalen Variablen aus dem umgebenden Gültigkeitsbereich und kein this verwenden; übergeben Sie Daten über Parameter.
Sie vermeidet versteckte Closure-Allokationen.
Der Compiler erzwingt das Erfassenverbot und erkennt dadurch versehentliche Abhängigkeiten.
Bevorzugen Sie sie, wenn die Hilfsfunktion keinen umgebenden Zustand benötigt.

Häufig gestellte Fragen

Ist die Lektion „Statische lokale Funktionen“ kostenlos?

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

Verhindern Sie Erfassungen für mehr Übersichtlichkeit und Leistung. 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 3 von 4.

Wie lange dauert die Lektion „Statische lokale Funktionen“?

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