Inheriting ConstructorArguments in Ninject

I'm trying to find a method of passing a constructor argument to the constructors of child classes. These objects are immutable so I'd prefer to use constructor arguments.

The issue I have encountered is that ConstructorArgument does not inherit to child instantiations and the following statements are not interchangeable:

_parsingProcessor = _kernel.Get<IParsingProcessor>(new ConstructorArgument("dataFilePath", dataFilePath);

and

_parsingProcessor = _kernel.Get<IParsingProcessor>(new Parameter("dataFilePath", dataFilePath, true);

So, how can get an inheritable ConstructorArgument and when does it makes sense, if ever, to new the Parameter class?

Solution

Yes, you can do this, but it's probably not what you really want. If the container is not actually responsible for instantiating its own dependencies, then its dependencies probably shouldn't be sharing its constructor arguments - it just doesn't make sense.

I'm pretty sure I know what you're trying to do, and the recommended approach is to create a unique binding specifically for your one container, and use the WhenInjectedInto conditional binding syntax, as in the example below:

public class Hello : IHello
{
    private readonly string name;

    public Hello(string name)
    {
        this.name = name;
    }

    public void SayHello()
    {
        Console.WriteLine("Hello, {0}!", name);
    }
}

This is the class that takes a constructor argument which we want to modify, depending on who is asking for an IHello. Let's say it's this boring container class:

public class MyApp : IApp
{
    private readonly IHello hello;

    public MyApp(IHello hello)
    {
        this.hello = hello;
    }

    public virtual void Run()
    {
        hello.SayHello();
        Console.ReadLine();
    }
}

Now, here's how you do up the bindings:

public class MainModule : NinjectModule
{
    public override void Load()
    {
        Bind<IApp>().To<MyApp>();
        Bind<IHello>().To<Hello>()
            .WithConstructorArgument("name", "Jim");
        Bind<IHello>().To<Hello>()
            .WhenInjectedInto<MyApp>()
            .WithConstructorArgument("name", "Bob");
    }
}

Basically all this binding is doing is saying the name should be "Jim" unless it's being requested by Hello, which in this case it is, so instead it will get the name "Bob".

If you are absolutely certain that you truly want cascading behaviour and understand that this is very dangerous and brittle, you can cheat using a method binding. Assuming that we've now added a name argument to the MyApp class for some unspecified purpose, the binding would be:

Bind<IHello>().ToMethod(ctx =>
    ctx.Kernel.Get<Hello>(ctx.Request.ParentContext.Parameters
        .OfType<ConstructorArgument>()
        .Where(c => c.Name == "name")
        .First()));

Please, please, make sure you are positive that this is what you want before doing it. It looks easy but it is also very likely to break during a simple refactoring, and 95% of the "customized dependency" scenarios I've seen can be addressed using the WhenInjectedInto binding instead.