C#:持有一组处理程序对象并找到合适的对象

Question

所以我有一个接口(interface)叫做IWorkItem在 WorkA 中实现, WorkB和许多其他类。

public interface IWorker<T> where T : IWorkItem
{
    void Process(T item);
}

IWorker<T>接口(interface)在 WorkerA 中实现( IWorker<WorkA> ), WorkerB ( IWorker<WorkB> ) 和许多其他类。

public static void ProcessWorkItem(IWorkItem item)
{
    (/* find the right worker */).Process(item);
}

现在我的问题是:如何找到能够处理给定 IWorkItem 的工作对象？

我的第一次尝试看起来像这样，但是泛型类型参数是个问题:

public static class WorkerRepository
{
    private static Dictionary<Type, IWorker<???>> RegisteredWorkers =
        new Dictionary<Type, IWorker<???>>();

    public static void RegisterWorker(IWorker<???> worker)
    {
        var handled = from iface in worker.GetType().GetInterfaces()
                      where iface.IsGenericType
                      where iface.GetGenericTypeDefinition() == typeof(IWorker<>)
                      select iface.GetGenericArguments()[0];
        foreach (var type in handled)
            if (!RegisteredWorkers.ContainsKey(type))
                RegisteredWorkers[type] = worker;
    }

    public static void ProcessWorkItem(IWorkItem item)
    {
        RegisteredWorkers[item.getType()].Process(item);
    }
}

所以我有 Dictionary包含 worker 。我在这里需要哪种类型的参数？在 Java 中我可以只使用 ? extends IWorkItem ，但我在 C# 中这样做吗？ 然后是RegisterWorker .您可能会为整个方法建议一个通用类型参数，例如 RegisterWorker<T>(IWorker<T> worker) .但是，这也行不通，因为我想动态加载、实例化和注册 Workers。

这是正确的方法还是有更好的方法来实现这一点？

Answer 1

我做了一些更改，但得到了一个解决方案，您可以在其中保持通用性(而不是使用 object s)。不确定您是否关心，但想将其添加为答案并让您决定。

我还写了一个测试来检查它是否真的有效，你应该可以复制/粘贴它。

[TestFixture]
public class WorkerThing
{
    [Test]
    public void RegisterAndRetrieveWorkers()
    {
        var repo = new WorkerRepository();
        repo.RegisterWorker(new WorkerA());
        var workerA = repo.RetrieveWorkerForWorkItem(new WorkItemA());
        Assert.IsTrue(workerA is WorkerA);

        repo.RegisterWorker(new WorkerB());
        var workerB = repo.RetrieveWorkerForWorkItem(new WorkItemB());
        Assert.IsTrue(workerB is WorkerB);
    }
}

WorkerRepository类。

public class WorkerRepository
{
    private readonly Dictionary<Type, IWorker<IWorkItem>> _registeredWorkers =
        new Dictionary<Type, IWorker<IWorkItem>>();

    public void RegisterWorker(IWorker<IWorkItem> worker)
    {
        var type = (from iface in worker.GetType().GetInterfaces()
                      where iface.IsGenericType
                      where iface.GetGenericTypeDefinition() == typeof(IWorker<>)
                      select iface.GetGenericArguments()[0]).First();

        if (!_registeredWorkers.ContainsKey(type))
        {
            _registeredWorkers[type] = worker;
        }
    }

    // You don't need this method, just added it to check if I indeed retrieved the correct type
    //
    public IWorker<IWorkItem> RetrieveWorkerForWorkItem(IWorkItem item)
    {
        var type = item.GetType();
        var registeredWorker = _registeredWorkers[type];
        return registeredWorker;
    }

    public void ProcessWorkItem(IWorkItem item)
    {
        var type = item.GetType();
        var registeredWorker = _registeredWorkers[type];
        registeredWorker.Process(item);
    }
}

工作项接口(interface)和类。

public interface IWorkItem
{
}

public class WorkItemA : IWorkItem
{
}

public class WorkItemB : IWorkItem
{
}

我在这里添加了 out关键字以允许在界面上输入协方差。这样你就可以转换 WorkerA至 IWorker<IWorkItem> . (如单元测试示例中所示)

public interface IWorker<out T> where T : IWorkItem
{
    void Process(IWorkItem workItem);
}

public class WorkerA : IWorker<WorkItemA>
{
    public void Process(IWorkItem item)
    {
    }
}

public class WorkerB : IWorker<WorkItemB>
{
    public void Process(IWorkItem item)
    {
    }
}

没有object字典。没有反射。我希望这个例子有用!

干杯(感谢这个很酷的问题，它让我忙了一会儿:))