Generics в C#: зачем нужны и как использовать для начинающих

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Generics в C#: зачем нужны и как использовать

При разработке на C# рано или поздно каждый сталкивается с ситуацией, когда один и тот же алгоритм нужно применить к разным типам данных. Раньше для этого приходилось либо писать несколько версий одного метода, либо использовать тип object, что приводило к потере производительности и риску ошибок. Решение этой проблемы — Generics (обобщенные типы). В этой статье мы разберем, что такое generics, зачем они нужны и как их правильно использовать в C#.

Что такое Generics в C#?

Generics (обобщения) — это механизм языка C#, который позволяет создавать классы, методы, интерфейсы и делегаты, работающие с разными типами данных, не теряя при этом строгой типизации. Вместо того чтобы писать код для каждого типа отдельно, вы создаете один универсальный шаблон, который подставляет нужный тип во время компиляции.

Представьте, что вам нужно написать метод для обмена значениями двух переменных. Без generics вам пришлось бы создавать отдельные методы для int, string, double и т.д. С generics вы пишете один метод, который работает с любым типом.

Вот простейший пример объявления generic-метода:

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

Здесь <T> — это параметр типа. Буква T — это общепринятое обозначение (от Type), но вы можете использовать любое имя. Когда вы вызываете метод, вы указываете конкретный тип:

int x = 5, y = 10;
Swap<int>(ref x, ref y);
// Теперь x = 10, y = 5

string first = "Hello", second = "World";
Swap<string>(ref first, ref second);
// Теперь first = "World", second = "Hello"

Зачем нужны Generics: основные преимущества

Использование generics дает несколько важных преимуществ, которые делают код лучше и безопаснее.

1. Безопасность типов (Type Safety)

В отличие от использования object, generics проверяют типы на этапе компиляции. Вы не сможете случайно передать строку туда, где ожидается число. Компилятор сразу укажет на ошибку.

2. Производительность

При использовании object происходит упаковка (boxing) значимых типов (int, double, struct) в ссылочный тип и обратная распаковка (unboxing). Это дорогостоящие операции. Generics полностью исключают эти процессы, так как компилятор генерирует специализированный код для каждого типа.

3. Повторное использование кода

Вам не нужно писать один и тот же алгоритм для разных типов. Один generic-класс или метод может работать с тысячами различных типов.

4. Читаемость и поддерживаемость

Код становится чище и понятнее. Вы явно видите, с какими типами работает метод или класс, а логика отделена от конкретных типов данных.

Как использовать Generics: практические примеры

Давайте рассмотрим несколько реальных сценариев использования generics в C#.

Generic-классы

Самый распространенный пример — это коллекции. Вместо того чтобы создавать свой класс для хранения списка чисел, строк или пользовательских объектов, вы используете List<T>:

List<int> numbers = new List<int>();
numbers.Add(1);
numbers.Add(2);

List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");

// Ваш собственный generic-класс
public class Repository<T>
{
    private List<T> _items = new List<T>();

    public void Add(T item) => _items.Add(item);
    public T Get(int index) => _items[index];
}

Repository<int> intRepo = new Repository<int>();
intRepo.Add(100);
int value = intRepo.Get(0); // 100

Generic-методы

Методы могут быть обобщенными даже внутри обычных классов:

public class Utils
{
    public T Max<T>(T a, T b) where T : IComparable<T>
    {
        return a.CompareTo(b) > 0 ? a : b;
    }
}

Utils utils = new Utils();
int maxInt = utils.Max(5, 10); // 10
string maxStr = utils.Max("apple", "banana"); // "banana"

Generic-интерфейсы

Интерфейсы также могут быть обобщенными. Это позволяет создавать гибкие контракты:

public interface IRepository<T>
{
    void Add(T item);
    T GetById(int id);
}

public class UserRepository : IRepository<User>
{
    public void Add(User user) { /* реализация */ }
    public User GetById(int id) { /* реализация */ return null; }
}

Ограничения (Constraints) в Generics

Иногда нужно ограничить, какие типы могут быть использованы в generic-классе или методе. Для этого используются ограничения (constraints) с ключевым словом where.

Основные типы ограничений:

where T : class — T должен быть ссылочным типом (классом).
where T : struct — T должен быть значимым типом (структурой).
where T : new() — T должен иметь конструктор без параметров.
where T : BaseClass — T должен наследоваться от указанного класса.
where T : IInterface — T должен реализовывать указанный интерфейс.

Пример с несколькими ограничениями:

public class Processor<T> where T : class, IComparable<T>, new()
{
    public T CreateAndCompare(T other)
    {
        T instance = new T(); // работает благодаря new()
        return instance.CompareTo(other) > 0 ? instance : other;
    }
}

Без ограничений вы не сможете вызывать методы типа CompareTo или создавать экземпляры через new T(), так как компилятор не знает, какие возможности есть у типа T.