Можно ли использовать более одного шаблонного типа?

Можно ли использовать более одного generic-типа в C#?

Да, в C# можно использовать несколько generic-типов (параметров типа) в одном объявлении класса, интерфейса, структуры, метода или делегата. Это мощная возможность языка, которая позволяет создавать обобщенные конструкции, работающие с двумя и более независимыми типами одновременно. Практически нет ограничений на количество параметров типа, но для читаемости кода обычно используют от одного до трех-четырех.

Примеры использования нескольких generic-типов

1. Класс с двумя параметрами типа: Dictionary<TKey, TValue>

    Самый классический пример из стандартной библиотеки .NET. Здесь `TKey` и `TValue` — это два независимых типа, которые могут быть заданы при создании экземпляра.

```csharp
// Объявление класса с двумя generic-параметрами
public class MyPair<TFirst, TSecond>
{
    public TFirst First { get; set; }
    public TSecond Second { get; set; }

    public MyPair(TFirst first, TSecond second)
    {
        First = first;
        Second = second;
    }
}

// Использование
var stringIntPair = new MyPair<string, int>("Count", 100);
var boolDateTimePair = new MyPair<bool, DateTime>(true, DateTime.Now);

// Пример из стандартной библиотеки:
var dictionary = new Dictionary<string, MyPair<int, bool>>();
dictionary["example"] = new MyPair<int, bool>(42, false);
```

2. Интерфейсы с несколькими generic-типами: IEnumerator<T> и IEnumerable<T>

    Интерфейсы также могут быть параметризованы.

```csharp
// Собственный интерфейс для репозитория, возвращающего сущность по ключу
public interface IRepository<TEntity, TKey> where TEntity : class
{
    TEntity GetById(TKey id);
    void Add(TEntity entity);
}

// Реализация
public class UserRepository : IRepository<User, int>
{
    public User GetById(int id) { /* ... */ }
    public void Add(User entity) { /* ... */ }
}

public class DocumentRepository : IRepository<Document, Guid>
{
    public Document GetById(Guid id) { /* ... */ }
    public void Add(Document entity) { /* ... */ }
}
```

3. Обобщенные методы с несколькими типами

    Можно определить метод, который принимает параметры разных типов и/или возвращает результат отличного от них типа.

```csharp
public class Utility
{
    // Метод, принимающий два аргумента разных типов и возвращающий bool
    public static bool AreEqual<T1, T2>(T1 first, T2 second)
    {
        // Простая логика сравнения строковых представлений
        return first?.ToString() == second?.ToString();
    }

    // Метод, который преобразует одну коллекцию в другую
    public static List<TResult> Project<TSource, TResult>(
        IEnumerable<TSource> source,
        Func<TSource, TResult> selector)
    {
        var result = new List<TResult>();
        foreach (var item in source)
        {
            result.Add(selector(item));
        }
        return result;
    }
}

// Использование
bool check1 = Utility.AreEqual<int, string>(10, "10"); // true
bool check2 = Utility.AreEqual(10, 10.5); // false (типы выводятся)

var numbers = new List<int> { 1, 2, 3 };
var strings = Utility.Project<int, string>(numbers, n => $"Number: {n}");
```

Ограничения (Constraints) для нескольких generic-типов

К каждому параметру типа можно применять независимые или связанные ограничения.

public class Processor<TData, TId>
    where TData : class, IEntity<TId>, new() // TData должен быть классом, реализовывать IEntity<TId> и иметь конструктор по умолчанию
    where TId : struct // TId должен быть value-типом (например, int, Guid)
{
    public TId Process(TData data)
    {
        var newEntity = new TData(); // Можно создать экземпляр благодаря "new()"
        // ... работа с data
        return data.Id; // Свойство Id известно благодаря IEntity<TId>
    }
}

// Вспомогательный интерфейс
public interface IEntity<TKey>
{
    TKey Id { get; set; }
}

Рекомендации и выводы

• Читаемость: Используйте осмысленные имена параметров типа, такие как TKey, TValue, TEntity, а не просто T1, T2.
• Умеренность: Применяйте несколько generic-параметров там, где это действительно необходимо. Слишком большое их количество (более 3-4) часто указывает на излишнюю сложность дизайна класса или метода.
• Вложенные generics: Комбинация нескольких generic-типов может создавать сложные объявления (например, Dictionary<string, List<Tuple<int, bool>>>), что иногда ухудшает читаемость. В таких случаях рассмотрите возможность использования псевдонимов типов с using или создание специализированных классов-оберток.

Таким образом, поддержка нескольких generic-параметров в C# — это фундаментальная возможнсть, которая лежит в основе типобезопасных коллекций (Dictionary<TKey,TValue>, Tuple<T1,T2>), паттернов репозитория и Unit of Work, многих механизмов ORM (например, DbSet<TEntity> в Entity Framework), и бесчисленного множества других сценариев, где требуется гибкость и безопасность типов при работе с разнородными данными.