Combining DI with constructor parameters?

Question

How do I combine constructor injection with "manual" constructor parameters? ie.

public class SomeObject {     public SomeObject(IService service, float someValue)     {     } } 

Where IService should be resolved/injected by my DI container, and someValue should be specified. How do I mix the two?

Answer 1

Such constructs should be avoided whenever possible. Therefore, ask yourself: is this parameter really required as constructor argument? Or can SomeObject be replaced by a stateless one which is reused by everyone that depends on it by passing the parameter to the method you execute on the object?

e.g. Instead of

public class SomeObject {     private float someValue     public SomeObject(IService service, float someValue)     {         this.someValue = someValue     }      public float Do(float x)     {         return this.Service.Get(this.someValue) * x;     } } 

use

public class SomeObject {     public SomeObject(IService service)     {     }      public float Do(float x, float someValue)     {         return this.Service.Get(someValue) * x;     } } 

---

If it is required go for a factory:

public interface ISomeObjectFactory {     ISomeObject CreateSomeObject(float someValue); }  public class SomeObjectFactory : ISomeObjectFactory {     private IKernel kernel;     public SomeObjectFactory(IKernel kernel)      {         this.Kernel = kernel;     }      public ISomeObject Create(float someValue)     {         return this.kernel.Get<ISomeObject>(WithConstructorArgument("someValue", someValue);     } } 

Preview: Ninject 2.4 won't require the implementation anymore but allow

kernel.Bind<ISomeObjectFactory>().ToFactory();  // or maybe .AsFactory(); 

Answer 2

You really shouldn't try to use D.I. for this. You could come up with all types of wacky solutions, but they may not make sense down the road.

Our approach is to create a factory via D.I., and the factory's Create method would then build itself out using the passed in D.I. container. We don't have to use this pattern often, but when we do it actually makes the product much cleaner (since it makes our dependency graphs smaller).