Dokumentacja C# z przykładami: Typy generyczne

Q: Jak napisać metodę generyczną w C#?

Umieść parametry typu po nazwie metody: static T Largest (List items) where T : IComparable { ... }. Kod wywołujący zwykle pomija argument typu, bo kompilator wnioskuje go z argumentów: Largest(prices) działa, gdy prices to List . Zapisz go jawnie, Largest (...), gdy nie ma z czego wnioskować.

Q: Co oznacza where T : class w C#?

To ograniczenie: T musi być typem referencyjnym, więc kod generyczny może przypisać null do T i użyć as T. Inne ograniczenia to where T : struct (typ wartościowy, który nie jest nullable), where T : new() (ma publiczny konstruktor bezparametrowy, więc kod może wywołać new T()), where T : SomeBaseClass oraz where T : ISomeInterface, które pozwala wywoływać na T składowe tego interfejsu.

Q: Czym jest default(T) w C#?

To wartość domyślna typu, którym okaże się T: 0 dla liczb, false dla bool, null dla typów referencyjnych i nullable oraz wyzerowana struktura dla pozostałych typów wartościowych. Kod generyczny używa jej, gdy potrzebuje "braku wartości" bez znajomości typu, na przykład jako wyniku nieudanego wyszukiwania. C# 7.1 dodał krótszy literał default.

Q: Dlaczego w C# nie mogę przypisać List do List ?

Bo List przyjmuje dowolne zwierzę: gdyby przypisanie było dozwolone, kod mógłby dodać Cat do czegoś, co naprawdę jest List . Kompilator to odrzuca (CS0029). Interfejsy tylko do odczytu są kowariantne, więc IEnumerable animals = dogs; i IReadOnlyList animals = dogs; kompilują się, bo nie da się przez nie niczego dodać.

Typy generyczne (generics) pozwalają napisać typ lub metodę raz i używać ich z wieloma typami, bez utraty bezpieczeństwa typów. Zamiast List elementów object, która wymaga rzutowań i przyjmuje wszystko, dostajesz List<int> i List<Order>, a każdą z nich sprawdza kompilator. Symbol zastępczy w nawiasach ostrych, zwyczajowo T, to parametr typu; typ podany przez kod wywołujący to argument typu.

Po co typy generyczne: problem, który rozwiązują

Przed typami generycznymi (C# 1) kolekcje przechowywały object. To się kompilowało, ale błędy wychodziły dopiero w trakcie działania, a każdy int był opakowywany (boxing) przy wstawianiu:

var prices = new System.Collections.ArrayList();
prices.Add(9.99m);
prices.Add("12.50");                  // compiles: anything is an object
decimal total = 0;
foreach (object p in prices)
    total += (decimal)p;              // InvalidCastException on the string

Z List<decimal> drugie Add to błąd kompilacji, pętla nie potrzebuje rzutowania, a wartości decimal są przechowywane jako decimal.

Klasy generyczne

Zadeklaruj parametry typu po nazwie klasy, a potem używaj ich w klasie jak każdego innego typu:

using System;
using System.Collections.Generic;

class Page<T>
{
    public IReadOnlyList<T> Items { get; }
    public int Number { get; }
    public int TotalPages { get; }

    public Page(IReadOnlyList<T> items, int number, int totalPages)
    {
        Items = items;
        Number = number;
        TotalPages = totalPages;
    }

    public bool HasNext => Number < TotalPages;

    public static Page<T> From(List<T> all, int number, int size)
    {
        int start = (number - 1) * size;
        int count = Math.Max(0, Math.Min(size, all.Count - start));
        int total = (all.Count + size - 1) / size;
        return new Page<T>(all.GetRange(start, count), number, total);
    }
}

class Program
{
    static void Main()
    {
        var names = new List<string> { "Ana", "Ben", "Chen", "Dara", "Eli" };
        Page<string> second = Page<string>.From(names, 2, 2);
        Console.WriteLine($"Page {second.Number}/{second.TotalPages}: {string.Join(", ", second.Items)}, more: {second.HasNext}");

        var scores = new List<int> { 90, 72, 85 };
        var first = Page<int>.From(scores, 1, 5);
        Console.WriteLine($"Page {first.Number}/{first.TotalPages}: {string.Join(", ", first.Items)}, more: {first.HasNext}");
    }
}

Wynik:

Page 2/3: Chen, Dara, more: True
Page 1/1: 90, 72, 85, more: False

Page<string> i Page<int> to dwa różne typy powstałe z jednej definicji. Klasa może przyjmować kilka parametrów typu (Dictionary<TKey, TValue>); nazywaj je T, gdy jest jeden, i TSomething, gdy jest ich kilka.

Metody generyczne i wnioskowanie typów

Metoda może mieć własne parametry typu, niezależnie od tego, czy jej klasa jest generyczna. Kod wywołujący zwykle pomija argument typu, bo kompilator wnioskuje go z argumentów:

using System;
using System.Collections.Generic;

class Program
{
    static void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }

    static List<T> Repeat<T>(T value, int times)
    {
        var list = new List<T>(times);
        for (int i = 0; i < times; i++) list.Add(value);
        return list;
    }

    static TOut[] Map<TIn, TOut>(TIn[] items, Func<TIn, TOut> convert)
    {
        var result = new TOut[items.Length];
        for (int i = 0; i < items.Length; i++) result[i] = convert(items[i]);
        return result;
    }

    static void Main()
    {
        int x = 1, y = 2;
        Swap(ref x, ref y);                  // T inferred as int
        Console.WriteLine($"{x} {y}");

        string first = "front", second = "back";
        Swap<string>(ref first, ref second); // explicit type argument
        Console.WriteLine($"{first} {second}");

        Console.WriteLine(string.Join(" ", Repeat("ho", 3)));

        decimal[] prices = { 4.5m, 12m, 0.99m };
        string[] labels = Map(prices, p => $"{p:F2} EUR");   // TIn and TOut inferred
        Console.WriteLine(string.Join(", ", labels));
    }
}

Wynik:

2 1
back front
ho ho ho
4.50 EUR, 12.00 EUR, 0.99 EUR

Wnioskowanie działa tylko na podstawie argumentów, nigdy typu zwracanego. Repeat(0, 3) nie potrzebuje adnotacji, ale metoda taka jak T Create<T>() nie ma z czego wnioskować, więc kod wywołujący musi napisać Create<Customer>(). Większość LINQ to metody generyczne oparte na tym wnioskowaniu: prices.Where(p => p > 1) to Where<decimal>, choć tego nie piszesz.

Ograniczenia: czym może być T

Wewnątrz metody generycznej kompilator pozwala tylko na to, co działa dla każdego możliwego T. Bez ograniczeń to niewiele więcej niż to, co obsługuje object. Aby wywołać CompareTo, utworzyć instancję albo odczytać właściwość, powiedz kompilatorowi przez where, czym musi być T:

using System;
using System.Collections.Generic;

abstract class Entity
{
    public int Id { get; set; }
}

class Customer : Entity
{
    public string Name { get; set; }
}

class Program
{
    // T must be comparable to itself, so CompareTo is available.
    static T Largest<T>(IEnumerable<T> items) where T : IComparable<T>
    {
        bool any = false;
        T best = default(T);
        foreach (T item in items)
        {
            if (!any || item.CompareTo(best) > 0) best = item;
            any = true;
        }
        if (!any) throw new InvalidOperationException("Sequence is empty");
        return best;
    }

    // T must derive from Entity (so .Id exists) and have a parameterless constructor.
    static T CreateWithId<T>(int id) where T : Entity, new()
    {
        var entity = new T();
        entity.Id = id;
        return entity;
    }

    static void Main()
    {
        Console.WriteLine(Largest(new[] { 3, 17, 8 }));
        Console.WriteLine(Largest(new List<string> { "pear", "apple", "plum" }));
        Console.WriteLine(Largest(new[] { 19.99m, 4.50m }));

        Customer c = CreateWithId<Customer>(42);
        c.Name = "Zoe";
        Console.WriteLine($"{c.Id} {c.Name}");
    }
}

Wynik:

17
plum
19.99
42 Zoe

Ograniczenia, których będziesz używać:

Ograniczenie	Znaczenie	Pozwala
`where T : class`	typ referencyjny	przypisać `null`, użyć `as`
`where T : struct`	typ wartościowy, nie nullable	użyć `T?` jako `Nullable<T>`
`where T : new()`	publiczny konstruktor bezparametrowy	wywołać `new T()` (musi być ostatnie na liście)
`where T : Entity`	dziedziczy po `Entity`	używać składowych `Entity`
`where T : IComparable<T>`	implementuje interfejs	wywołać `CompareTo`
`where T : U`	dziedziczy po innym parametrze typu	powiązać dwa parametry
`where T : unmanaged` (C# 7.3)	struktura bez referencji w środku	wskaźniki, `stackalloc`
`where T : Enum` (C# 7.3)	typ wyliczeniowy	przekazać do metod `Enum`
`where T : notnull` (C# 8)	typ, który nie jest nullable	adnotacje nullable reference

Kilka ograniczeń jednego parametru oddziela się przecinkami; każdy z kilku parametrów dostaje własną klauzulę where: class Cache<TKey, TValue> where TKey : notnull where TValue : class.

Brakujące ograniczenie objawia się błędem kompilacji w miejscu użycia składowej, na przykład CS1061 ('T' does not contain a definition for 'CompareTo') albo CS0304 przy wywołaniu new T() bez new().

default(T)

Kod generyczny czasem potrzebuje "pustej wartości" typu, którego nie zna. default(T) daje 0 dla liczb, false dla bool, null dla typów referencyjnych i nullable, a w pozostałych przypadkach wyzerowaną strukturę:

using System;
using System.Collections.Generic;

class Program
{
    static T FindOrDefault<T>(List<T> items, Predicate<T> match)
    {
        foreach (T item in items)
            if (match(item)) return item;
        return default(T);
    }

    static void Main()
    {
        var ages = new List<int> { 12, 25, 31 };
        var cities = new List<string> { "Oslo", "Porto" };

        Console.WriteLine(FindOrDefault(ages, a => a > 30));
        Console.WriteLine(FindOrDefault(ages, a => a > 90));
        Console.WriteLine(FindOrDefault(cities, c => c.StartsWith("P")));
        Console.WriteLine(FindOrDefault(cities, c => c.StartsWith("Z")) == null);
        Console.WriteLine(default(DateTime).ToString("yyyy-MM-dd"));
    }
}

Wynik:

31
0
Porto
True
0001-01-01

Druga linia pokazuje słabość tego wzorca: dla typów wartościowych "nie znaleziono" i "znaleziono 0" wyglądają tak samo. Dlatego metody frameworka używają zamiast tego kształtu TryGet (bool TryGetValue(TKey key, out TValue value)). Od C# 7.1 możesz pisać krócej return default;, gdy typ wynika z kontekstu.

Składowe statyczne osobno dla każdego typu

Każdy skonstruowany typ (Counter<int>, Counter<string>) dostaje własną kopię pól statycznych klasy:

using System;

class Counter<T>
{
    public static int Created;
    public Counter() { Created++; }
}

class Program
{
    static void Main()
    {
        new Counter<int>();
        new Counter<int>();
        new Counter<string>();

        Console.WriteLine(Counter<int>.Created);
        Console.WriteLine(Counter<string>.Created);
        Console.WriteLine(typeof(Counter<int>) == typeof(Counter<string>));
    }
}

Wynik:

2
1
False

Czasem to przydatne (pamięć podręczna dla typu, np. TypeInfo<T>.Name obliczane raz dla każdego T), a czasem zaskakuje, gdy spodziewasz się jednego wspólnego licznika. Wspólny stan trzymaj w klasie niegenerycznej.

Kolekcje generyczne

Kolekcje generyczne pokrywają większość potrzeb: List<T>, Dictionary<TKey, TValue>, HashSet<T>, Queue<T>, Stack<T> oraz wspólne dla nich interfejsy IEnumerable<T>, ICollection<T>, IList<T>, IReadOnlyList<T>. Przyjmuj najwęższy interfejs, jakiego metoda potrzebuje (IEnumerable<T>, jeśli tylko iteruje), a zwracaj typ konkretny albo tylko do odczytu.

Kowariancja i kontrawariancja

Dog jest Animal, ale List<Dog> nie jest List<Animal>:

List<Dog> dogs = new List<Dog>();
List<Animal> animals = dogs;
// error CS0029: Cannot implicitly convert type 'List<Dog>' to 'List<Animal>'

Gdyby to było dozwolone, animals.Add(new Cat()) wstawiłoby kota do listy psów. Interfejsy, które tylko produkują wartości, są bezpieczne i deklaruje się je jako kowariantne przez out:

IEnumerable<Animal> readOnly = dogs;          // fine: IEnumerable<out T>
IReadOnlyList<Animal> alsoFine = dogs;        // fine: IReadOnlyList<out T>

Odbicie lustrzane, kontrawariancja, oznaczana in, dotyczy interfejsów i delegatów, które tylko konsumują wartości: Action<Animal> można użyć tam, gdzie oczekiwany jest Action<Dog>, bo coś, co obsłuży każde zwierzę, obsłuży też psa. IComparer<in T> jest kontrawariantny, a Func<in T, out TResult> używa obu oznaczeń. Wariancja dotyczy tylko interfejsów i delegatów i tylko argumentów typów referencyjnych: IEnumerable<int> nie konwertuje się na IEnumerable<object>.

Typowe błędy

Używanie object tam, gdzie powinien być parametr typu. Rezygnujesz ze sprawdzania w czasie kompilacji i opakowujesz typy wartościowe.
Porównywanie dwóch wartości T przez ==. Bez ograniczenia class to się nie kompiluje (CS0019), a z nim porównuje referencje. Używaj EqualityComparer<T>.Default.Equals(a, b), które działa dla każdego T i respektuje własne Equals typu.
Zwracanie default(T) jako "nie znaleziono". Dla typów wartościowych to niejednoznaczne. Używaj bool TryX(..., out T value).
Za dużo ograniczeń. Każde zawęża krąg tych, którzy mogą używać metody. Ograniczaj tylko to, czego ciało naprawdę potrzebuje.
Oczekiwanie, że List<Derived> skonwertuje się na List<Base>. Zamiast tego przyjmuj IEnumerable<Base> albo IReadOnlyList<Base>.

Najczęściej zadawane pytania

Czym są typy generyczne w C#?

Typy generyczne pozwalają napisać klasę, interfejs lub metodę raz, z typem zastępczym T, który uzupełnia kod wywołujący: List<int>, List<Customer>. Kompilator sprawdza każde użycie względem prawdziwego typu, więc masz bezpieczeństwo typów bez rzutowań, a typy wartościowe są przechowywane bez boxingu. Najbardziej znanym przykładem są kolekcje z System.Collections.Generic.

Jak napisać metodę generyczną w C#?

Umieść parametry typu po nazwie metody: static T Largest<T>(List<T> items) where T : IComparable<T> { ... }. Kod wywołujący zwykle pomija argument typu, bo kompilator wnioskuje go z argumentów: Largest(prices) działa, gdy prices to List<decimal>. Zapisz go jawnie, Largest<decimal>(...), gdy nie ma z czego wnioskować.

Co oznacza where T : class w C#?

To ograniczenie: T musi być typem referencyjnym, więc kod generyczny może przypisać null do T i użyć as T. Inne ograniczenia to where T : struct (typ wartościowy, który nie jest nullable), where T : new() (ma publiczny konstruktor bezparametrowy, więc kod może wywołać new T()), where T : SomeBaseClass oraz where T : ISomeInterface, które pozwala wywoływać na T składowe tego interfejsu.

Czym jest default(T) w C#?

To wartość domyślna typu, którym okaże się T: 0 dla liczb, false dla bool, null dla typów referencyjnych i nullable oraz wyzerowana struktura dla pozostałych typów wartościowych. Kod generyczny używa jej, gdy potrzebuje "braku wartości" bez znajomości typu, na przykład jako wyniku nieudanego wyszukiwania. C# 7.1 dodał krótszy literał default.

Dlaczego w C# nie mogę przypisać List<Dog> do List<Animal>?

Bo List<Animal> przyjmuje dowolne zwierzę: gdyby przypisanie było dozwolone, kod mógłby dodać Cat do czegoś, co naprawdę jest List<Dog>. Kompilator to odrzuca (CS0029). Interfejsy tylko do odczytu są kowariantne, więc IEnumerable<Animal> animals = dogs; i IReadOnlyList<Animal> animals = dogs; kompilują się, bo nie da się przez nie niczego dodać.

Powiązane zagadnienia