C# 从总线解析命令

目前正在从处理命令同步转移到消息总线上，以便以后可以处理这些命令，但在尝试加载命令而不是键入每个命令时，很难返回真正的类型

这是我到目前为止所做的，看起来效果不错

指挥调度员

  public class CommandDispatcher : ICommandDispatcher
{
    private readonly IBus _commandBus;

    public CommandDispatcher(IBus commandBus)
    {
        _commandBus = commandBus;
    }

    public void Dispatch<TCommand>(TCommand command) where TCommand : ICommand
    {
        var messageType = typeof(TCommand);

        _commandBus.Publish(messageType, command);
    }

现在x只是一个我不能传递给Handlecommand方法的对象

我的集装箱使用autofac，公交车使用easynetq。

我认为这部分：

   private void HandleCommand<TCommand>(TCommand command) where TCommand : ICommand
    {
        var handler = _container.Resolve<ICommandHandler<TCommand>>();

        handler.Handle(command);
    }

private void HandleCommand（TCommand命令），其中TCommand:ICommand
{
var handler=_container.Resolve（）；
Handle.Handle（命令）；
}

如果您实现的是

IConsume

而不是

ICommandHandler

，则它们似乎具有相同的目的

您需要单独的

ICommandHandler

接口有什么具体原因吗

另请注意：在您的实现中，在解析命令处理程序时，您没有创建单独的“作用域”，这会导致处理程序的每个指令（以及任何依赖项）永远存在于“根”作用域中。换句话说：内存泄漏：）

如果您仍然想坚持您的实现，我认为最好这样做：

   private void HandleCommand<TCommand>(TCommand command) where TCommand : ICommand
    {
        using(var scope = _container.BeginLifetimeScope("my-command-scope"))
        {
          var handler = scope.Resolve<ICommandHandler<TCommand>>();
          handler.Handle(command);
        }
    }

private void HandleCommand（TCommand命令），其中TCommand:ICommand
{
使用（var scope=\u container.BeginLifetimeScope（“我的命令范围”））
{
var handler=scope.Resolve（）；
Handle.Handle（命令）；
}
}

但是，如果您使用AutoSubscriber，AutofacMessageDispatcher将为您执行以下操作：

---

这很有趣！然而，IConsume会让我依赖easynetQ。由于我目前正在考虑masstransit，这可能是一个坏消息dependency@luke：我想说，用IConsumer everywhere替换IConsume比尝试重新实现已经存在的概念更容易！同意：）谢谢你的帮助，我会搬到自动订户那里

        var commandAssembly = Assembly.GetAssembly(typeof(ICommand));

        var commands = commandAssembly.GetTypes().Where(x => typeof(ICommand).IsAssignableFrom(x));

        foreach (var command in commands)
        {
            bus.Subscribe(command, "key", x =>
            {
                HandleCommand(x);

            });
        }

   private void HandleCommand<TCommand>(TCommand command) where TCommand : ICommand
    {
        var handler = _container.Resolve<ICommandHandler<TCommand>>();

        handler.Handle(command);
    }

   private void HandleCommand<TCommand>(TCommand command) where TCommand : ICommand
    {
        using(var scope = _container.BeginLifetimeScope("my-command-scope"))
        {
          var handler = scope.Resolve<ICommandHandler<TCommand>>();
          handler.Handle(command);
        }
    }