Question

public interface IProcessor<T> {   void Process(T instance); }   foreach(AbstractType instance in myClass.SomeCollection)   OnProcess(instance);  public void OnProcess<T>(T instance) {   IProcessor<T> processor =      unityContainer.Resolve<IProcessor<T>>();   processor.Process(instance); } 

The problem with this code is that the in OnProcess is always AbstractType, and not the concrete type of the instance being passed. I currently see two possibilities.

01: Create a non generic IProcessor and use it as the base for IProcessor. Any implementor will have to implement both generic and non-generic Process methods, typically typecasting and passing onto the generic method.

02: Use Type.MakeGenericType to get the IProcessor, resolve that, and then use reflection to invoke the Process method.

Both of these approaches feel a bit ‘unclean’. Can anyone think of a way I can do this without having to resort to these practices?

Thanks

Pete

Answer 1

2 will be a performance killer (the necessary dynamic/relection invoke in particular is slow)

1 is a common answer to this problem, especially with explicit implementation; the problem is getting hold of the type… does unity allow query with a Type instance, rather than via generics? If so something like below… of course, you might still have to use MakeGenericType:

Type intType = typeof(IProcessor<>).MakeGenericType(instanceType); IProcessor proc = (IProcessor) IoC.Resolve(intType); 

Where instanceType is perhaps via instance.GetType(). For similar reasons, it might be helpful to expose the T as a Type on the IProcessor:

public interface IProcessor {     void Process(object instance);     Type InstanceType {get;} } public interface IProcessor<T> : IProcessor {     void Process(T instance); } class SomeClass: IProcessor<int> {     public void Process(int instance)     {         throw new NotImplementedException();     }     Type IProcessor.InstanceType {get {return typeof(int);}}     void IProcessor.Process(object instance)     {         Process((int)instance);     } } 

Of course, an (optional) base-class might allow you to avoid some of this per-implementation:

abstract class SomeBase<T> : IProcessor<T> {     public void Process(T instance)     {         OnProcess(instance);     }     Type IProcessor.InstanceType {get {return typeof(T);}}     void IProcessor.Process(object instance)     {         Process((T)instance);     }     protected abstract void OnProcess(T instance); }