与 C# 中的泛型类型有些混淆

Question

我正在使用 cqs，我正在尝试在类库中实现它（因此没有 IOC、IServiceProvider 等）。这是我写的一些代码：

public interface IQuery<TResult>
{
}

public interface IQueryHandler<TQuery, TResult> where TQuery : IQuery<TResult>
{
    TResult Handle(TQuery query);
}

public class Query : IQuery<bool>
{
    public int Value { get; set; }
}

public class QueryHandler : IQueryHandler<Query, bool>
{
    public bool Handle(Query query)
    {
        return query.Value > 0;
    }
}

public class Dispatcher
{
    private readonly Dictionary<Type, object> handlers = new Dictionary<Type, object>();

    public Dispatcher()
    {
        handlers.Add(typeof(Query), new QueryHandler());
    }

    public T Dispatch<T>(IQuery<T> query)
    {
        IQueryHandler<IQuery<T>, T> queryHandler;

        if (!this.handlers.TryGetValue(query.GetType(), out object handler) ||
            ((queryHandler = handler as IQueryHandler<IQuery<T>, T>) == null))
        {
            throw new Exception();
        }

        return queryHandler.Handle(query);
    }
}

这就是我如何调用我的代码：

Query query = new Query();
Dispatcher dispatcher = new Dispatcher();
var result = dispatcher.Dispatch(query);

但是问题是在dispatcher里面，我不知道为什么变量handler不能被强制转换为IQueryHandler<IQuery<T>,T>。这是一些额外的数据：

PS：我知道如何使这项工作（动态），但我想了解为什么此代码不起作用。

Answer 1

这是一个协方差问题。 handler的真实类型是QueryHandler，所以是IQueryHandler<Query, bool>。当然Query 是IQuery<bool>，但这就是协方差的意义所在。

这就像试图将List<String> 分配给List<Object> 类型的变量。

存在一个out 关键字，可让您按预期使用IQueryHandler 接口上的协方差。

详情请见out

编辑：

正如Sweeper 所指出的，您不能在TQuery 上使用out，因为它被用作输入参数。正确的解决方案是避免QueryHandler 对Query 的依赖。 Isma 很好地展示了它是如何完成的。

Answer 2

此代码不起作用，因为IQueryHandler 在TQuery 泛型参数上是不变的。 TQuery 需要协变才能使 handler 可转换为 IQueryHandler<IQuery<T>, T>，但这是不可能的，我稍后会解释。但是，您可以使 TQuery 逆变，它允许您将 handler 转换为 IQueryHandler<ASubclassOfQuery, T>。 TResult 可以是协变的。这是执行此操作的代码：

public interface IQueryHandler<in TQuery, out TResult> where TQuery : IQuery<TResult>

有关通用差异的更多信息，请参阅this page。

至于为什么handler不是IQueryHandler<IQuery<T>, T>，我们先假设它是，也就是说这段代码可以编译：

IQueryHandler<IQuery<T>, T> q = handler;
q.Handle(new MyQuery<T>());

MyQuery 的定义如下：

class MyQuery<T> : IQuery<T> {}

但是，handler 是运行时类型 QueryHandler。 QueryHandler.Handle 只处理 Query 对象，而不是 MyQuery<T> 对象！我们有一个矛盾，因此我们假设handler 是IQueryHandler<IQuery<T>, T> 一定是错误的。

Answer 3

这是避免协方差问题的另一种方法：

public interface IQuery<TResult>
{
    TResult Value { get; set; }
}

public interface IQueryHandler<TResult>
{
    TResult Handle<TQuery>(TQuery query) where TQuery : IQuery<TResult>;
}

public class Query : IQuery<bool>
{
    public bool Value { get; set; }
}

public class QueryHandler : IQueryHandler<bool>
{
    public bool Handle<TQuery>(TQuery query) where TQuery : IQuery<bool>
    {
        return query.Value;
    }
}

public class Dispatcher
{
    private readonly Dictionary<Type, object> handlers = new Dictionary<Type, object>();

    public Dispatcher()
    {
        handlers.Add(typeof(Query), new QueryHandler());
    }

    public T Dispatch<T>(IQuery<T> query)
    {
        if (handlers.ContainsKey(query.GetType()))
        {
            var queryHandler = (IQueryHandler<T>)handlers[query.GetType()];
            return queryHandler.Handle(query);
        }

        throw new NotSupportedException();
    }
}

例子：

var queryHandler = new QueryHandler();
var query = new Query();
query.Value = true;
var dispatcher = new Dispatcher();
dispatcher.Dispatch(query);
>> True

Answer 4

您的以下行没有意义：

handler as IQueryHandler<T, T>

因为第一个和第二个类型参数永远不能与Query 相同，Result 将始终是不同的类型。

您需要一些机制来在您的Dispatcher 中提供第二个类型参数，一种方法是：

public class Dispatcher<TResult> 
{
    private readonly Dictionary<Type, object> handlers = new Dictionary<Type, object>();

    public Dispatcher()
    {
        handlers.Add(typeof(Query), new QueryHandler());
    }

    public TResult Dispatch<TQuery>(TQuery query) where TQuery : IQuery<TResult>
    {
        IQueryHandler<TQuery, TResult> queryHandler;

        if (!this.handlers.TryGetValue(query.GetType(), out object handler) ||
            ((queryHandler = handler as IQueryHandler<TQuery, TResult>) == null))
        {
            throw new Exception();
        }

        return queryHandler.Handle(query);
    }
}

它可以被称为：

Query query = new Query();
Dispatcher<bool> dispatcher = new Dispatcher<bool>();
var result = dispatcher.Dispatch(query);

另一种方法是在Dispatch 方法中采用第二个类型参数，但我认为第一种方法更好：

public class Dispatcher<TQuery, TResult> where TQuery : IQuery<TResult>, new()
{
    private readonly Dictionary<Type, object> handlers = new Dictionary<Type, object>();

    public Dispatcher()
    {
        handlers.Add(typeof(Query), new QueryHandler());
    }

    public TResult Dispatch()
    {
        TQuery query = new TQuery();
        IQueryHandler<TQuery, TResult> queryHandler;

        if (!this.handlers.TryGetValue(query.GetType(), out object handler) ||
            ((queryHandler = handler as IQueryHandler<TQuery, TResult>) == null))
        {
            throw new Exception();
        }

        return queryHandler.Handle(query);
    }
}

调用方将如下所示：

Dispatcher<Query, bool> dispatcher = new Dispatcher<Query,bool>();
var result = dispatcher.Dispatch();