Что такое generics в C# и почему они полезны?

Базовый пример: без generics vs с generics

// БЕЗ generics — до C# 2.0 (ArrayList)
var list = new System.Collections.ArrayList();
list.Add(42);        // boxing int -> object
list.Add("mistake"); // компилируется, но это баг
int value = (int)list[0]; // явный cast, риск InvalidCastException

// С generics
var list = new List<int>();
list.Add(42);        // нет boxing
// list.Add("mistake"); // ошибка компиляции CS1503
int value = list[0]; // нет cast

Что такое generics и зачем они нужны

Generics (обобщения) — механизм параметризации типов и методов в C#. Вместо написания одного класса для int и отдельного для string вы пишете один обобщённый тип Container<T>, а компилятор создаёт специализированные версии под каждый тип-аргумент.

Три главные причины использовать generics:

• Типобезопасность — ошибки типов обнаруживаются на этапе компиляции, не в runtime.
• Производительность — для value types (int, struct) CLR создаёт специализированный машинный код без boxing/unboxing.
• Переиспользование — один алгоритм работает с любым типом, удовлетворяющим ограничению (constraint).

Generic методы и ограничения (constraints)

// Базовый generic метод
public T Max<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) >= 0 ? a : b;

// Использование
int maxInt = Max(3, 7);       // T = int
string maxStr = Max("abc", "xyz"); // T = string

// Ограничения (constraints)
public class Repository<T> where T : class, IEntity, new()
{
    // T : class     — только reference types
    // T : IEntity   — T реализует интерфейс
    // T : new()     — T имеет публичный конструктор без параметров

    public T Create() => new T();

    public async Task SaveAsync(T entity, CancellationToken ct)
    {
        entity.UpdatedAt = DateTime.UtcNow;
        await _db.Set<T>().AddAsync(entity, ct);
        await _db.SaveChangesAsync(ct);
    }
}

Generic классы и struct constraints для zero-allocation

// where T : struct — value type constraint, нет boxing
public readonly struct Option<T> where T : struct
{
    private readonly T _value;
    public bool HasValue { get; }

    public Option(T value) { _value = value; HasValue = true; }

    public T GetValueOrDefault(T @default = default)
        => HasValue ? _value : @default;
}

var opt = new Option<int>(42);
int val = opt.GetValueOrDefault(0); // нет heap allocation

Generics в стандартной библиотеке .NET

Generics пронизывают весь .NET:

• List<T>, Dictionary<TKey, TValue>, HashSet<T> — коллекции.
• Task<TResult>, IAsyncEnumerable<T> — async pipeline.
• ILogger<T>, IOptions<T> — DI в ASP.NET Core.
• IEnumerable<T>, IQueryable<T> — LINQ и EF Core.
• Span<T>, Memory<T>, ReadOnlySpan<T> — zero-allocation работа с памятью.

Как CLR обрабатывает generics

CLR (Common Language Runtime) использует reification — физическое создание специализированных типов:

• Для value types: List<int> и List<double> — разные JIT-скомпилированные типы, нет boxing.
• Для reference types: List<string> и List<User> используют одну JIT-специализацию с указателем, т.к. все reference types одного размера.

Подводные камни

• Constraint where T : new() использует Activator.CreateInstance — медленнее прямого new T(); в .NET 8+ используйте where T : IActivatable или фабрику.
• Generic типы не поддерживают наследование по параметру: List<Dog> не является List<Animal> — для этого нужна ковариантность (out T) или контравариантность (in T) на интерфейсах.
• Статические члены generic класса раздельны для каждого type argument: Singleton<int>.Instance != Singleton<string>.Instance.
• Reflection с generics сложнее: typeof(List<>) — открытый generic тип, требует MakeGenericType(typeof(int)) для создания экземпляра.
• AOT (PublishAot) требует, чтобы все используемые generic инстанции были известны на этапе компиляции — динамические MakeGenericType проблематичны.
• Слишком широкие constraints (where T : class) снижают пользу generics — IDE не подсказывает члены T.
• Generic методы в интерфейсах и default interface methods (.NET 8) — поведение при наследовании может быть неочевидным.
• Не путайте C# generics с Java generics: в Java type erasure убирает параметры типа в runtime, в C# — нет (reification).

• Путать обобщения, типобезопасность и переиспользование с похожим механизмом из другой версии или платформы.
• Игнорировать runtime-границы C#: lifecycle, DI scope, SQL translation, UI thread или platform API.
• Не обсуждать null/empty/error cases и поведение под нагрузкой.

• Кандидат объясняет обобщения, типобезопасность и переиспользование на конкретном примере, а не только определением.
• Указывает последствия для производительности, тестируемости и поддержки.
• Различает документированное поведение текущего стека и устаревшие практики.