c# - 抽象方法和泛型方法

Question

拥有这个抽象类:

abstract class OrderHandler<T> : Handler  where T : class
{
    protected readonly Dictionary<Type, Func<BaseOrder, T>> OrderDispatcher =
         new Dictionary<Type, Func<BaseOrder, T>>
    {
        { typeof(OrderA), order => HandleOrder((OrderA) order) },
        { typeof(OrderB), order => HandleOrder((OrderB) order) },
        { typeof(OrderC), order => HandleOrder((OrderC) order) },
        { typeof(OrderD), order => HandleOrder((OrderD) order) },
    };

    public abstract T HandleOrder(OrderA order);

    public abstract T HandleOrder(OrderB order);

    public abstract T HandleOrder(OrderC order);

    public abstract T HandleOrder(OrderD order);
}

abstract class Handler
{
    public abstract Start(string orderId);
}

我想要创建可以访问调度程序字典的特定处理程序类，但每个类都重写并实现自己的 HandleOrder 方法。

我似乎无法将通用 T 应用于字典的委托(delegate)。

The type or namespace name 'T' could not be found (are you missing a using directive or an assembly reference?)

我做错了什么？

编辑

我想要多个类继承OrderHandler，例如InsertOrderHandler、DeleteOrderHandler、UpdateOrderHandler等。有许多 Order 对象(A、B、C...)，它们都继承 BaseOrder。

我已经有一个返回 BaseOrder 对象的方法，但我需要知道它是哪个子类。

BaseOrder order = GetOrder(id);

所以要避免这样做

if (order is OrderA) else if (order is OrderB) ...

我创建了按类型委托(delegate)的 HandleOrder 方法。

基本上

class InsertOrderHandler : OrderHandler<InsertOrderResult>
{
    public override Start(string orderId)
    {
        Order o = GetOrder(orderId);
        InsertOrderResult i = OrderDispatcher[o.GetType()](orderId);
    }

    public override InsertOrderResult HandleOrder(OrderA order)
    { /* do something then insert order */ }

    ...
}

class UpdateOrderHandler : OrderHandler<UpdateOrderResult>
{
    public override Start(string orderId)
    {
        Order o = GetOrder(orderId);
        UpdateOrderResult u = OrderDispatcher[o.GetType()](orderId);
    }

    public override UpdateOrderResult HandleOrder(OrderA order)
    { /* do something then update order */ }

    ...

class DeleteOrderHandler : OrderHandler<DeleteOrderResult>
{
    public override Start(string orderId)
    {
        Order o = GetOrder(orderId);
        DeleteOrderResult d = OrderDispatcher[o.GetType()](orderId);
    }

    public override DeleteOrderResult HandleOrder(OrderA order)
    { /* do something then delete order */ }

    ...
 }

我像这样启动处理程序

new InsertOrderHandler().Start("123");

Answer 1

您需要定义类的通用约束:

abstract class OrderHandler<T> where T : class

注意:
正如 Sriram 在他的评论中已经说过的那样:方法不能是静态和抽象，因为你不能覆盖静态 -方法。

所以下面的方法不起作用:

public abstract static T HandleOrder<T>(OrderA order);

您需要使用:

public abstract T HandleOrder(OrderA order); // no <T> as defined on class level

然后您可以在自定义处理程序中覆盖它们。当然，您需要一个对象实例来调用方法，并且 OrderDispatcher 也需要是非静态 才能访问实例方法。

更新问题的可能解决方案:

abstract class OrderHandler<T> where T : class
{
    protected readonly Dictionary<Type, Func<BaseOrder, T>> OrderDispatcher;

    public OrderHandler()
    {
       OrderDispatcher = new Dictionary<Type, Func<BaseOrder, T>>
       {
            { typeof(OrderA), order => HandleOrder(order as OrderA) },
            { typeof(OrderB), order => HandleOrder(order as OrderB) },
            // ...
       };
    }

    public T HandleOrder(BaseOrder order)
    {
        return OrderDispatcher[order.GetType()](order);
    }
    protected abstract T HandleOrder(OrderA order);
    // ...
}

class InsertOrderHandler : OrderHandler<InsertOrderResult>
{
    protected override InsertOrderResult HandleOrder(OrderA order)
    {
        // ...
    }
    // ...
}

然后你可以这样做:

var handler = new InsertOrderHandler();
handler.HandleOrder(order);