如何在这段代码中去掉反射调用?

Question

我正在构建一个简单的"总线"作为概念证明。我不需要任何复杂的东西，但我想知道如何最好地优化下面的代码。我使用Autofac作为容器来解析命令作为开放泛型，但实际上执行命令目前正在通过反射完成，因为传入命令不能转换为代码中的具体类型。参见代码-标记为//BEGIN//END -这是当前通过反射完成的。有没有一种方法可以做到这一点，而不使用反射?

// IoC wrapper
static class IoC {
    public static object Resolve(Type t) {
        // container gubbins - not relevant to rest of code.
    }
}
// Handler interface
interface IHandles<T> {
    void Handle(T command);
}
// Command interface
interface ICommand {
}
// Bus interface
interface IBus {
    void Publish(ICommand cmd);
}
// Handler implementation
class ConcreteHandlerImpl : IHandles<HelloCommand> {
    public void Handle(HelloCommand cmd) {
        Console.WriteLine("Hello Command executed");
    }
}
// Bus implementation
class BusImpl : IBus {
    public void Publish(ICommand cmd) {
        var cmdType = cmd.GetType();
        var handler = IoC.Resolve(typeof(IHandles<>).MakeGenericType(cmdType));
        // BEGIN SLOW
        var method = handler.GetType().GetMethod("Handle", new [] { cmdType });
        method.Invoke(handler, new[] { cmd });
        // END SLOW
    }
}

Answer 1

这样如何(仅显示更改的部分):-

// Handler interface
interface IHandles<T> where T : ICommand {
    void Handle(T command);
}
// Bus interface
interface IBus {
    void Publish<T>(T cmd) where T : ICommand;
}
// Bus implementation
class BusImpl : IBus {
    public void Publish<T>(T cmd) where T : ICommand {
        var handler = (IHandles<T>)IoC.Resolve(typeof(IHandles<T>));
        handler.Handle(cmd);
    }
}

这里的关键是使Publish方法泛型，这意味着您获得命令类型的类型引用T，然后可以使用它进行强制转换。类型参数约束只是确保只能传递ICommand，就像以前一样。

BTW -我已经测试了这个，它的工作，这里是完整的代码:-

public static void Main(){
   new BusImpl().Publish(new HelloCommand());
}
// IoC wrapper
static class IoC {
    public static object Resolve(Type t) {
        return new ConcreteHandlerImpl();
    }
}
// Handler interface
interface IHandles<T> where T : ICommand {
    void Handle(T command);
}
// Command interface
interface ICommand {
}

// Handler implementation
class ConcreteHandlerImpl : IHandles<HelloCommand> {
    public void Handle(HelloCommand cmd) {
        Console.WriteLine("Hello Command executed");
    }
}
public class HelloCommand:ICommand{}
// Bus interface
interface IBus {
    void Publish<T>(T cmd) where T : ICommand;
}
// Bus implementation
class BusImpl : IBus {
    public void Publish<T>(T cmd) where T : ICommand {
        var handler = (IHandles<T>)IoC.Resolve(typeof(IHandles<T>));
        handler.Handle(cmd);
    }
}

——

正如Peter Lillevold指出的那样，您还应该考虑向IOC容器方法添加类型参数，如下所示:-

// IoC wrapper
static class IoC {
    public static T Resolve<T>() {
        ...
    }
}

这将简化你的调用，像这样:-

// Bus implementation
class BusImpl : IBus {
    public void Publish<T>(T cmd) where T : ICommand {
        var handler = IoC.Resolve<IHandles<T>>();
        handler.Handle(cmd);
    }
}

这是你最初问题的一个侧面，但对于IOC接口来说似乎是一个明智的设计。

Answer 2

这样行吗?你的IoC是返回对象，考虑返回T，这样你就不必像下面那样处理类型歧义了。

public void Publish(ICommand cmd) {
    var cmdType = cmd.GetType();
    var handler = IoC.Resolve(typeof(IHandles<>).MakeGenericType(cmdType)) as IHandles<ICommand>;
    if (handler != null)
    {
        // BEGIN SLOW
        handler.Handle(command);
        // END SLOW
    }
    //else throw some exception
}