如何摆脱这段代码中的反射调用？

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，和以前一样。

顺便说一句 - 我测试过这一点，它的工作原理，这里是全码： -

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); 
    } 
} 

- 更新 -

正如彼得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 
}