How to inject ISession into Repository correctly?

Question

Please correct me on the following scenario. ( Question is at the end)

(I asked a similar question that was un-organized and it was voted to close. So I have summarized the question here into a scope that can be replied with exact answers.)

I am developing a web application with multiple layers using nhibernate as ORM. My layer structure is as follow

1. Model Layer
2. Repository Layer
3. Services Layer
4. UI Layer

with the above layers, the classes and interfaces are placed as below.

ProductController.cs (UI Layer)

public class ProductController : Controller
{
    ProductServices _ProductServices;
    NHibernate.ISession _Session;

    public ProductController()
    {
        _Session = SessionManager.GetCurrentSession();

        _ProductServices = new ProductServices(
            new ProductRepository(), _Session);
    }
    // Cont..
 }

ProductServices.cs (Service Layer)

public class ProductServices : IProductServices
{
    protected IProductRepository _ProductRepository;
    protected NHibernate.ISession _Session;

    public ProductServices(IProductRepository productRepository,
        NHibernate.ISession session)
    {
        _ProductRepository = productRepository;
        _Session = session;
        _ProductRepository.SetSession(_Session);
    }

    // cont...
}

ProductRepository.cs (Repository Layer)

public class ProductRepository : IProductRepository
{
    NHibernate.ISession _Session;

    public void SetSession(NHibernate.ISession session)
    {
        _Session = session;
    }

    public IEnumerable<Product> FindAll()
    {
        return _Session.CreateCriteria<Product>().List<Product>();
    }

    //cont..
}

From the UI layer, I create the session as request per session and inject into service layer with the help of class constructor. Then set the session of repository with a help of a method.

I am afraid if I pass the _Session directly to repository as constructor, I will not have the control over it under the service layer. Also there is a future extension plan for using a webservice layer.

** Is there a way to ensure in each method of ProductRepository class that _Session is set already, without writing the piece of code if(_Session==null) in each and every method as it is repeating the same code.

** If the above pattern is wrong, Please show me a right way to achieve this goal.

Answer 1

What you are doing amazed me a bit. You applying the constructor injection pattern in the ProductService, which is definitely the way to go. On the other hand you are not injecting the dependencies into the ProductController, but that class is requesting one of those dependencies through a static class (this is the Service Locator anti-pattern) and creates a ProductServices class itself. This makes this class hard to test and makes your application less flexible and maintainable, since you can't easily change, decorate or intercept the use of the ProductServices class, when it's been used in multiple places.

And although you are (correctly) using constructor injection for the dependencies in the ProductServices, you are passing those dependencies on to the product repository, instead of applying the constructor injection pattern on the ProductResopistory as well.

Please show me a right way to achieve this goal.

The right way is to apply the constructor injection pattern everywhere. When you do this, your code will start to look like this:

public class ProductController : Controller
{
    private ProductServices _ProductServices;

    public ProductController(ProductServices services)
    {
        _ProductServices = services;
    }
    // Cont..
 }

public class ProductServices : IProductServices
{
    private IProductRepository _ProductRepository;

    public ProductServices(
        IProductRepository productRepository)
    {
        _ProductRepository = productRepository;
    }
    // cont...
}

public class ProductRepository : IProductRepository
{
    private ISession _Session;

    public ProductRepository (ISession session)
    {
        _Session = session;
    }

    public IEnumerable<Product> FindAll()
    {
        return _Session
            .CreateCriteria<Product>().List<Product>();
    }
    //cont..
}

See how each class only takes in dependencies that it uses itself. So the ProductController and ProductServices don't depend on ISession (I made the assumption that only ProductRepoistory needs ISession). See how -from a class's perspective- everything is much simpler now?

Did we actually solve a problem here? It seems like we just moved the problem of wiring all classes together up the dependency graph. Yes we did move the problem. And this is a good thing. Now each class can be tested in isolation, is easier to follow, and the application as a whole is more maintainable.

Somewhere in the application however, a ProductController must be created. This could look like this:

new ProductController(
    new ProductServices(
        new ProductRepository(
            SessionManager.GetCurrentSession())));

In its normal configuration, ASP.NET MVC will create controller classes for you, and it needs a default constructor to do so. If you want to wire up controllers using constructor injection (which you should definitely do), you need to do something 'special' to get this to work.

ASP.NET MVC allows you to override the default ControllerFactory class. This allows you to decide how to create controller instances. However, when your application starts to grow, it will get really awkward very quickly when you are creating your dependency graphs by hand (as my last example shows). In this case, it would be much better to use a Dependency Injection framework. Most of them contain a feature / package that allows you to integrate it with ASP.NET MVC and automatically allows to use constructor injection on your MVC controllers.

Are we done yet? Well... are we ever? There's one thing in your design that triggered a flag in my brain. Your system contains a class named ProductServices. Although a wild guess, the name Services seems like you wrapped all product related business operations inside that class. Depending on the size of your system, the number of people on your team, and the amount of changes you need to make, this might get problematic. For instance, how to you effectively apply cross-cutting concerns (such as logging, validation, profiling, transaction management, fault tolerance improvements) in such way that to system stays maintainable?

So instead of wrapping all operations in a single ProductServices class, try giving each business transaction / use case its own class and apply the same (generic) interface to all those classes. This description might be a bit vague, but it is a great way to improve the maintainability of small and big systems. You can read more about that here.

Answer 2

You can use a dependency injection container such as Autofac to instantiate your session and manage the lifetime of it. Leave the responsibility of instantiating the session to Autofac and simply inject the ISession interface into any classes that require the dependency. Have a look at this post: Managing NHibernate ISession with Autofac

You will also find this wiki page useful about configuring Autofac with MVC3: http://code.google.com/p/autofac/wiki/MvcIntegration3