Исполняемые доки C#: Обобщения

Q: Как написать обобщённый метод в C#?

Поставьте параметры типа после имени метода: static T Largest (List items) where T : IComparable { ... }. Вызывающий код обычно опускает аргумент типа, потому что компилятор выводит его из аргументов: Largest(prices) работает, когда prices это List . Пишите его явно, Largest (...), когда выводить не из чего.

Q: Что означает where T : class в C#?

Это ограничение: T должен быть ссылочным типом, поэтому обобщённый код может присвоить T значение null и использовать as T. Другие ограничения: where T : struct (тип значения, не допускающий null), where T : new() (есть открытый конструктор без параметров, поэтому код может вызвать new T()), where T : SomeBaseClass и where T : ISomeInterface, которое позволяет коду вызывать члены этого интерфейса у T.

Q: Что такое default(T) в C#?

Значение по умолчанию для того типа, которым окажется T: 0 для чисел, false для bool, null для ссылочных типов и типов, допускающих null, и обнулённая структура для других типов значений. Обобщённый код использует его, когда нужно «нет значения», не зная типа, например как результат неудачного поиска. C# 7.1 добавил более короткий литерал default.

Q: Почему нельзя присвоить List переменной List в C#?

Потому что List принимает любое животное: если бы присваивание было разрешено, код мог бы добавить Cat в то, что на самом деле является List . Компилятор это отвергает (CS0029). Интерфейсы только для чтения ковариантны, поэтому IEnumerable animals = dogs; и IReadOnlyList animals = dogs; компилируются: через них ничего нельзя добавить.

Обобщения (generics) позволяют написать тип или метод один раз и использовать его со многими типами, не теряя типобезопасности. Вместо List из object, который требует приведений и принимает что угодно, вы получаете List<int> и List<Order>, каждый проверяемый компилятором. Заполнитель в угловых скобках, по соглашению T, называется параметром типа; тип, который подставляет вызывающий код, это аргумент типа.

Зачем нужны обобщения: какую проблему они решают

До обобщений (C# 1) коллекции хранили object. Это компилировалось, но ошибки проявлялись только во время выполнения, а каждый int упаковывался при добавлении:

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

С List<decimal> второй Add это ошибка компиляции, циклу не нужно приведение, а decimal хранятся как decimal.

Обобщённые классы

Объявите параметры типа после имени класса, а затем используйте их внутри класса как любой другой тип:

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

Вывод:

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

Page<string> и Page<int> это два разных типа, полученных из одного определения. Класс может принимать несколько параметров типа (Dictionary<TKey, TValue>); называйте его T, когда он один, и TSomething, когда их несколько.

Обобщённые методы и вывод типов

У метода могут быть собственные параметры типа независимо от того, обобщённый ли его класс. Вызывающий код обычно опускает аргумент типа, потому что компилятор выводит его из аргументов:

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

Вывод:

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

Вывод работает только по аргументам, никогда по возвращаемому типу. Repeat(0, 3) не требует аннотации, а у метода вроде T Create<T>() выводить не из чего, поэтому вызывающие должны писать Create<Customer>(). Большая часть LINQ это обобщённые методы, опирающиеся на этот вывод: prices.Where(p => p > 1) это Where<decimal>, хотя вы этого не пишете.

Ограничения: каким может быть T

Внутри обобщённого метода компилятор разрешает только то, что работает для любого возможного T. Без ограничений это немногим больше, чем поддерживает object. Чтобы вызвать CompareTo, создать экземпляр или прочитать свойство, скажите компилятору через where, каким должен быть 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}");
    }
}

Вывод:

17
plum
19.99
42 Zoe

Ограничения, которые вам понадобятся:

Ограничение	Смысл	Что позволяет
`where T : class`	ссылочный тип	присваивать `null`, использовать `as`
`where T : struct`	тип значения, не допускающий null	использовать `T?` как `Nullable<T>`
`where T : new()`	открытый конструктор без параметров	вызывать `new T()` (указывается последним)
`where T : Entity`	наследуется от `Entity`	использовать члены `Entity`
`where T : IComparable<T>`	реализует интерфейс	вызывать `CompareTo`
`where T : U`	наследуется от другого параметра типа	связывать два параметра
`where T : unmanaged` (C# 7.3)	структура без ссылок внутри	указатели, `stackalloc`
`where T : Enum` (C# 7.3)	тип перечисления	передавать в методы `Enum`
`where T : notnull` (C# 8)	тип, не допускающий null	аннотации ссылочных типов, допускающих null

Несколько ограничений одного параметра разделяются запятыми; для нескольких параметров у каждого своё предложение where: class Cache<TKey, TValue> where TKey : notnull where TValue : class.

Отсутствующее ограничение проявляется как ошибка компиляции в месте использования члена, например CS1061 ('T' does not contain a definition for 'CompareTo') или CS0304 при вызове new T() без new().

default(T)

Обобщённому коду иногда нужно «пустое значение» типа, которого он не знает. default(T) даёт 0 для чисел, false для bool, null для ссылочных типов и типов, допускающих null, и обнулённую структуру в остальных случаях:

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

Вывод:

31
0
Porto
True
0001-01-01

Вторая строка показывает слабость этого приёма: для типов значений «не найдено» и «найден 0» выглядят одинаково. Поэтому методы фреймворка вместо этого используют форму TryGet (bool TryGetValue(TKey key, out TValue value)). Начиная с C# 7.1 можно писать короче return default;, когда тип ясен из контекста.

Статические члены у каждого сконструированного типа свои

Каждый сконструированный тип (Counter<int>, Counter<string>) получает собственную копию статических полей класса:

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

Вывод:

2
1
False

Иногда это полезно (кэш на каждый тип, например TypeInfo<T>.Name, вычисляемый один раз для каждого T), а иногда удивляет, если вы ожидали один общий счётчик. Общее состояние помещайте в необобщённый класс.

Обобщённые коллекции

Обобщённые коллекции покрывают большинство потребностей: List<T>, Dictionary<TKey, TValue>, HashSet<T>, Queue<T>, Stack<T> и их общие интерфейсы IEnumerable<T>, ICollection<T>, IList<T>, IReadOnlyList<T>. Принимайте самый узкий интерфейс, который нужен методу (IEnumerable<T>, если он только перебирает), а возвращайте конкретный тип или тип только для чтения.

Ковариантность и контравариантность

Dog это Animal, но List<Dog> не является List<Animal>:

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

Если бы это было разрешено, animals.Add(new Cat()) положил бы кошку в список собак. Интерфейсы, которые только выдают значения, безопасны, и они объявлены ковариантными через out:

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

Зеркальный случай, контравариантность, помеченная in, относится к интерфейсам и делегатам, которые только потребляют значения: Action<Animal> можно использовать там, где ожидается Action<Dog>, потому что всё, что умеет обработать любое животное, умеет обработать и собаку. IComparer<in T> контравариантен, а Func<in T, out TResult> использует оба маркера. Вариантность применяется только к интерфейсам и делегатам и только к ссылочным аргументам типа: IEnumerable<int> не преобразуется в IEnumerable<object>.

Частые ошибки

object там, где место параметру типа. Это отказ от проверок при компиляции и упаковка типов значений.
Сравнение двух значений T через ==. Без ограничения class это не компилируется (CS0019), а с ним сравниваются ссылки. Используйте EqualityComparer<T>.Default.Equals(a, b), который работает для любого T и учитывает собственный Equals типа.
Возврат default(T) как «не найдено». Для типов значений это неоднозначно. Используйте bool TryX(..., out T value).
Слишком много ограничений. Каждое сужает круг тех, кто может использовать метод. Ограничивайте только то, что действительно нужно телу.
Ожидание, что List<Derived> преобразуется в List<Base>. Вместо этого принимайте IEnumerable<Base> или IReadOnlyList<Base>.

Часто задаваемые вопросы

Что такое обобщения в C#?

Обобщения позволяют один раз написать класс, интерфейс или метод с типом-заполнителем T, который подставляет вызывающий код: List<int>, List<Customer>. Компилятор проверяет каждое использование по настоящему типу, поэтому вы получаете типобезопасность без приведений, а типы значений хранятся без упаковки. Самый знакомый пример это коллекции из System.Collections.Generic.

Как написать обобщённый метод в C#?

Поставьте параметры типа после имени метода: static T Largest<T>(List<T> items) where T : IComparable<T> { ... }. Вызывающий код обычно опускает аргумент типа, потому что компилятор выводит его из аргументов: Largest(prices) работает, когда prices это List<decimal>. Пишите его явно, Largest<decimal>(...), когда выводить не из чего.

Что означает where T : class в C#?

Это ограничение: T должен быть ссылочным типом, поэтому обобщённый код может присвоить T значение null и использовать as T. Другие ограничения: where T : struct (тип значения, не допускающий null), where T : new() (есть открытый конструктор без параметров, поэтому код может вызвать new T()), where T : SomeBaseClass и where T : ISomeInterface, которое позволяет коду вызывать члены этого интерфейса у T.

Что такое default(T) в C#?

Значение по умолчанию для того типа, которым окажется T: 0 для чисел, false для bool, null для ссылочных типов и типов, допускающих null, и обнулённая структура для других типов значений. Обобщённый код использует его, когда нужно «нет значения», не зная типа, например как результат неудачного поиска. C# 7.1 добавил более короткий литерал default.

Почему нельзя присвоить List<Dog> переменной List<Animal> в C#?

Потому что List<Animal> принимает любое животное: если бы присваивание было разрешено, код мог бы добавить Cat в то, что на самом деле является List<Dog>. Компилятор это отвергает (CS0029). Интерфейсы только для чтения ковариантны, поэтому IEnumerable<Animal> animals = dogs; и IReadOnlyList<Animal> animals = dogs; компилируются: через них ничего нельзя добавить.

Связанные концепции