泛型参数实际运行时类型解析问题：无法正确获取RequirementHandler

场景定义 #

核心接口与实现类 #

interface IRequirement { }
interface ITarget { ICollection<IRequirement> Requirements { get; set; } }
interface IRequirementHandler<TRequirement, TTarget>
    where TRequirement : IRequirement
    where TTarget : ITarget 
{
    bool QualifyAgainst(TTarget target);
}

class AgeMustBeGreaterThanThirtyRequirement : IRequirement {}
class Person : ITarget 
{ 
    public int Age { get; set; } 
    public ICollection<IRequirement> Requirements { get; set; } = new List<IRequirement>();
}
class PersonAgeMustBeGreaterThanThirtyRequirementHandler : 
    IRequirementHandler<AgeMustBeGreaterThanThirtyRequirement, Person>
{
    public bool QualifyAgainst(Person target)
    {
        return target.Age > 30;
    }
}

DI容器注册 #

// 在DI容器中注册需求处理器
services.AddSingleton<IRequirementHandler<AgeMustBeGreaterThanThirtyRequirement, Person>,
    PersonAgeMustBeGreaterThanThirtyRequirementHandler>();

原实现思路与问题 #

需求处理器定位器设计 #

interface IRequirementHandlerLocator 
{ 
    IRequirementHandler<TRequirement, TTarget> GetHandler<TRequirement, TTarget>(TRequirement requirement, 
        TTarget target) where TRequirement : IRequirement
                        where TTarget : ITarget;
}

class RequirementHandlerLocator : IRequirementHandlerLocator
{
    private readonly IServiceProvider _serviceProvider;

    public RequirementHandlerLocator(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public IRequirementHandler<TRequirement, TTarget> GetHandler<TRequirement, TTarget>(TRequirement requirement, 
        TTarget target) where TRequirement : IRequirement
                        where TTarget : ITarget
    {
        return _serviceProvider.GetRequiredService<IRequirementHandler<TRequirement, TTarget>>();
    }
}

调用时的失败情况 #

IRequirementHandlerLocator _requirementHandlerLocator;

bool DoesTargetSatisfyRequirements(ITarget target)
{
    foreach (var requirement in target.Requirements)
    {
        // 编译时推断TRequirement为IRequirement，TTarget为ITarget，导致DI找不到对应处理器
        var handler = _requirementHandlerLocator.GetHandler(requirement, target);
        if (!handler.QualifyAgainst(target))
            return false;
    }
    return true;
}

问题核心：泛型类型推断是编译时行为，即使requirement和target的运行时类型是具体实现类，编译时只能推断出它们的接口类型IRequirement和ITarget，导致DI尝试解析IRequirementHandler<IRequirement, ITarget>，但实际注册的是针对具体类型的处理器。

尝试的解决方案及转换失败原因 #

尝试通过反射构建泛型类型并从DI获取实例，但转换失败：

// 定位器方法中的修改尝试
var handlerType = typeof(IRequirementHandler<,>)
    .MakeGenericType(requirement.GetType(), target.GetType());

// 成功获取到注册的处理器实例
var handler = _serviceProvider.GetRequiredService(handlerType);

// 强制转换失败：IRequirementHandler<ConcreteReq, ConcreteTarget> 无法转换为 IRequirementHandler<IRequirement, ITarget>
return (IRequirementHandler<TRequirement, TTarget>) handler;

转换失败的原因：IRequirementHandler<TRequirement, TTarget>默认是不变量泛型接口，即不支持协变或逆变。只有当接口声明为IRequirementHandler<out TRequirement, in TTarget>时，才能进行有限的类型转换，但这里TRequirement通常作为处理器的输入依赖，无法声明为协变；TTarget作为验证方法的输入参数，也无法声明为逆变，因此直接类型转换不成立。

可行解决方案 #

方案1：引入非泛型基接口 #

定义非泛型基接口，让泛型接口继承它，避免类型转换问题：

// 新增非泛型基接口
interface IRequirementHandler
{
    bool QualifyAgainst(ITarget target);
}

// 修改泛型接口继承非泛型接口
interface IRequirementHandler<TRequirement, TTarget> : IRequirementHandler
    where TRequirement : IRequirement
    where TTarget : ITarget 
{
    bool QualifyAgainst(TTarget target);
}

// 调整处理器实现，显式实现非泛型方法
class PersonAgeMustBeGreaterThanThirtyRequirementHandler : 
    IRequirementHandler<AgeMustBeGreaterThanThirtyRequirement, Person>
{
    public bool QualifyAgainst(Person target)
    {
        return target.Age > 30;
    }

    bool IRequirementHandler.QualifyAgainst(ITarget target)
    {
        if (target is Person person)
            return QualifyAgainst(person);
        throw new ArgumentException("目标类型不匹配", nameof(target));
    }
}

// 修改定位器接口及实现
interface IRequirementHandlerLocator 
{ 
    IRequirementHandler GetHandler(IRequirement requirement, ITarget target);
}

class RequirementHandlerLocator : IRequirementHandlerLocator
{
    private readonly IServiceProvider _serviceProvider;

    public RequirementHandlerLocator(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public IRequirementHandler GetHandler(IRequirement requirement, ITarget target)
    {
        var handlerType = typeof(IRequirementHandler<,>)
            .MakeGenericType(requirement.GetType(), target.GetType());
        return (IRequirementHandler)_serviceProvider.GetRequiredService(handlerType);
    }
}

// 调用代码
bool DoesTargetSatisfyRequirements(ITarget target)
{
    foreach (var requirement in target.Requirements)
    {
        var handler = _requirementHandlerLocator.GetHandler(requirement, target);
        if (!handler.QualifyAgainst(target))
            return false;
    }
    return true;
}

方案2：反射调用处理器方法 #

不修改接口结构，直接通过反射调用验证方法：

// 修改定位器接口
interface IRequirementHandlerLocator 
{ 
    bool ValidateRequirement(IRequirement requirement, ITarget target);
}

class RequirementHandlerLocator : IRequirementHandlerLocator
{
    private readonly IServiceProvider _serviceProvider;

    public RequirementHandlerLocator(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public bool ValidateRequirement(IRequirement requirement, ITarget target)
    {
        var handlerType = typeof(IRequirementHandler<,>)
            .MakeGenericType(requirement.GetType(), target.GetType());
        var handler = _serviceProvider.GetRequiredService(handlerType);
        
        // 反射调用QualifyAgainst方法
        var method = handlerType.GetMethod(nameof(IRequirementHandler<IRequirement, ITarget>.QualifyAgainst));
        return (bool)method.Invoke(handler, new object[] { target });
    }
}

// 调用代码
bool DoesTargetSatisfyRequirements(ITarget target)
{
    foreach (var requirement in target.Requirements)
    {
        if (!_requirementHandlerLocator.ValidateRequirement(requirement, target))
            return false;
    }
    return true;
}

原理总结 #

1. 泛型类型推断的编译时特性：C#泛型类型推断发生在编译阶段，编译器只能根据变量的声明类型推断泛型参数，无法预知运行时的实际类型。
2. 泛型接口的可变性：默认泛型接口是不变量，不同泛型参数的接口实例属于完全不同的类型，无法直接转换。协变/逆变修饰仅适用于特定场景（如输出参数用out，输入参数用in），无法覆盖当前需求场景。
3. 反射的作用：反射可以在运行时获取实际类型并构建泛型类型，正确从DI容器中解析实例，但需通过非泛型基接口或反射调用方法来规避类型转换问题。

内容的提问来源于stack exchange，提问作者mhDuke