C# Academy · Lektion

Statiske lokale funktioner

Undgå indfangning af variabler for større tydelighed og ydeevne.

Lektion 3 af 413 trin

Statiske lokale funktioner er en gratis C# Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i C# Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. C# Academy-kurset indeholder 4 lektioner i alt.

Statiske lokale funktioner

Hvis du markerer en lokal funktion med static, kan den ikke indfange omsluttende variabler eller this. Det gør funktionen selvstændig, tydeligere og fri for skjulte lukningsallokeringer.

Erklæring af en statisk lokal funktion

Tilføj modifikatoren static før returtypen. Funktionen kan stadig modtage parametre og returnere værdier; den kan bare ikke tilgå ydre lokale variabler.

using System;

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

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

Indfangning er ikke tilladt

En statisk lokal funktion kan ikke bruge omsluttende lokale variabler. Alt, hvad den har brug for, skal sendes ind som en parameter, så dens input bliver tydelige.

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

Undgå skjulte allokeringer

Ikke-statiske lokale funktioner, der indfanger variabler, kan allokere et skjult lukningsobjekt. En statisk lokal funktion indfanger aldrig noget og undgår derfor denne allokering helt.

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

Selvdokumenterende hensigt

Nøgleordet static signalerer til læserne, at hjælperen kun afhænger af sine argumenter. Den garanti gør funktionen lettere at forstå og teste.

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

Kompileren håndhæver ingen indfangning

Hvis du ved et uheld refererer til en omsluttende lokal variabel i en statisk lokal funktion, rapporterer kompileren en fejl. Det opdager utilsigtede afhængigheder tidligt.

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

Statiske lokale funktioner med rekursion

Statiske lokale funktioner understøtter stadig rekursion, fordi det at kalde sig selv ikke er det samme som at indfange en variabel.

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

Kombination med out-parametre

Ligesom enhver anden metode kan statiske lokale funktioner bruge out-parametre, hvilket passer godt sammen med deres egenskab af ikke at indfange noget i hjælpere i stil med try-parse.

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

Videregivelse af statiske lokale funktioner som delegerede

Fordi de ikke indfanger noget, kan statiske lokale funktioner konverteres til delegerede uden at allokere en lukning, hvilket kan have betydning i ydeevnekritiske stier.

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

Hvornår bør static foretrækkes?

Foretræk en statisk lokal funktion, når hjælperen ikke har brug for omsluttende tilstand. Det dokumenterer renhed, forhindrer utilsigtet indfangning og kan være mere effektivt. Fjern static kun, når du faktisk har brug for at lukke over lokale variabler.

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

Prøv selv

Skriv en ren statisk lokal funktion, og send den som et prædikat til LINQ. Fordi den ikke indfanger noget, konverteres den til en delegeret uden en lukning.

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

Hurtigt tjek

Genkald, hvad static tilføjer til en lokal funktion.

Besvar den i den interaktive lektion

Opsamling

En static lokal funktion indfanger intet.

Den kan ikke bruge omsluttende lokale variabler eller this; send data via parametre.
Den undgår skjulte lukningsallokeringer.
Kompileren håndhæver reglen om ingen indfangning og opdager utilsigtede afhængigheder.
Foretræk den, når hjælperen ikke har brug for omsluttende tilstand.

Gratis at komme i gang

Lær C# med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 93
Lektioner: 346

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Statiske lokale funktioner” gratis?

Ja — hele teksten til “Statiske lokale funktioner” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af C# Academy-kurset, skal du opgradere til CoddyKit PRO. C# Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Statiske lokale funktioner”?

Undgå indfangning af variabler for større tydelighed og ydeevne. Du øver dig i C# Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på C# Academy?

Der kræves ingen tidligere erfaring. C# Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Statiske lokale funktioner”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne C# Academy-lektion?

Ja. Alle C# Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til C# Academy