ASP.NET MVC and Service Layer Dependency Injection

Question

I have some problems with constructors in controller and service that is called by controller.

This is my service:

// model state dictionary for validation
private ModelStateDictionary _modelState;

// initialize UnitOfWork
private IUnitOfWork _unitOfWork;

public TownService(ModelStateDictionary modelState, IUnitOfWork unitOfWork)
{
    _modelState = modelState;
    _unitOfWork = unitOfWork;
}

Now in my controller I want to create new service, pass controller this.ModelState but don't want to add UnitOfWork inside controller.

Something like this:

private ITownService _townService;

public TownController()
{
    _townService = new TownService(this.ModelState, null);
}

so that everything considering UnitOfWork is done inside service. Controller just passes its own modelState and service is one that creates new UnitOfWork.

Is that possible and also good way? How can I achieve that? Or should I add new UnitOfWork instead of null parameter in controller?

Because I want to separate Core, DAL, Web as much as possible so that everything does its part and with adding UnitOfWork in both controller and service seems like its not good way...

Thanks.

haim770 · Accepted Answer · 2017-12-21T09:59:55.553

Dependency Injection:

First, you have to correctly grasp the concept of 'Dependency Injection':

public TownController()
{
    _townService = new TownService(this.ModelState, null);
}

TownController isn't getting any dependency injected to it, and you're instantiating _townService using a hard-coded TownService implementation.

It should look more like this:

private ITownService _townService;

public TownController(ITownService townService)
{
    _townService = townService;
}

As you can see, ITownService implementation is being injected into the controller (using its constructor).

Now, if your injected dependency (ITownService) has its own dependencies (IUnitOfWork), it doesn't mean that your controller has to get injected all those dependencies as well, because when ITownService is injected to the controller, it is already initialized and its dependencies have already been injected to it.

Most people use Dependency Injection Frameworks to achieve all that (and much more), here's a simple Unity example for ASP.NET MVC:

// some code omitted for brevity
internal static class DependencyResolvingConfig
{
    internal static IUnityContainer Configure()
    {
        var container = new UnityContainer();
        RegisterTypes(container);
        DependencyResolver.SetResolver(new UnityDependencyResolver(container));
        return container;
    }

    internal static void RegisterTypes(IUnityContainer container)
    {
        container.RegisterType<IUnitOfWork, UnitOfWork>();
        container.RegisterType<ITownService, TownService>();
    }
}

This line:

DependencyResolver.SetResolver(new UnityDependencyResolver(container));

Is telling ASP.Net MVC that whenever it instantiating a new controller with dependency, it will ask UnityDependencyResolver to provide the implementation, Unity will then do that according to the configuration above.

ModelStateDictionary:

Another problem is that your service layer is using ModelStateDictionary:

The concept of a ModelState is (generally) the presentation-layer concern and is used for validation and getting/setting errors back/from the UI (traditionally HTML forms).

You should check and validate the Model State in your controllers, and then (usually only if it's valid) you call the service layer to perform the actual action.

Also, you'd have to add a reference to System.Web.Mvc Assembly solely for the purpose of ModelState usage (which is not recommended).

Nice answer :) I have set up my service layer with DI of the IUnitOfWork and it is working fine. However I would like to ask you something...I am wondering if the IUnitOfWork injected is a singleton? I would like the same UnifOfWork all along the controllers for the same transaction. I'm new to DI and I'm a little bit confused..... — Alvykun, Dec 21 '17 at 09:27
@Alvykun, In the case of web/application servers, a "Unit of work" is usually associated with an Http request. Most frameworks use the term "lifetime" or "scope" to define how objects are created (or reused). So, your desired "Singleton" would actually be some kind of a `PerRequestLifeTime` (In Unity, for example: https://msdn.microsoft.com/en-us/library/microsoft.practices.unity.perrequestlifetimemanager(v=pandp.30).aspx) — haim770, Dec 21 '17 at 09:59
thanks for you answer. The `PerRequestLifeTime` is located inside the the Unity.Mvc nuget package. I am using the Unity one as my project is a web api 2. I have found that `PerThreadLifeTimeManager` works as well...But I am not sure if my whole IoC set up is correctly done.... `container.RegisterType(new PerThreadLifetimeManager()); container.RegisterType(new HierarchicalLifetimeManager()); container.RegisterType(new HierarchicalLifetimeManager());` — Alvykun, Dec 22 '17 at 02:57

ASP.NET MVC and Service Layer Dependency Injection

1 Answers1