Дженерики в C# - продвинутые техники

private static List<Transaction> _transactions = new List<Transaction>();
 
// Поток 1
_transactions.Add(new Transaction("оплата"));
 
// Поток 2 (одновременно)
foreach (var transaction in _transactions)
{
    // Может произойти InvalidOperationException
}

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

public unsafe void ProcessArray<T>(T[] array) where T : unmanaged
{
    fixed (T* ptr = array)
    {
        // безопасная работа с указателями
    }
}

public class XmlSerializer<T> where T : IXmlSerializable, new()
{
    public string Serialize(T obj)
    {
        // код сериализации
        return result;
    }
    
    public T Deserialize(string xml)
    {
        T obj = new T(); // возможно благодаря ограничению new()
        // код десериализации
        return obj;
    }
}

public class Repository<TEntity, TKey> 
    where TEntity : class, IEntity<TKey>, new()
    where TKey : IComparable<TKey>, IEquatable<TKey>
{
    public TEntity GetById(TKey id)
    {
        // Код получения сущности по идентификатору
    }
    
    public IEnumerable<TEntity> GetAll(Expression<Func<TEntity, bool>> filter = null)
    {
        // Код выборки с фильтрацией
    }
}

public abstract class Builder<TProduct, TBuilder>
    where TProduct : class, new()
    where TBuilder : Builder<TProduct, TBuilder>
{
    protected TProduct Product { get; } = new TProduct();
    
    public TProduct Build() => Product;
    
    public abstract TBuilder WithName(string name);
    // другие методы билдера
}
 
public class CarBuilder : Builder<Car, CarBuilder>
{
    public override CarBuilder WithName(string name)
    {
        Product.Name = name;
        return this;
    }
    
    public CarBuilder WithEngine(Engine engine)
    {
        Product.Engine = engine;
        return this;
    }
}

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

// Без ограничений
public void ProcessValue<T>(T value)
{
    object boxed = value; // Боксинг значимого типа
    // Обработка
}
 
// С ограничением значимого типа
public void ProcessValueOptimized<T>(T value) where T : struct
{
    // Компилятор знает, что T - значимый тип
    // Никакого боксинга не произойдёт
}

public static T Sum<T>(T[] items)
{
    T result = default(T);
    foreach (var item in items)
    {
        result += item; // Ошибка компиляции! 
        // Оператор + не определён для T
    }
    return result;
}

public interface IAddable<T>
{
    T Add(T other);
}
 
public static T Sum<T>(T[] items) where T : IAddable<T>, new()
{
    T result = new T();
    foreach (var item in items)
    {
        result = result.Add(item);
    }
    return result;
}

public interface IValidatable { bool Validate(); }
 
public class Repository<T> where T : class
{
    public void Save(T entity)
    {
        if (entity is IValidatable validatable)
        {
            if (!validatable.Validate())
                throw new ValidationException("Entity failed validation");
        }
        
        // Сохранение сущности
    }
}

public class CloneableCache<TKey, TValue> 
    where TKey : notnull, IEquatable<TKey> 
    where TValue : ICloneable
{
    private Dictionary<TKey, TValue> _cache = new();
    
    public TValue Get(TKey key)
    {
        if (_cache.TryGetValue(key, out var value))
            return (TValue)value.Clone(); // Возвращаем клон
        return default;
    }
    
    public void Add(TKey key, TValue value)
    {
        _cache[key] = value;
    }
}

public class ValidateModelAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext context)
    {
        if (!context.ModelState.IsValid)
        {
            context.Result = new BadRequestObjectResult(context.ModelState);
        }
    }
}
 
[HttpPost]
[ValidateModel]
public IActionResult CreateUser([FromBody] UserModel model)
{
    // Модель уже проверена благодаря атрибуту
    _repository.Add(model);
    return Ok();
}

// Объявление ковариантного интерфейса
public interface IProducer<out T>
{
    T Produce();
}
 
// Классы в нашей иерархии
public class Animal { }
public class Cat : Animal { }
 
// Реализации интерфейса
public class CatProducer : IProducer<Cat>
{
    public Cat Produce() => new Cat();
}
 
// Благодаря ковариантности это работает!
IProducer<Animal> animalProducer = new CatProducer();
Animal animal = animalProducer.Produce(); // Получаем кота в переменную типа Animal

// Это НЕ скомпилируется!
public interface IBroken<out T>
{
    void Process(T item); // Ошибка: нельзя использовать T в входной позиции
}

// Контравариантный интерфейс
public interface IConsumer<in T>
{
    void Consume(T item);
}
 
// Реализация для обработки всех животных
public class AnimalConsumer : IConsumer<Animal>
{
    public void Consume(Animal animal)
    {
        Console.WriteLine($"Обрабатываю животное: {animal.GetType().Name}");
    }
}
 
// Благодаря контравариантности можно использовать обработчик животных
// там, где ожидается обработчик котов
IConsumer<Cat> catConsumer = new AnimalConsumer();
catConsumer.Consume(new Cat()); // Работает!

List<Cat> cats = new List<Cat>();
List<Animal> animals = cats; // Ошибка компиляции!

List<Animal> animals = new List<Cat>(); // Если бы это было возможно
animals.Add(new Dog()); // Добавляем собаку в список котов?!

async Task<Cat> GetCatAsync() => new Cat();
Task<Animal> animalTask = GetCatAsync(); // Ковариантность работает!
 
Animal animal = await animalTask; // Получаем кота

public interface IAsyncEnumerable<out T>
{
    IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default);
}

async IAsyncEnumerable<Cat> GetCatsAsync()
{
    yield return new Cat { Name = "Мурзик" };
    yield return new Cat { Name = "Барсик" };
}
 
IAsyncEnumerable<Animal> animals = GetCatsAsync(); // Работает благодаря ковариантности
 
await foreach (var animal in animals)
{
    // Обрабатываем животных (котов)
}

public delegate TResult Func<in T, out TResult>(T arg);

Func<Animal, Cat> catCreator = animal => new Cat();
Func<Cat, Animal> convertToAnimal = catCreator; // Обе вариативности в действии!

public interface IMediator
{
    TResponse Send<TResponse>(IRequest<TResponse> request);
}
 
public interface IRequestHandler<in TRequest, out TResponse> 
where TRequest : IRequest<TResponse>
{
    TResponse Handle(TRequest request);
}

// Пример CQRS с использованием вариативности
public interface IQueryHandler<in TQuery, out TResult> 
    where TQuery : IQuery<TResult>
{
    TResult Handle(TQuery query);
}
 
// Конкретный обработчик запроса
public class GetUserByIdHandler : IQueryHandler<GetUserByIdQuery, UserDto>
{
    public UserDto Handle(GetUserByIdQuery query) 
    {
        // Реализация получения пользователя
        return new UserDto { Id = query.UserId, Name = "Иван" };
    }
}

public abstract class AuthorizedQueryHandler<TQuery, TResult> : 
    IQueryHandler<AuthorizedQuery<TQuery>, TResult>
    where TQuery : IQuery<TResult>
{
    public TResult Handle(AuthorizedQuery<TQuery> authorizedQuery)
    {
        // Проверка прав доступа
        if (!IsAuthorized(authorizedQuery.UserId))
            throw new UnauthorizedException();
            
        // Делегирование обработки базовому запросу
        return HandleAuthorized(authorizedQuery.Query);
    }
    
    protected abstract TResult HandleAuthorized(TQuery query);
    
    private bool IsAuthorized(int userId) => true; // Упрощено для примера
}

IEnumerable<Cat> cats = GetCats();
IEnumerable<Animal> animals = cats; // Работает благодаря ковариантности
 
// Можно обрабатывать котов как животных без дополнительных аллокаций
var result = animals.Where(a => a.Age > 5).ToList();

// Без ковариантности (только для демонстрации проблемы)
List<Cat> cats = GetCats();
List<Animal> animals = cats.Cast<Animal>().ToList(); // Выделение дополнительной памяти

public interface IFactory<out T>
{
    T Create();
}
 
// Фабрика, создающая конкретную реализацию
public class CatFactory : IFactory<Cat>
{
    public Cat Create() => new Cat { Name = "Новый кот" };
}
 
// Можно использовать как фабрику животных
IFactory<Animal> animalFactory = new CatFactory();
Animal animal = animalFactory.Create(); // Получаем кота

services.AddTransient<ICatService, SiameseCatService>();
// Внутренне создаётся что-то вроде IFactory<ICatService>

public class ReadOnlyListWrapper<T> : IReadOnlyList<T>
{
    private readonly IList<T> _innerList;
    
    public ReadOnlyListWrapper(IList<T> list) => _innerList = list;
    
    public T this[int index] => _innerList[index];
    public int Count => _innerList.Count;
    public IEnumerator<T> GetEnumerator() => _innerList.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

public object CreateInstance(Type genericType, Type[] typeArguments)
{
    // Создаём конструкцию вида SomeGeneric<T1, T2, ...>
    Type constructedType = genericType.MakeGenericType(typeArguments);
    
    // Создаём экземпляр сконструированного типа
    return Activator.CreateInstance(constructedType);
}
 
// Пример использования
object list = CreateInstance(typeof(List<>), new[] { typeof(string) });
// Эквивалентно: new List<string>()

public void InvokeGenericMethod<T>(T item)
{
    // Получаем информацию о методе
    MethodInfo methodInfo = typeof(Processor).GetMethod("Process");
    
    // Создаём конкретный метод с типом T
    MethodInfo genericMethod = methodInfo.MakeGenericMethod(typeof(T));
    
    // Вызываем метод
    genericMethod.Invoke(new Processor(), new object[] { item });
}
 
public class Processor
{
    public void Process<TItem>(TItem item)
    {
        Console.WriteLine($"Обработка: {item} типа {typeof(TItem).Name}");
    }
}

private static readonly ConcurrentDictionary<Type, MethodInfo> _methodCache
    = new ConcurrentDictionary<Type, MethodInfo>();
 
public void InvokeProcessMethodOptimized<T>(T item)
{
    // Пытаемся получить метод из кэша
    var methodInfo = _methodCache.GetOrAdd(
        typeof(T),
        t => typeof(Processor).GetMethod("Process").MakeGenericMethod(t)
    );
    
    // Вызываем метод
    methodInfo.Invoke(new Processor(), new object[] { item });
}

private static readonly ConcurrentDictionary<Type, Action<object>> _delegateCache
    = new ConcurrentDictionary<Type, Action<object>>();
 
public void InvokeProcessMethodFast<T>(T item)
{
    // Получаем или создаём делегат
    var action = _delegateCache.GetOrAdd(
        typeof(T),
        t =>
        {
            // Параметры для выражения: (processor, item)
            var processorParam = Expression.Parameter(typeof(Processor), "processor");
            var itemParam = Expression.Parameter(typeof(object), "item");
            
            // Создаём вызов: processor.Process((T)item)
            var castItem = Expression.Convert(itemParam, t);
            var methodCall = Expression.Call(
                processorParam,
                typeof(Processor).GetMethod("Process").MakeGenericMethod(t),
                castItem
            );
            
            // Компилируем в делегат
            return Expression.Lambda<Action<Processor, object>>(
                methodCall, processorParam, itemParam
            ).Compile();
        }
    );
    
    // Вызываем делегат
    action(new Processor(), item);
}

public static class ReflectionExtensions
{
    public static T GetAttribute<T>(this MemberInfo member) where T : Attribute
    {
        return (T)member.GetCustomAttributes(typeof(T), true).FirstOrDefault();
    }
    
    public static void InvokeGenericMethod(this object obj, string methodName, Type[] typeArgs, params object[] args)
    {
        Type type = obj.GetType();
        MethodInfo method = type.GetMethod(methodName);
        MethodInfo genericMethod = method.MakeGenericMethod(typeArgs);
        genericMethod.Invoke(obj, args);
    }
}
 
// Пример использования
PropertyInfo prop = typeof(User).GetProperty("Name");
DisplayAttribute attr = prop.GetAttribute<DisplayAttribute>();
 
var processor = new Processor();
processor.InvokeGenericMethod("Process", new[] { typeof(int) }, 42);

public class ObjectMapper
{
    private delegate TTarget MapFunc<TSource, TTarget>(TSource source);
    private static readonly ConcurrentDictionary<(Type, Type), Delegate> _mappers = new();
    
    public static TTarget Map<TSource, TTarget>(TSource source)
        where TTarget : new()
    {
        var key = (typeof(TSource), typeof(TTarget));
        
        // Создаём или получаем маппер для пары типов
        var mapper = (MapFunc<TSource, TTarget>)_mappers.GetOrAdd(key, _ => CreateMapper<TSource, TTarget>());
        
        return mapper(source);
    }
    
    private static MapFunc<TSource, TTarget> CreateMapper<TSource, TTarget>()
        where TTarget : new()
    {
        var sourceType = typeof(TSource);
        var targetType = typeof(TTarget);
        
        // Параметр выражения
        var sourceParam = Expression.Parameter(sourceType, "source");
        var targetVar = Expression.Variable(targetType, "target");
        
        // Создаём новый целевой объект
        var newTarget = Expression.New(targetType);
        var assignTarget = Expression.Assign(targetVar, newTarget);
        
        // Собираем выражения для копирования свойств
        var propertySetters = sourceType.GetProperties()
            .Join(targetType.GetProperties(),
                  sourceProp => sourceProp.Name,
                  targetProp => targetProp.Name,
                  (sourceProp, targetProp) => new { SourceProp = sourceProp, TargetProp = targetProp })
            .Where(props => props.TargetProp.CanWrite && props.SourceProp.CanRead)
            .Select(props => {
                var sourcePropAccess = Expression.Property(sourceParam, props.SourceProp);
                var targetPropAccess = Expression.Property(targetVar, props.TargetProp);
                return Expression.Assign(targetPropAccess, sourcePropAccess);
            })
            .ToList();
        
        // Добавляем возврат целевого объекта
        var returnTarget = Expression.Return(Expression.Label(targetType), targetVar);
        var returnLabel = Expression.Label(targetType);
        
        // Собираем все выражения вместе
        var block = Expression.Block(
            new[] { targetVar },
            new List<Expression> { assignTarget }
                .Concat(propertySetters)
                .Append(returnTarget)
                .Append(Expression.Label(returnLabel, targetVar))
        );
        
        // Компилируем выражение в функцию
        return Expression.Lambda<MapFunc<TSource, TTarget>>(block, sourceParam).Compile();
    }
}

public class GenericFactory
{
    private static readonly ConcurrentDictionary<Type, Func<object>> _constructors = 
        new ConcurrentDictionary<Type, Func<object>>();
 
    public static T Create<T>() where T : new()
    {
        return (T)GetOrCreateConstructor(typeof(T))();
    }
 
    public static object Create(Type type)
    {
        return GetOrCreateConstructor(type)();
    }
 
    private static Func<object> GetOrCreateConstructor(Type type)
    {
        return _constructors.GetOrAdd(type, t =>
        {
            // Если тип обобщенный и не закрытый, выбросить исключение
            if (t.IsGenericTypeDefinition)
                throw new ArgumentException($"Не могу создать экземпляр незакрытого обобщённого типа {t}");
 
            // Создаём выражение для вызова конструктора без параметров
            var newExpr = Expression.New(t);
            
            // Компилируем в функцию
            return Expression.Lambda<Func<object>>(Expression.Convert(newExpr, typeof(object))).Compile();
        });
    }
    
    // Создание экземпляра с параметрами
    public static T Create<T>(params object[] args)
    {
        Type type = typeof(T);
        var constructors = type.GetConstructors();
        
        foreach (var ctor in constructors)
        {
            var parameters = ctor.GetParameters();
            if (parameters.Length == args.Length)
            {
                // Проверяем, что типы аргументов совместимы с параметрами
                bool match = true;
                for (int i = 0; i < parameters.Length; i++)
                {
                    if (args[i] != null && !parameters[i].ParameterType.IsAssignableFrom(args[i].GetType()))
                    {
                        match = false;
                        break;
                    }
                }
 
                if (match)
                    return (T)ctor.Invoke(args);
            }
        }
        
        throw new ArgumentException($"Не найден подходящий конструктор для типа {type.Name}");
    }
}

public static object CreateGeneric(Type genericTypeDefinition, params Type[] typeArguments)
{
    if (!genericTypeDefinition.IsGenericTypeDefinition)
        throw new ArgumentException($"Тип {genericTypeDefinition} не является определением обобщённого типа");
 
    // Создаём закрытый тип
    Type constructedType = genericTypeDefinition.MakeGenericType(typeArguments);
    
    // Создаём экземпляр
    return Create(constructedType);
}
 
public static object CreateGeneric(Type genericTypeDefinition, object[] constructorArgs, params Type[] typeArguments)
{
    if (!genericTypeDefinition.IsGenericTypeDefinition)
        throw new ArgumentException($"Тип {genericTypeDefinition} не является определением обобщённого типа");
 
    // Создаём закрытый тип
    Type constructedType = genericTypeDefinition.MakeGenericType(typeArguments);
    
    // Находим конструктор
    var constructor = constructedType.GetConstructor(
        constructorArgs.Select(arg => arg?.GetType() ?? typeof(object)).ToArray());
    
    if (constructor == null)
        throw new ArgumentException($"Не найден подходящий конструктор для типа {constructedType}");
    
    // Создаём экземпляр
    return constructor.Invoke(constructorArgs);
}

// Создаём словарь string -> int
var dict = GenericFactory.CreateGeneric(
    typeof(Dictionary<,>),
    typeof(string), typeof(int)
) as IEnumerable;
 
// Создаём обобщённый кэш с настройками
var cache = GenericFactory.CreateGeneric(
    typeof(MemoryCache<,>),
    new object[] { TimeSpan.FromMinutes(10) },
    typeof(string), typeof(User)
);

public static class ValidationHelper
{
    public static ValidationResult Validate<T>(T obj)
    {
        var result = new ValidationResult();
        var properties = typeof(T).GetProperties();
        
        foreach (var prop in properties)
        {
            var requiredAttr = prop.GetCustomAttribute<RequiredAttribute>();
            if (requiredAttr != null)
            {
                var value = prop.GetValue(obj);
                if (value == null || (value is string s && string.IsNullOrWhiteSpace(s)))
                {
                    result.Errors.Add($"Свойство {prop.Name} обязательно к заполнению");
                }
            }
            
            // Другие проверки...
        }
        
        return result;
    }
}

public static class GenericSerializer
{
    public static string Serialize<T>(T obj)
    {
        return JsonSerializer.Serialize(obj);
    }
    
    public static T Deserialize<T>(string json)
    {
        return JsonSerializer.Deserialize<T>(json);
    }
    
    public static object DeserializeGeneric(string json, Type type)
    {
        // Создаём обобщённый метод для конкретного типа
        var method = typeof(GenericSerializer)
            .GetMethod("Deserialize")
            .MakeGenericMethod(type);
        
        // Вызываем метод
        return method.Invoke(null, new object[] { json });
    }
}

public static class TypedStorage<T>
{
    public static object Value { get; set; }
}
 
// Использование
TypedStorage<User>.Value = new User { Id = 1 };
TypedStorage<Settings>.Value = new Settings { Theme = "Dark" };
 
// Позже в коде
var user = (User)TypedStorage<User>.Value;

public interface IOperation<T>
{
    T Execute(T input);
}
 
public class OperationMaterializer
{
    public TResult Materialize<TResult, TOperation>(TOperation operation, TResult input)
        where TOperation : IOperation<TResult>
    {
        return operation.Execute(input);
    }
}

public abstract class QueryBuilder<TSelf, TEntity>
    where TSelf : QueryBuilder<TSelf, TEntity>
{
    protected List<string> Filters = new List<string>();
    
    public TSelf Where(string condition)
    {
        Filters.Add(condition);
        return (TSelf)this;
    }
    
    public abstract IEnumerable<TEntity> Execute();
}
 
public class SqlQueryBuilder<TEntity> : QueryBuilder<SqlQueryBuilder<TEntity>, TEntity>
{
    public override IEnumerable<TEntity> Execute()
    {
        // Формирование и выполнение SQL-запроса
        return Enumerable.Empty<TEntity>();
    }
}

public static class FastActivator
{
    private static ConcurrentDictionary<Type, Func<object>> _activators 
        = new ConcurrentDictionary<Type, Func<object>>();
    
    public static T CreateInstance<T>() where T : new()
    {
        return new T();
    }
    
    public static object CreateInstance(Type type)
    {
        return _activators.GetOrAdd(type, t =>
        {
            var method = typeof(FastActivator).GetMethod("CreateInstance", Type.EmptyTypes)
                .MakeGenericMethod(t);
                
            return Expression.Lambda<Func<object>>(
                Expression.Convert(
                    Expression.Call(method),
                    typeof(object)
                )
            ).Compile();
        })();
    }
}

public static class QuickMapper
{
    private static ConcurrentDictionary<(Type, Type), Delegate> _mappers 
        = new ConcurrentDictionary<(Type, Type), Delegate>();
    
    public static TTarget Map<TSource, TTarget>(TSource source)
        where TTarget : new()
    {
        var key = (typeof(TSource), typeof(TTarget));
        
        var mapper = (Func<TSource, TTarget>)_mappers.GetOrAdd(key, k => 
            CreateMapper<TSource, TTarget>());
        
        return mapper(source);
    }
    
    private static Func<TSource, TTarget> CreateMapper<TSource, TTarget>()
        where TTarget : new()
    {
        // Создание и компиляция выражения маппинга
        // ...реализация опущена для краткости...
    }
}