How to Inject properly an IDBContextFactory into a controller's inject IDomainFactory using Ninject MVC3?

Question

Preliminaries

1. I'm using Ninject.MVC3 2.2.2.0 Nuget Package for injecting into my controller an implementation of a IDomain Interface that separates my Business Logic (BL) using an Factory approach.

2. I'm registering my Ninject Modules in the preconfigured NinjectMVC3.cs using:

   private static void RegisterServices(IKernel kernel)
   {
       var modules = new INinjectModule[]
       {
           new DomainBLModule(),
           new ADOModule()
       };
       kernel.Load(modules);
   }
   

3. I'm trying to avoid the fatal curse of the diabolic Service Locator anti-pattern.

The Domain Class uses a DBContext that i'm trying to inject an interface implementation too, via an IDBContext, with the following scenario:

IDomainBLFactory:

public interface IDomainBLFactory
{
    DomainBL CreateNew();
}

DomainBLFactory:

public class DomainBLFactory : IDomainBLFactory
{
    public DomainBL CreateNew()
    {            
        return new DomainBL();
    }
}

In the controller's namespace:

public class DomainBLModule : NinjectModule
{
    public override void Load()
    {
        Bind<IDomainBLFactory>().To<DomainBLFactory>().InRequestScope();
    }
}

At this point i can inject the IDomainBLFactory implementation into my controller using Ninject Constructor Injection without any problem:

public class MyController : Controller
{
    private readonly IDomainBLFactory DomainBLFactory;
    // Default Injected Constructor
    public MyController(IDomainBLFactory DomainBLFactory)
    {
        this.DomainBLFactory = DomainBLFactory;
    }
    ... (use the Domain for performing tasks/commands with the Database Context)
}

Now my central problem.

In the DomainBL implementation, i will inject the dependency to a particular DBContext, in this case ADO DBContext from Entity Framework, again, using a IDBContextFactory:

IDbDataContextFactory

public interface IDbDataContextFactory
{
    myADOEntities CreateNew();
}

DbDataContextFactory

public class DbDataContextFactory : IDbDataContextFactory
{
    public myADOEntities CreateNew()        
    {
        return new myADOEntities ();
    }
}

ADOModule

public class ADOModule : NinjectModule
{
    public override void Load()
    {
        Bind<IDbDataContextFactory>().To<DbDataContextFactory>().InRequestScope();
    }
}

Now in the DomainBL implementation I faced the problem of injecting the necessary interface for the DBContext Object Factory:

public class DomainBL
{
  private readonly IDbDataContextFactory contextFactory;
  **** OPS, i tried to understand about 10+ Stackoverflow articles ***
  ...
}

What have I tried?

1. To Use the constructor Injection. But I don't know what to inject in the call for the Factory CreateNew() in the IDBContextFactory. For clear:

   public class DomainBLFactory: IDomainBLFactory        
   {
       // Here the constructor requires one argument for passing the factory impl.
       public DomainBL CreateNew()
       {
           return new DomainBL(?????)  // I need a IDBContextFactory impl to resolve.
           //It's not like in the MVC Controller where injection takes place internally
           //for the controller constructor. I'm outside a controller
       }
   }
   

   In this Useful Post, our unique true friend Remo Gloor describes in a comment a possible solution for me, citing: "Create an interface that has a CreateSomething method that takes everything you need to create the instance and have it return the instance. Then in your configuration you implement this interface and add an IResolutionRoot to its constructor and use this instace to Get the required object."

   Questions: How do I implement this in a proper way using Ninject.MVC3 and my modest Domain Class approach? How do I Resolve the IResolutionRoot without be punished for relaying in the Service Locator anti-pattern?

2. To Use the property injection for an IDBContexFactory. In the course of learning and reading all the contradictory points of view plus the theoretical explanations about it, I can deduce it's not a proper way of doing the injection for my DBContexFactory class code. Nevermind. It doesn't work anyway.

   public class DomainBL
   {
   
     [Inject]
     public IDbDataContextFactory contextFactory
     {
         get;
         set;
     }
     //Doesn't works, contextFactory is null with or without parameterless constructor
     .... (methods that uses contextFactory.CreateNew()....
   
   }
   

   Question: What am I missing? Even if this approach is wrong the property is not injecting.

3. Be cursed. Use a DependencyResolver and live with the stigmata. This works and I will remain in this approach until a proper solution appears for me. And this is really frustrating because the lack of knowledge in my last 10 days effort trying to understand and do things right.

   public class DomainBL
   {
     private readonly IDbDataContextFactory contextFactory;
     this.contextFactory = DependencyResolver.Current.GetService<IDbDataContextFactory>();
     //So sweet, it works.. but i'm a sinner.
   
   }
   

   Question: Is there a big mistake in my understanding of the Factory Approach for the injection of interfaced implementations and using a Domain Driven Approach for taking apart the Business Logic? In the case I'm wrong, what stack of patterns should I implement with confidence?

   I saw before a really big quantity of articles and blogs that does not ask this important question in a open a clear way.

---

Remo Gloor introduces the Ninject.Extensions.Factory for the Ninject 3.0.0 RC in www.planetgeek.ch/2011/12/31/ninject-extensions-factory-introduction.

Question: Will this extension work coupled with Ninject.MVC3 for general porpouse?. In such case it should be my hope for the near future.

Thank you all in advance for your guidance and remember we appreciate your kind help. I think a lot of people will find this scenario useful too.

Answer 1

Here's an implementation of a generic IFactory to solve the problem without resorting to the ServiceLocator anti-pattern.

First you define a nice generic factory interface

  public interface IFactory<T>
  {
    T CreateNew();
  }

And define the implementation which uses ninject kernel to create the objects requested

  class NinjectFactory<T> : IFactory<T>
  {
    private IKernel Kernel;

    public NinjectFactory( IKernel Kernel )
    {
      this.Kernel = Kernel;
    }

    public T CreateNew()
    {
      return Kernel.Get<T>();
    }
  }

Binding to your factory using the following

  private static void RegisterServices(IKernel kernel)
  {
    kernel.Bind<myADOEntities>().ToSelf();
    kernel.Bind<DomainBL>().ToSelf();
    kernel.Bind(typeof(IFactory<>)).To(typeof(NinjectFactory<>));
  }        

You can now do the following in your controller.

  public class MyController : Controller
  {
    private readonly IFactory<DomainBL> DomainBLFactory;

    public MyController( IFactory<DomainBL> DomainBLFactory )
    {
      this.DomainBLFactory = DomainBLFactory;
    }

    // ... (use the Domain for performing tasks/commands with the Database Context)
  }

And in your DomainBL

  public class DomainBL
  {
    IFactory<myADOEntities> EntitiesFactory;

    public DomainBL( IFactory<myADOEntities> EntitiesFactory )
    {
      this.EntitiesFactory = EntitiesFactory;
    }

    // ... (use the Entities factory whenever you need to create a Domain Context)
  }

Answer 2

I don't really get the purpose of your factories. Normally, you have exactly one ObjectContext instance for one request. This means you don't need the factory and can simply bind myADOEntities in Request scope and inject it into your DomainBL without adding the factories:

Bind<myADOEntities>().ToSelf().InRequestScope();
Bind<DomainBL>().ToSelf().InRequestScope();

And Yes the factory and mvc extrensions work together.