How to specify a service override further down the dependency graph in Castle Windsor?

Question

Here is a simplification of my scenario.

I have some interfaces IFoo , IBar , and IBaz with their implementations Foo , Bar and Baz .

Foo depends on IBar and Bar depends on IBaz , so the dependency graph looks like this:

   Foo 
    |
   Bar
    |
   Baz

My Windsor config looks like this, and everything works as expected:

container.Register(Component.For<IFoo>().ImplementedBy<Foo>());
container.Register(Component.For<IBar>().ImplementedBy<Bar>());
container.Register(Component.For<IBaz>().ImplementedBy<Baz>());

Now I need to introduce a new SpecialBaz , and I want to use it instead of the old Baz when my dependency graph begins with a Foo . The rest of the app will continue to the the old Baz :

      Foo           SomethingElse
       |                  |
      Bar                Bar
       |                  |
   SpecialBaz            Baz

I have tried naming the SpecialBaz with the ServiceOverride api:

container.Register(Component.For<IBaz>().ImplementedBy<Baz>().IsDefault());
container.Register(Component.For<IBaz>().Named("special baz").ImplementedBy<SpecialBaz>());

container.Register(Component.For<IFoo>()
                            .ImplementedBy<Foo>()
                            .DependsOn(ServiceOverride.ForKey<IBaz>().Eq("special baz")));

And specifying the dependency:

container.Register(Component.For<IBaz>().ImplementedBy<Baz>().IsDefault());
container.Register(Component.For<IBaz>().ImplementedBy<SpecialBaz>());

container.Register(Component.For<IFoo>()
                            .ImplementedBy<Foo>()
                            .DependsOn(Component.For<IBaz>().ImplementedBy<SpecialBaz>()));

But neither approach worked.

Is this possible in Castle Windsor, and how do I wire it up?

Answer 1

The short answer is yes - Castle Windsor can. Every DI container can. I will offer you a rule to remember by which you can resolve most of your dependency problems.

The long answer.

The rule : Every point of indirection requires a layer of abstraction . Keep this rule in mind when you try to build dependency resolutions in apps. And there are two kinds of indirections as far as I know - static and dynamic.

You need to change the graph at one point and only once ( indirections ) but somehow you need to traverse the dependecies graph at runtime to see if your Baz is requested for Foo or not. So you need a factory of some kind( the abstraction thingie ).

You have two options depending on the answer of one question:

Is my change dependent on static or dynamic conditions?

For example - If you depend on incoming user data or environment data - you are in the dynamic case in which you will need yo use Dynamic Parameters or something else capable.

In your case your dependency is static.

and I want to use it instead of the old Baz when my dependency graph begins with a Foo.

The condition for special Baz never changes once the beginning of the graph is Foo.

You can achieve this with Factory method or Typed Factory Componend Selector. I provide you an example with Factory Method :

using System;
using Castle.MicroKernel.Registration;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            var container = new Castle.Windsor.WindsorContainer();
            container.Register(Component.For<IFoo>().ImplementedBy<Foo>());
            container.Register(Component.For<ISomethingElse>().ImplementedBy<SomethingElse>());

            container.Register(Component.For<IBar>().ImplementedBy<Bar>().LifeStyle.Transient);

            container.Register
            (
                Component
                .For<IBaz>()
                .UsingFactoryMethod
                (
                    (k, c) =>
                    {
                        IBaz resolved = null;
                        var requestingType = c.Handler.ComponentModel.Implementation;
                        if (requestingType == typeof(Foo))
                        {
                            resolved = new Baz();
                        }
                        else
                        {
                            resolved = new BazSpecial();
                        }

                        return resolved;
                    }
                ).LifeStyle.Transient
            );

            var f = container.Resolve<IFoo>();
            var se = container.Resolve<ISomethingElse>();

            Console.ReadLine();
        }
    }
    internal interface IBar
    {
    }

    internal interface IBaz
    {
    }

    internal interface IFoo
    {
    }

    interface ISomethingElse
    {

    }


    internal class Bar : IBar
    {
        private readonly IBaz baz;

        public Bar(IBaz baz)
        {
            this.baz = baz;
        }

    }

    internal class Baz : IBaz
    {
    }

    internal class BazSpecial : IBaz
    {
    }

    internal class Foo : IFoo
    {
        private readonly IBar bar;

        public Foo(IBar bar)
        {
            this.bar = bar;
        }
    }

    internal class SomethingElse : ISomethingElse
    {
        private readonly IBar bar;

        public SomethingElse(IBar bar)
        {


         this.bar = bar;
        }
    }
}}