Castle Windsor configuring a factory

Question

I have a scenario that I don't know how best to resolve with Castle. I am trying to resolve types based on an id that is retrieved from an external system. The tricky part is that multiple id's relate to the same concrete type.

Here is what I have come up with so far. This just feels a bit wrong. I don't like the fact that I needed to call ResolveAll.

    [TestFixture]
public class TestWindsor
{

    [Test]
    public void AddGreenResolverToContainer_ShouldResolveCorrectTypeAndTypeId()
    {
        //---------------Set up test pack-------------------
        IWindsorContainer container = new WindsorContainer();
        //---------------Assert Precondition----------------

        //---------------Execute Test ----------------------
        container.Register(Component.For<IResolver>()
                               .ImplementedBy<TestOneResolver>()
                               .DependsOn(new {typeId = "1"}));
        //---------------Test Result -----------------------
        var actual = container.Resolve<IResolver>();
        Assert.IsInstanceOf<TestOneResolver>(actual);
        Assert.AreEqual("1", actual.typeId);
    }

    [Test]
    public void AddTwoNamedGreenResolverToContainer_ShouldResolveTwoTypes()
    {
        //---------------Set up test pack-------------------
        IWindsorContainer container = new WindsorContainer();
        //---------------Assert Precondition----------------

        //---------------Execute Test ----------------------
        container.Register(Component.For<IResolver>()
                               .ImplementedBy<TestOneResolver>()
                               .DependsOn(new {typeId = "1"}).Named("tageventstatusresolver"));
        container.Register(Component.For<IResolver>()
                               .ImplementedBy<TestOneResolver>()
                               .DependsOn(new {typeId = "2"}).Named("second"));            
        container.Register(Component.For<IResolver>()
                               .ImplementedBy<TestTwoResolver>()
                               .DependsOn(new {typeId = "1122"}).Named("redFirst"));
        container.Register(Component.For<IResolverFactory>()
                                    .ImplementedBy<ResolverFactory>()
                                    .DependsOn(new { resolvers=container.ResolveAll<IResolver>()}));


        //---------------Test Result -----------------------
        var actual = container.Resolve<IResolverFactory>();
        var resolver = actual.Create("1");
        Assert.IsInstanceOf<TestOneResolver>(resolver);
    }

}


public interface IResolverFactory
{
    IResolver Create(string typeId);
}

public class ResolverFactory : IResolverFactory
{
    private readonly IResolver[] _resolvers;

    public ResolverFactory(IResolver[] resolvers)
    {
        _resolvers = resolvers;
    }

    public IResolver Create(string typeId)
    {
        return _resolvers.Where(resolver => resolver.typeId == typeId).FirstOrDefault();
    }
}

public enum ResolutionStatus
{
    Red,
    Green,
    Amber
}

public interface IResolver
{
    string typeId { get; }
    ResolutionStatus Resolve();
}

public class TestOneResolver : IResolver
{
    public TestOneResolver(string typeId)
    {
        this.TypeId = typeId;
    }

    public string TypeId { get; private set; }

    public ResolutionStatus Resolve()
    {
        return ResolutionStatus.Green;
    }
}

public class TestTwoResolver : IResolver
{
    public TestTwoResolver(string typeId)
    {
        TypeId = typeId;
    }

    public string TypeId { get; private set; }

    public ResolutionStatus Resolve()
    {
        return ResolutionStatus.Red;
    }
}

Does anyone have suggestions as to a better way to do this?

Answer 1

Set component name as typeId value and follow this approach to have a typed factory creating by component name.