Typy generyczne w C#

Witamy w pierwszej lekcji kursu „Advanced C# Features”! W tej lekcji poznają Państwo typy generyczne — zaawansowaną funkcję języka C#, która umożliwia tworzenie elastycznego i wielokrotnego wykorzystania kodu. Zaczynajmy!

Czym są typy generyczne?

Typy generyczne to funkcja języka C#, która umożliwia definiowanie klas, metod i struktur danych z użyciem symbolu zastępczego reprezentującego typ przechowywanych lub używanych danych. Typy generyczne zapewniają bezpieczeństwo typów i ponowne wykorzystanie kodu.

Przykład: Lista generyczna (List<T>) może przechowywać elementy dowolnego typu, zapewniając jednocześnie bezpieczeństwo typów.

Tworzenie klas generycznych

Klasę generyczną można zdefiniować za pomocą składni <T>, w której T reprezentuje parametr typu. Przykład:

Najważniejsza informacja: Typy generyczne umożliwiają tworzenie klas działających z dowolnym typem danych przy zachowaniu bezpieczeństwa typów.

using System;

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

    public void Display() {
        Console.WriteLine("Value: " + Value);
    }
}

class Program {
    static void Main() {
        GenericBox<int> intBox = new GenericBox<int> { Value = 42 };
        intBox.Display(); // Outputs: Value: 42

        GenericBox<string> stringBox = new GenericBox<string> { Value = "Hello, Generics!" };
        stringBox.Display(); // Outputs: Value: Hello, Generics!
    }
}

Tworzenie metod generycznych

Metodę generyczną można zdefiniować wewnątrz klasy. Przykład:

Wskazówka: Proszę używać metod generycznych do operacji, które mają zastosowanie do wielu typów danych.

using System;

class Program {
    static void Main() {
        PrintValue(42);
        PrintValue("Generics are powerful!");
    }

    static void PrintValue<T>(T value) {
        Console.WriteLine("Value: " + value);
    }
}

Ograniczenia typów generycznych

Ograniczenia zawężają typy, których można używać jako parametrów typu. Przykład:

• where T : struct - T musi być typem wartości.
• where T : class - T musi być typem referencyjnym.
• where T : new() - T musi mieć konstruktor bezparametrowy.

Przykład:

Najważniejsza informacja: Ograniczenia sprawiają, że typy generyczne są bardziej elastyczne i przydatne w określonych scenariuszach.

using System;

class Program {
    static void Main() {
        DisplayDefault<int>();
        DisplayDefault<string>();
    }

    static void DisplayDefault<T>() where T : new() {
        T instance = new T();
        Console.WriteLine("Created instance of: " + typeof(T));
    }
}

Kolekcje generyczne

C# udostępnia kilka wbudowanych kolekcji generycznych:

• List<T>: Przechowuje kolekcję elementów w tablicy dynamicznej.
• Dictionary<TKey, TValue>: Przechowuje pary klucz-wartość, umożliwiając szybkie wyszukiwanie.
• Queue<T>: Implementuje strukturę First In, First Out (FIFO).

Przykład: Użycie listy generycznej:

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        List<string> names = new List<string> { "Alice", "Bob", "Charlie" };
        names.Add("Diana");

        foreach (string name in names) {
            Console.WriteLine(name);
        }
    }
}

Ćwiczenie praktyczne

Proszę utworzyć klasę generyczną Pair<TKey, TValue>, która przechowuje parę klucz-wartość, oraz metodę generyczną Swap(), która zamienia miejscami klucz i wartość. Przykład:

using System;

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

    public void Swap() {
        (Key, Value) = ((TKey)(object)Value, (TValue)(object)Key);
    }

    public void Display() {
        Console.WriteLine($"Key: {Key}, Value: {Value}");
    }
}

class Program {
    static void Main() {
        Pair<string, int> pair = new Pair<string, int> { Key = "Age", Value = 30 };
        pair.Display();
        pair.Swap();
        pair.Display();
    }
}

Najlepsze praktyki korzystania z typów generycznych

Oto kilka najlepszych praktyk:

• Proszę używać typów generycznych do tworzenia wielokrotnego użytku i bezpiecznych typowo klas oraz metod.
• Proszę stosować ograniczenia, gdy wymagania dotyczące typu są określone.
• Ze względu na wydajność i bezpieczeństwo proszę preferować kolekcje generyczne zamiast niegenerycznych.

Wskazówka: Proszę używać znaczących nazw parametrów typu, takich jak T dla typu lub TKey i TValue dla par klucz-wartość.

Świetna robota!

Gratulacje! Nauczyli się Państwo używać generyków do tworzenia wielokrotnego użytku i elastycznego kodu w C#. W następnej lekcji poznają Państwo programowanie asynchroniczne z użyciem async i await. Proszę kontynuować naukę programowania!