C# Academy · Lekcja

Statyczne funkcje lokalne

Zapobiegaj przechwytywaniu dla większej czytelności i wydajności.

Statyczne funkcje lokalne to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 4 lekcji w sumie.

Statyczne funkcje lokalne

Oznaczenie funkcji lokalnej jako static uniemożliwia jej przechwytywanie zmiennych z otaczającego zakresu oraz this. Dzięki temu funkcja jest samodzielna, bardziej przejrzysta i nie powoduje ukrytych alokacji domknięcia.

Deklarowanie statycznej funkcji lokalnej

Modyfikator static należy dodać przed typem zwracanym. Funkcja nadal może przyjmować parametry i zwracać wartości, ale nie może uzyskiwać dostępu do zmiennych zewnętrznych.

using System;

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

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

Brak możliwości przechwytywania

Statyczna funkcja lokalna nie może korzystać ze zmiennych z otaczającego zakresu. Wszystko, czego potrzebuje, musi otrzymać jako parametr, dzięki czemu jej dane wejściowe są jawne.

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

Unikanie ukrytych alokacji

Niestatyczne funkcje lokalne, które przechwytują zmienne, mogą alokować ukryty obiekt domknięcia. Statyczna funkcja lokalna nigdy niczego nie przechwytuje, więc całkowicie unika tej alokacji.

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

Samodokumentująca się intencja

Słowo kluczowe static sygnalizuje czytelnikom, że funkcja pomocnicza zależy wyłącznie od swoich argumentów. Ta gwarancja ułatwia analizowanie i testowanie funkcji.

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

Kompilator wymusza brak przechwytywania

Jeśli przypadkowo odwołają się Państwo do zmiennej lokalnej z otaczającego zakresu wewnątrz statycznej funkcji lokalnej, kompilator zgłosi błąd. Pozwala to wcześnie wykryć niezamierzone zależności.

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

Statyczne funkcje lokalne z rekurencją

Statyczne funkcje lokalne nadal obsługują rekurencję, ponieważ wywoływanie samych siebie nie jest równoznaczne z przechwytywaniem zmiennej.

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

Łączenie z parametrami out

Podobnie jak każda metoda, statyczne funkcje lokalne mogą używać parametrów out, co dobrze współgra z ich brakiem przechwytywania w pomocniczych funkcjach w stylu 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 _));
    }
}

Przekazywanie statycznych funkcji lokalnych jako delegatów

Ponieważ nie przechwytują żadnych zmiennych, statyczne funkcje lokalne można konwertować na delegaty bez alokowania domknięcia, co może mieć znaczenie w często wykonywanych fragmentach kodu.

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

Kiedy preferować static

Statyczną funkcję lokalną należy preferować zawsze, gdy funkcja pomocnicza nie potrzebuje stanu z otaczającego zakresu. Dokumentuje to brak efektów ubocznych, zapobiega przypadkowemu przechwytywaniu i może zwiększyć wydajność. Słowo static należy pominąć tylko wtedy, gdy rzeczywiście potrzebują Państwo przechwytywać zmienne lokalne.

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

Spróbuj samodzielnie

Napisz czystą statyczną funkcję lokalną i przekaż ją do LINQ jako predykat. Ponieważ niczego nie przechwytuje, jest konwertowana na delegat bez domknięcia.

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

Szybkie sprawdzenie

Przypomnij sobie, co dodaje static do funkcji lokalnej.

Podsumowanie

Statyczna funkcja lokalna oznaczona jako static niczego nie przechwytuje.

Nie może korzystać ze zmiennych z otaczającego zakresu ani z this; dane należy przekazywać przez parametry.
Unika ukrytych alokacji domknięcia.
Kompilator wymusza zasadę braku przechwytywania, wykrywając przypadkowe zależności.
Należy ją preferować zawsze, gdy funkcja pomocnicza nie potrzebuje stanu z otaczającego zakresu.

Często zadawane pytania

Czy lekcja „Statyczne funkcje lokalne” jest bezpłatna?

Tak — pełny tekst „Statyczne funkcje lokalne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Statyczne funkcje lokalne”?

Zapobiegaj przechwytywaniu dla większej czytelności i wydajności. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Statyczne funkcje lokalne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C# Academy