2

我有一个对象“Receiver”，它正在接收/反序列化许多不同类型的请求。

然后，我希望此接收器使用“调度程序”对象，该对象将根据传入请求的类型将请求对象调度到正确的请求处理程序对象（先前在调度程序上注册）。当然，请求的类型只在运行时知道，而不是在编译时知道（太容易了；））

这里有一些代码来澄清事情......

我有一个请求类型的标记接口：

public interface IRequest {}

然后是一个虚拟请求类型：

public class DummyRequest : IRequest {}

这是请求处理程序对请求类型 T 使用的通用接口。

public interface IRequestHandler<in T> where T : IRequest
{
   void HandleRequest(T request);
}

一个具体的实现是 DummyRequest 请求的请求处理程序：

public class DummyRequestHandler : IRequestHandler<DummyRequest>
{
   public void HandleRequest(DummyRequest request) { }
}

这是我使用动态的调度程序的非常基本的实现，但仅当请求类型在编译时已知时才有效，但如果请求类型仅在运行时已知则无法工作（这不是很感兴趣在我的上下文中，但以某种方式显示了意图）：

public class Dispatcher
{
    private Dictionary<Type, dynamic> _handlers = new Dictionary<Type, dynamic>();

    public void Dispatch<T>(T requestObject) where T : IRequest
    {
       _handlers[requestObject.GetType()].HandleRequest(requestObject);
    }

    public void RegisterHandler<T>(IRequestHandler<T> handler) where T : IRequest
    {
       _handlers[typeof(T)] = handler;
    }
}

和用法，考虑到调度程序变量是一个 Dispatcher 对象：

一些代码会以这种方式在调度程序上注册处理程序

dispatcher.RegisterHandler<DummyRequest>(new DummyRequestHandler());

并且接收器对象将使用调度程序以这种方式调度传入请求：

dispatcher.Dispatch(new DummyRequest());

当然，这里只有在编译时知道请求类型时才有效，但在我的上下文中，接收方将请求作为对象类型接收，例如：

// Here ReceiveMessage is not generic and therefore returns object type 
// (even if type is DummyRequest, it's just being returned as an object,
// i.e : "request is DummyRequest" returns true) 
// signature of ReceiveMessage is "object ReceiveMessage()"
var request = ReceiveMessage();

我不能像这样打电话给调度员

dispatcher.Dispatch(request);

我找不到一种方法来解决这个问题而不会失去类型安全性（例如，不将 HandleRequest 签名更改为非泛型的获取对象的签名），我宁愿不要丢失。

我希望我的问题很清楚并且有意义......也许没有真正的方法，我不知道。

通过谷歌搜索“request dispatcher C#”没有发现任何有趣的东西。也许这种“模式”以另一个名字而闻名，但我称它为请求调度程序才有意义。

这背后的最终目的是能够通过为特定请求类型创建一个新的请求处理程序并将其注册到调度程序上来处理新的请求类型，而无需更改接收器的代码，也不需要更改调度程序。

谢谢 ！

4

2 回答 2

2

您无法摆脱直到运行时才知道对象类型的事实，因此您需要一个能够应对这种情况的设计。你应该看看工厂模式。如果你谷歌它，你会发现大量的例子。但本质上，您必须在运行时确定代码中对象的类型，并确定要实例化的对象类型。这可以采取使用反射的形式，也可以只是工厂方法中的 switch 语句。

于 2012-12-05T09:01:57.743 回答
2

您可以做的是实现抽象工厂模式（包含泛型），非常简单的概述可能类似于以下内容

public interface IRequest
{
   void Dispatch();
}

您将在哪里使用以下类来获得在运行时使用的正确“策略”

public static class DispatchStrategyfactory
{
    public static void Dispatch<T>(T instance) where T : IRequest 
    {
        instance.Dispatch();
    } 
}

但是，要使此模式起作用，您必须将相关的具体类创建为

public static TestDispatcher : IRequest
{
    public void Dispatch()
    {
        // Do stuff.
    }
}

这应该使您能够执行所需的操作。有关 Strategy/[Abstract]Factory 模式的更多信息，请参见此处。我希望我没有错过这里的重点。

我希望这有帮助。

于 2012-12-05T09:10:49.860 回答