C# Academy · Lekcja

Klasy generyczne

Wielokrotnego użytku typy kontenerów.

Klasy generyczne to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 2 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 klasa generyczna?

Klasa generyczna deklaruje jeden lub więcej parametrów typu w nawiasach ostrych umieszczonych za nazwą klasy. Parametrów tych można używać w polach, właściwościach, sygnaturach metod i typach zwracanych w całej klasie.

Pozwala to napisać jeden kontener lub serwis działający z wieloma typami elementów, przy zachowaniu silnego typowania.

class Box<T>
{
    public T Value { get; set; }
}

Tworzenie instancji klasy generycznej

Aby utworzyć instancję, należy podać konkretny argument typu. Box<int> i Box<string> to różne skonstruowane typy.

Każdy skonstruowany typ zachowuje się tak, jakby jego T zostało wszędzie zastąpione rzeczywistym typem.

using System;

class Box<T> { public T Value { get; set; } }

class Program
{
    static void Main()
    {
        var b = new Box<int> { Value = 7 };
        Console.WriteLine(b.Value);
    }
}

Pola i właściwości generyczne

Parametry typu mogą określać typ pól i właściwości. Stos, kolejka lub pamięć podręczna często przechowuje dane w tablicy albo na liście elementów typu T.

Wewnętrzne przechowywanie danych pozostaje bezpieczne typowo i nie wymaga rzutowania.

class Pair<T>
{
    public T First;
    public T Second;
}

Wiele parametrów typu

Klasa może przyjmować kilka parametrów typu. Typ reprezentujący parę klucz/wartość lub słownik często używa dwóch parametrów.

Opisowe nazwy, takie jak TKey i TValue, poprawiają czytelność, gdy parametrów jest więcej niż jeden.

class Entry<TKey, TValue>
{
    public TKey Key { get; set; }
    public TValue Value { get; set; }
}

Prosty stos generyczny

Oto niewielki stos generyczny oparty na List<T>. Push dodaje element na końcu, a Pop usuwa element z końca.

Ta sama klasa obsługuje liczby całkowite, napisy oraz dowolne typy referencyjne i typy wartości.

using System;
using System.Collections.Generic;

class MyStack<T>
{
    private readonly List<T> items = new();
    public void Push(T item) => items.Add(item);
    public T Pop()
    {
        var i = items[^1];
        items.RemoveAt(items.Count - 1);
        return i;
    }
}

class Program
{
    static void Main()
    {
        var s = new MyStack<string>();
        s.Push("a");
        s.Push("b");
        Console.WriteLine(s.Pop());
    }
}

Metody generyczne wewnątrz klas generycznych

Klasa generyczna może również deklarować dodatkowe parametry typu dla poszczególnych metod. Parametry na poziomie metody są niezależne od parametrów na poziomie klasy.

Zwiększa to elastyczność, na przykład pozwalając konwertować przechowywany typ na inny typ.

class Box<T>
{
    public T Value;
    public TOut Map<TOut>(Func<T, TOut> f) => f(Value);
}

Ograniczenia klasy

Podobnie jak metody, klasa generyczna może ograniczać swoje parametry typu za pomocą where. Ograniczenie dotyczy każdego elementu używającego tego parametru.

W poniższym przykładzie where T : class pozwala przypisywać null i porównywać referencje.

class Repository<T> where T : class
{
    private T current;
    public bool IsEmpty => current is null;
}

Elementy statyczne są niezależne dla każdego typu

Każdy skonstruowany typ generyczny otrzymuje własną kopię pól statycznych. Counter<int> i Counter<string> śledzą oddzielne liczniki.

Jest to subtelna, ale ważna różnica w porównaniu z klasami niegenerycznymi.

class Counter<T>
{
    public static int Count;
}

Wartości domyślne w klasach generycznych

Wewnątrz klasy generycznej często potrzebna jest wartość początkowa dla pola typu T. Należy użyć default(T) lub krótszego zapisu default, gdy typ wynika z kontekstu.

Wyrażenie to zwraca null dla typów referencyjnych i wartość zerową dla typów wartości.

class Slot<T>
{
    public T Value = default!;
    public bool HasValue { get; private set; }
}

Dziedziczenie po klasie generycznej

Można dziedziczyć po klasie bazowej generycznej. Klasa pochodna może ustalić argument typu albo sama pozostać generyczna.

Ustalenie argumentu specjalizuje klasę bazową, a pozostawienie klasy generycznej przekazuje parametr wyżej.

class Box<T> { public T Value; }

class IntBox : Box<int> { }

class NamedBox<T> : Box<T> { public string Name; }

Generyczność a kolekcje wbudowane

Biblioteka bazowa .NET jest pełna klas generycznych: List<T>, Dictionary<TKey, TValue> i Queue<T>. Są one codzienną korzyścią wynikającą z projektowania klas generycznych.

Tworzenie własnych typów generycznych pozwala rozszerzać ten sam bezpieczny i wielokrotnego użytku styl.

using System.Collections.Generic;

var scores = new Dictionary<string, int>();
scores["ada"] = 95;

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat klas generycznych.

Podsumowanie

Klasy generyczne deklarują parametry typu za nazwą klasy i używają ich w polach, właściwościach oraz metodach. Tworzy się je za pomocą konkretnych argumentów typu, uzyskując różne typy.

Mogą dodawać parametry typu na poziomie metod, zawierać ograniczenia where, być klasami bazowymi lub pochodnymi oraz przechowywać statyczny stan niezależny dla każdego typu. Kolekcje wbudowane są najlepszym przykładem.

Często zadawane pytania

Czy lekcja „Klasy generyczne” jest bezpłatna?

Tak — pełny tekst „Klasy generyczne” 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 „Klasy generyczne”?

Wielokrotnego użytku typy kontenerów. Ć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 2 z 4.

Ile czasu zajmuje lekcja „Klasy generyczne”?

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