Injecting and Resolving dependencies in AspNet Core 
Tags: csharp, dotnet, aspnetcore
Published: 2019-11-06 19:02:46

---
title: Injecting and Resolving dependencies in AspNet Core 
published: true
description: How to retrieve and resolve dependencies in different ways in AspNet Core
tags: #csharp #dotnet #aspnetcore
---
***
*Welcome!* Spanish articles on [LinkedIn](https://www.linkedin.com/in/mpetrinidev/). You can follow me on [Twitter](https://twitter.com/mpetrinidev/) for news.
***

## Table of Contents
1. [Benefits of Dependency Injection](#benefits-of-dependency-injection)
2. [Components of Microsoft Dependency Injection](#components-of-microsoft-dependency-injection)
3. [Example](#example)
4. [Constructor injection](#constructor-injection)
    - [Controllers](#controllers)
    - [Middleware](#middleware)
    - [Filters](#filters)
    - [Tag Helpers](#tag-helpers)
    - [View Components](#view-components)
    - [Razor Page Models](#razor-page-models)
    - [Razor Views](#razor-views)
5. [Action Injection](#action-injection)


We are not going to dig into the main concepts of Dependency Injection, but I want to remember the main benefits.

## Benefits of Dependency Injection

- Loose coupling of components
- Logical abstraction of components
- Supports unit testing 
- Cleaner, more readable code

If you want to learn about Dependency Injection, I'd recommend [Steve Gordon's Pluralsight course]( https://www.pluralsight.com/courses/aspdotnet-core-dependency-injection). It's a perfect way to getting started.

## Components of Microsoft Dependency Injection

`IServiceCollection` defines a contract for register and configure a collection of service descriptors.

`IServiceProvider` provides a mechanism to retrieve a required service at runtime.

In this post, we are going to take a look at which elements of AspNet Core could retrieve and resolve dependencies.

### Example

We are going to use the following interface and concrete class as an example.

```cs
    public interface IExampleDependency
    {
        Guid Code { get; }
    }
```

```cs
    public class ExampleDependency : IExampleDependency
    {
        public Guid Code { get; } = Guid.NewGuid();
    }
```

Then, we register the service in our `ConfigureServices` method in the `Startup class` as scoped.

```cs
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddScoped<IExampleDependency, ExampleDependency>();
        //Code
    }
```

## Constructor injection

Dependencies can easy be injected via constructors. Remember that a `public` constructor is required. We can inject a dependency into the constructor of:

- Controllers
- Middleware
- Filters
- Tag Helpers
- View Components
- Razor page models
- Razor Views

### Controllers

```cs
    [ApiController]
    [Route("[controller]")]
    public class ValuesController : ControllerBase
    {
        private readonly ILogger<ValuesController> _logger;
        private readonly IExampleDependency _exampleDependency;

        public ValuesController(ILogger<ValuesController> logger, IExampleDependency exampleDependency)
        {
            _logger = logger;
            _exampleDependency = exampleDependency;
        }

        [HttpGet]
        public string Get()
        {
            return _exampleDependency.Code.ToString();
        }
    }
```

### Middleware

Middleware components are constructed once during the life of the application. We shouldn't inject short-lived scopes or transients services via the constructor. Our service is scope, so we need another solution. Middleware supports a second point of injection via the `InvokeAsync` method. This method is invoked on each request.

```cs
    public class CustomMiddleware
    {
        private readonly RequestDelegate _next;

        public CustomMiddleware(RequestDelegate next)
        {
            _next = next;
        }
        
        public async Task InvokeAsync(HttpContext httpContext, IExampleDependency exampleDependency)
        {
            httpContext.Response.Headers.Add("X-Code", exampleDependency.Code.ToString());
            await _next(httpContext);
        }
    }
```

Remember to configure the middleware in the `Configure` method in the `Startup` class.

```cs
    app.UseMiddleware<CustomMiddleware>(); 
```

### Filters

We can inject a service in the constructor of a filter. Let's take a look at this example.

```cs
    public class CustomAsyncFilter : IAsyncActionFilter
    {
        private readonly IExampleDependency _exampleDependency;

        public CustomAsyncFilter(IExampleDependency exampleDependency)
        {
            _exampleDependency = exampleDependency;
        }
        
        public async Task OnActionExecutionAsync(
            ActionExecutingContext context,
            ActionExecutionDelegate next)
        {
            // Do something before the action executes.
            context.HttpContext.Response.Headers.Add("X-Code-Filter", _exampleDependency.Code.ToString());

            // next() calls the action method.
            var resultContext = await next();
            // resultContext.Result is set.
            // Do something after the action executes.
        }
    }
```

Remember to configure the service in the `ConfigureServices` method in the `Startup` class. 

```cs
    services.AddControllers(opt => { opt.Filters.Add(typeof(CustomAsyncFilter)); });
```

We are adding the `CustomAsyncFilter` *by type* and not by instance.


### Tag Helpers

Tag helpers enable server-side code to participate in creating and rendering HTML elements in Razor files.

```cs
    public class TitleTagHelper : TagHelper
    {
        private readonly IExampleDependency _exampleDependency;

        public TitleTagHelper(IExampleDependency exampleDependency)
        {
            _exampleDependency = exampleDependency;
        }

        public override void Process(TagHelperContext context, TagHelperOutput output)
        {
            output.TagName = "h1";
            output.AddClass("display-4", HtmlEncoder.Default);
            output.Content.SetContent($"Welcome {_exampleDependency.Code.ToString()}");
        }
    }
```

And then, on your Razor page.

```cs
    @page
    @model IndexModel
    @{
        ViewData["Title"] = "Home page";
    }

    <div class="text-center">
        <title></title>
        <p>Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
    </div>
```


### View Components

View components are similar to partial views, but they are much more powerful.

```cs
    public class CustomViewComponent : ViewComponent
    {
        private readonly IExampleDependency _exampleDependency;

        public CustomViewComponent(IExampleDependency exampleDependency)
        {
            _exampleDependency = exampleDependency;
        }

        public Task<IViewComponentResult> InvokeAsync()
        {
            return Task.FromResult((IViewComponentResult)View("Default", _exampleDependency.Code.ToString()));
        }
    }
```

Then, create the Razor page for the custom view component under `Pages/Components/Custom/Default.cshtml.`

```cs
    @model string
    <h1 class="display-4">@Model</h1>
```

Finally, use the custom view component in the Razor page.


```cs
    @page
    @model IndexModel
    @{
        ViewData["Title"] = "Home page";
    }

    <div class="text-center">
        @await Component.InvokeAsync("Custom");

        <p>Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
    </div>
```


### Razor page models

Razor page models is the same that controller injection

```cs
    public class IndexModel : PageModel
    {
        private readonly ILogger<IndexModel> _logger;
        private readonly IExampleDependency _exampleDependency;

        public IndexModel(ILogger<IndexModel> logger, IExampleDependency exampleDependency)
        {
            _logger = logger;
            _exampleDependency = exampleDependency;
        }

        public void OnGet()
        {
            ViewData["code"] = _exampleDependency.Code;
        }
    }
```

### Razor views 

In razor views, we use the `@inject` directive to inject a service in a view.

```cs
    @page
    @using WebApplication2.Demo
    @model IndexModel
    
    //Here
    @inject IExampleDependency _exampleDependency

    @{
        ViewData["Title"] = "Home page";
    }

    <div class="text-center">
        <h1 class="display-4">Welcome @_exampleDependency.Code.ToString()</h1>
        <p>Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
    </div>
```

## Action Injection

AspNet Core controllers supports a second point of injection called action injection.

It's a common practice to use action injection over constructor injection when you need to use a service only once time on an action.

We have to apply `[FromServices]` attribute to tell that this parameter is coming from dependency injection.


```cs
    [ApiController]
    [Route("[controller]")]
    public class ValuesController : ControllerBase
    {
        private readonly ILogger<ValuesController> _logger;

        public ValuesController(ILogger<ValuesController> logger)
        {
            _logger = logger;
        }

        [HttpGet]
        public string Get([FromServices] IExampleDependency exampleDependency)
        {
            return exampleDependency.Code.ToString();
        }
    }
```

I think that there are common ways to inject and resolve dependencies in AspNet Core. 

Am I forgetting some? Leave your comment below!