Injecting and Resolving dependencies in AspNet Core

---

Welcome! Spanish articles on LinkedIn. You can follow me on Twitter for news.

---

Table of Contents

1. Benefits of Dependency Injection
2. Components of Microsoft Dependency Injection
3. Example
4. Constructor injection
   • Controllers
   • Middleware
   • Filters
   • Tag Helpers
   • View Components
   • Razor Page Models
   • Razor Views
5. 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. 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.

    public interface IExampleDependency
    {
        Guid Code { get; }
    }

    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.

    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

    [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.

    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.

    app.UseMiddleware<CustomMiddleware>(); 

Filters

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

    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.

    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.

    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.

    @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.

    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.

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

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

    @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

    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.

    @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.

    [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!