C# Academy · Lekcja

Deklarowanie funkcji lokalnych

Definiuj funkcje pomocnicze wewnątrz metod.

Deklarowanie funkcji lokalnych to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 1 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.

Czym jest funkcja lokalna?

Funkcja lokalna to metoda zadeklarowana wewnątrz innej metody. Jest widoczna tylko w obrębie otaczającego jej elementu, dzięki czemu logika pomocnicza pozostaje blisko miejsca użycia i nie powiększa publicznego interfejsu klasy.

Deklarowanie funkcji lokalnej

Funkcję lokalną należy zapisać jak zwykłą metodę, zagnieżdżoną w treści innej metody. W tym samym zakresie można wywołać ją zarówno przed deklaracją, jak i po niej.

using System;

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

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

Funkcje lokalne z blokiem instrukcji

Funkcje lokalne mogą mieć pełne bloki instrukcji zawierające wiele instrukcji, pętle i własne zmienne lokalne, podobnie jak każda metoda.

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

Poprawa czytelności

Funkcje lokalne pozwalają nazwać fragment logiki bez zaśmiecania klasy prywatną metodą używaną tylko przez jedną inną metodę. Dzięki temu powiązany kod pozostaje razem.

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

Rekurencja z funkcjami lokalnymi

Funkcja lokalna może wywoływać samą siebie, dzięki czemu łatwo wyrazić rekurencję dokładnie w miejscu, w którym jest potrzebna.

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

Funkcje lokalne można deklarować po użyciu

W przeciwieństwie do zmiennych lokalnych funkcję lokalną można odwołać wcześniej w metodzie, niż została zadeklarowana. Kompilator analizuje cały otaczający zakres.

using System;

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

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

Parametry i typy zwracane

Funkcje lokalne obsługują wszystko, co zwykłe metody: wiele parametrów, wartości zwracane, parametry ref i out oraz typy generyczne.

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

Generyczne funkcje lokalne

Funkcja lokalna może być generyczna i mieć własne argumenty typów, niezależne od metody, w której została zdefiniowana.

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

Zagnieżdżanie funkcji lokalnych

Funkcje lokalne mogą same zawierać funkcje lokalne. Funkcje wewnętrzne są widoczne tylko w obrębie funkcji nadrzędnej, co pozwala tworzyć pomocnicze warstwy o ściśle ograniczonym zakresie.

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

Funkcje lokalne do sprawdzania argumentów

Typowy wzorzec polega na tym, aby najpierw niezwłocznie sprawdzić argumenty, a następnie odroczyć właściwą pracę do funkcji lokalnej. Jest to szczególnie przydatne w przypadku iteratorów, ponieważ sprawdzanie odbywa się wtedy natychmiast.

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

Kiedy używać funkcji lokalnych

Warto użyć funkcji lokalnej, gdy funkcja pomocnicza jest wykorzystywana dokładnie przez jedną metodę, zyskuje na opisowej nazwie albo potrzebuje dostępu do lokalnego stanu metody. Pozwala to zachować porządek w klasie i ułatwia odnalezienie powiązanej logiki.

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

Szybkie sprawdzenie

Przypomnij sobie, czym jest funkcja lokalna.

Podsumowanie

Funkcje lokalne to nazwane funkcje pomocnicze zagnieżdżone w metodzie.

Są widoczne tylko w obrębie otaczającego ich elementu.
Obsługują parametry, wartości zwracane, out/ref, typy generyczne i rekurencję.
Można się do nich odwoływać przed ich deklaracją.
Doskonale nadają się do funkcji pomocniczych używanych w jednym miejscu oraz do niezwłocznego sprawdzania argumentów w iteratorach.

Często zadawane pytania

Czy lekcja „Deklarowanie funkcji lokalnych” jest bezpłatna?

Tak — pełny tekst „Deklarowanie funkcji lokalnych” 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 „Deklarowanie funkcji lokalnych”?

Definiuj funkcje pomocnicze wewnątrz metod. Ć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 1 z 4.

Ile czasu zajmuje lekcja „Deklarowanie funkcji lokalnych”?

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