StructureMap - Inject Conditional Class - conditional-statements

Question

I have 1 interface named IProcessor having multiple implementations like ABCProcessor, PQRProcessor.
I want to make use of specific processor based on external parameters. How can I achive the same using StructureMap.
I am looking at named instances for the same.

Answer 1

You could use a factory pattern:
public interface IProcessorFactory
{
IProcessor Create(int dropDownValue);
}
public class ProcessorFactory : IProcessorFactory
{
private readonly IContainer _container;
public ProcessorFactory(IContainer container)
{
_container = container;
}
public IProcessor Create()
{
if(//your condition)
return _container.GetInstance<ABCProcessor>();
_container.GetInstance<PQRProcessor>();
}
}
(or simply inject the required dependencies instead of the container)
and then simply
private readonly IProcessorFactory _processorFactory;
public MvcController(IProcessorFactory processorFactory)
{
_processorFactory = processorFactory;
}
public void Method()
{
var processor = _processorFactory.Create();
}

Answer 2

The best solution to your problem is to hide the knowledge of the existence of multiple implementations and the selection between them from the consumer by implementing a proxy implementation for IProcessor:
public sealed ProxyProcessor : IProcessor
{
private readonly ABCProcessor abc;
private readonly PQRProcessor pqr;
private readonly IProcessorConfig config;
public ProxyProcessor(ABCProcessor abc, PQRProcessor pqr, IProcessorConfig config) {
this.abc = abc;
this.pqr = pqr;
this.config = config;
}
// Implement IProcessor methods to forward to the CurrentProcessor.
public void Process() => CurrentProcessor.Process();
private IProcessor CurrentProcessor => config.ProcessorType == "ABC" ? abc : pqr;
}
By doing this you can delegate to the correct implementation at runtime while the consumer stays oblivious to the fact that you make a decision at runtime about this. Now instead of injecting either an ABCProcessor or PQRProcessor into the consumers, you now inject a ProxyProcessor into the consumers. For instance, this is how the object graph for the ProxyProcessor could look like:
IProcessor processor =
new ProxyProcessor(
abc: new ABCProcessor(),
pqr: new PQRProcessor(),
config: new SqlProcessorConfig("constr"));
Note that this solution has several benefits over the use of a factory, such as:
It prevents having to make any changes to the consumers; the consumers stay oblivious.
It prevents introducing unneeded complexity into the consumers; with the factory approach, consumers have to deal with with an extra dependency. This complicates code and tests.
It causes object graphs to be constructed in a delayed fashion, which complicates verification of object graphs.
Please read this article if you want to know more about why factories hardly ever are the right abstraction.