Question

I’m attempting to inject a dependency that varies by the state passed in. For example, if the state is Wisconsin, I want to inject one class, but if it’s Illinois, I want another. It’s not 1-for-1, but 7 states for one and 3 for another.

Is there a way in Spring.net to have a list of values to check against in the config xml?

Answer 1

This is the subject of chapter 6.1 “Mapping runtime values to abstractions” of the book Dependency Injection in .NET. The solution suggested there is to use an Abstract Factory. Your abstract factory might look like:

public interface IStateAlgorithmFactory
{
    IStateAlgorithm Create(string state);
}

And inject this factory on your consumer that knows which state to process. To get an IStateAlgorithm his consumer then calls y

alg = _factory.Create("Illnois");

Optionally, you could create a simple factory that maps state names to instances managed by your spring container if you want full configuration control.

Simple example

I imagine you have several classes that implement a certain IStateAlgorithm:

public interface IStateAlgorithm
{
    string ProcessState(string stateName);
}

public class EchoingStateAlgorithm : IStateAlgorithm
{
    public string ProcessState(string stateName)
    {
        return stateName;
    }
}

public class ReverseEchoingStateAlgorithm : IStateAlgorithm
{
    public string ProcessState(string stateName)
    {
        return new string(stateName.Reverse().ToArray());
    }
}

And that there is a certain Consumer that needs to pick an algorithm based on a runtime value. The consumer can be injected with a factory, from which it can retrieve the algorithm it needs:

public class Consumer
{
    private readonly IStateAlgorithmFactory _factory;

    public Consumer(IStateAlgorithmFactory factory)
    {
        _factory = factory;
    }

    public string Process(string state)
    {
        var alg = _factory.Create(state);
        return alg.ProcessState(state);
    }
}

A simple factory implementation would simply switch on the state value, use an if, or look in internal list:

public interface IStateAlgorithmFactory
{
    IStateAlgorithm Create(string state);
}

public class StateAlgorithmFactory : IStateAlgorithmFactory
{
    private string[] _reverseStates = new[] {"Wisconsin", "Alaska"};

    public IStateAlgorithm Create(string state)
    {
        if(_reverseStates.Contains(state))
            return new ReverseEchoingStateAlgorithm();

        return new EchoingStateAlgorithm();
    }
}

Spring.Net Configurable example

If you would like to be able to configure your IStateAlgorithm in your spring configuration, you can introduce a LookupStateAlgorithmFactory. This example assumes that your IStateAlgorithms are stateless and can be shared among consumers:

public class LookupStateAlgorithmFactory : IStateAlgorithmFactory
{
    private readonly IDictionary<string, IStateAlgorithm> _stateToAlgorithmMap;
    private readonly IStateAlgorithm _defaultAlgorithm;

    public LookupStateAlgorithmFactory(IDictionary<string, IStateAlgorithm> stateToAlgorithmMap, 
                                        IStateAlgorithm defaultAlgorithm)
    {
        _stateToAlgorithmMap = stateToAlgorithmMap;
        _defaultAlgorithm = defaultAlgorithm;
    }

    public IStateAlgorithm Create(string state)
    {
        IStateAlgorithm alg;
        if (!_stateToAlgorithmMap.TryGetValue(state, out alg))
            alg = _defaultAlgorithm;

        return alg;
    }
}

The xml config could be:

<object id="lookupFactory"
        type="LookupStateAlgorithmFactory, MyAssembly">
  <constructor-arg ref="echo" />
  <constructor-arg>
    <dictionary key-type="string" value-type="IStateAlgorithm, MyAssembly">
      <entry key="Alaska" value-ref="reverseEcho"/>
      <entry key="Wisconsin" value-ref="reverseEcho"/>
    </dictionary>
  </constructor-arg>
</object>

<object id="echo" type="EchoingStateAlgorithm, MyAssembly" />
<object id="reverseEcho" type="ReverseEchoingStateAlgorithm, MyAssembly" />