ASP.NET Core 2.0 Dependency Injection

Here we will learn how to use ASP.NET Core service container for dependency injection.

Solution

Create a Service.

public interface IGreetingService
{
    string Greet(string to);
}

public class GreetingService : IGreetingService
{
    public string Greet(string to)
    {
        return $"Hello {to}";
    }
}

Inject where required, I am using the Middleware created in a previous post.

public static class UseMiddlewareExtensions
{
    public static IApplicationBuilder UseHelloWorld(this IApplicationBuilder app)
    {
        return app.UseMiddleware();
    }
}

public class HelloWorldMiddleware
{
    private readonly RequestDelegate next;

    public HelloWorldMiddleware(
            RequestDelegate next)
    {
        this.next = next;
    }

    public async Task Invoke(
            HttpContext context,
            IGreetingService greetingService)
    {
        var message = greetingService.Greet("World (via DI)");
        await context.Response.WriteAsync(message);
    }
}

Add service to container using AddScoped() in ConfigureServices() method of Startup.cs.

public void ConfigureServices(
            IServiceCollection services)
{
    // setup dependency injection in service container
    services.AddScoped<IGreetingService, GreetingService>();
}

public void Configure(
            IApplicationBuilder app,
            IHostingEnvironment env)
{
    // setup request pipeline using middleware
    app.UseHelloWorld();
}

Let’s say your service implementation needs more complex setup. You could use the overload that accepts a factory method. Let’s say our service accepts a parameter.

public class FlexibleGreetingService : IGreetingService
{
    private readonly string sayWhat;

    public FlexibleGreetingService(string sayWhat)
    {
        this.sayWhat = sayWhat;
    }

    public string Greet(string to)
    {
        return $"{this.sayWhat} {to}";
    }
}

We can use factory method to add this to the service container.

public void ConfigureServices(
           IServiceCollection services)
{
    // setup dependency injection in service container
    services.AddScoped(factory =>
    {
        return new FlexibleGreetingService("Good Morning");
    });
}

In case of Singleton lifetime, an additional overload accepts an instance of service.

public void ConfigureServices(
     IServiceCollection services)
{
     // setup dependency injection in service container
     services.AddSingleton(
         new FlexibleGreetingService("Good Evening"));
}

Discussion

ASP.NET Core comes with a built-in lightweight service container. We configure our services in ConfigureServices() method of Startup.cs. As discussed in a previous post, this method runs before Configure() method, hence we can use our services when setting up any middleware (including MVC).

The default method of injection is via public constructors, which for most scenarios is considered best practice.

Service Lifetimes

Service container manages the lifetime of services added to it. Following are the methods to accomplish this.

• AddScoped() - These services are created once per request.
• AddTransient() - These services are created each time they are requested.
• AddSingleton() - These services are created the first time they are requested and stay the same for subsequent requests.

Note

EF should be added as Scoped or by using IServiceCollection.AddDbContext, which does this behind the scenes.

Factory Methods

All the above methods have an overload to add service using a factory method. This could be useful for services that require more complex setup, for instance - using Builder pattern.

Signature for these methods looks like: 

AddScoped(Func<IServiceProvider, TService>)

Framework Services

IServiceCollection being received by ConfigureServices() has various built-in services (provided by framework); refer to ASP.NET Core documentation.

There are also some useful extension methods on IServiceCollection to add commonly used services, for example:

AddDbContext, AddIdentity, AddOptions and AddMvc.

Disposing Services

Service container will call Dispose() on all types implementing IDisposable, except for services added as an instance rather than type.

Request Services

Although injecting services via constructor is considered the best practice, you could also retrieve the services using GetService() method on IServiceProvider, which can be accessed via HttpContext.

public class HelloDevelopersMiddleware
{
    private readonly RequestDelegate next;

    public HelloDevelopersMiddleware(
        RequestDelegate next)
    {
        this.next = next;
    }

    public async Task Invoke(
        HttpContext context)
    {
        var greetingService =
               context.RequestServices.GetService<IGreetingService>();
        var message = greetingService.Greet("Developers (via GetService)");
        await context.Response.WriteAsync(message);
    }
}

Note

Add a "using" statement for Microsoft.Extensions.DependencyInjection to access the generic version of GetService() method.

Source Code

GitHub