C# Academy · Lektion

Statiska lokala funktioner

Förhindra infångning för tydlighet och prestanda.

Lektion 3 av 413 steg

Statiska lokala funktioner är en gratis lektion i C# Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för C# Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C# Academy innehåller totalt 4 lektioner.

Statiska lokala funktioner

Om en lokal funktion märks med static förbjuds den från att fånga omslutande variabler eller this. Funktionen blir då självständig, tydligare och fri från dolda closure-allokeringar.

Deklarera en statisk lokal funktion

Lägg till modifieraren static före returtypen. Funktionen kan fortfarande ta emot parametrar och returnera värden, men den kan inte nå yttre lokala variabler.

using System;

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

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

Ingen infångning tillåten

En statisk lokal funktion kan inte använda omslutande lokala variabler. Allt den behöver måste skickas in som en parameter, vilket gör indata tydliga.

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

Undvika dolda allokeringar

Icke-statiska lokala funktioner som fångar variabler kan allokera ett dolt closure-objekt. En statisk lokal funktion fångar aldrig något och undviker därför allokeringen 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));
    }
}

Självdokumenterande avsikt

Nyckelordet static signalerar att hjälpfunktionen bara beror på sina argument. Den garantin gör funktionen enklare att förstå och testa.

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

Kompilatorn verkställer att ingen infångning sker

Om en omslutande lokal variabel råkar refereras i en statisk lokal funktion rapporterar kompilatorn ett fel. Det fångar oavsiktliga beroenden tidigt.

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

Statiska lokala funktioner med rekursion

Statiska lokala funktioner stöder fortfarande rekursion, eftersom ett anrop till den egna funktionen inte är samma sak som att fånga 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));
    }
}

Kombinera med out-parametrar

Precis som alla metoder kan statiska lokala funktioner använda out-parametrar, vilket passar bra ihop med deras rena egenskap att inte fånga något i hjälpfunktioner av typen 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 _));
    }
}

Skicka statiska lokala funktioner som delegater

Eftersom de inte fångar något kan statiska lokala funktioner omvandlas till delegater utan att en closure allokeras, vilket kan vara viktigt i prestandakritiska kodvägar.

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

När ska static föredras?

Föredra en statisk lokal funktion när hjälpfunktionen inte behöver omslutande tillstånd. Det dokumenterar att funktionen är ren, förhindrar oavsiktlig infångning och kan vara effektivare. Ta bara bort static när det verkligen behövs för att fånga lokala 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));
    }
}

Prova själv

Skriv en ren statisk lokal funktion och skicka den som ett predikat till LINQ. Eftersom den inte fångar något omvandlas den till en delegat utan en closure.

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

Snabbkontroll

Återkalla vad static tillför en lokal funktion.

Besvara frågan i den interaktiva lektionen

Sammanfattning

En static lokal funktion fångar ingenting.

Den kan inte använda omslutande lokala variabler eller this; skicka data via parametrar.
Den undviker dolda closure-allokeringar.
Kompilatorn verkställer regeln om ingen infångning och upptäcker oavsiktliga beroenden.
Föredra den när hjälpfunktionen inte behöver omslutande tillstånd.

Gratis att börja

Lär dig C# med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 93
Lektioner: 346

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Statiska lokala funktioner” gratis?

Ja – hela texten till ”Statiska lokala funktioner” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i C# Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i C# Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Statiska lokala funktioner”?

Förhindra infångning för tydlighet och prestanda. Ni övar på C# Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C# Academy?

Du behöver inga förkunskaper. Utbildningen i C# Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Statiska lokala funktioner”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C# Academy-lektionen?

Ja. Varje C# Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till C# Academy