Article - ASP.NET Core Dependency Injection, with Unit Testing

Microsoft has done a good job of incorporating best practices into their newest web development framework: ASP.NET Core. One of which is baked-in Dependency Injection. If you're not familiar with it, follow that link for a good introduction. This tutorial assumes you're already familiar with it, and just want the quick-and-dirty. This shows you that, along with an example unit test.

Step one: Create your app

For this step, I used Visual Studio 2019 and created a new ASP.NET Core web application. This will eventually be used as a new web-interface for my home-grown banking application called Quid. In this case, I called my new app "QuidWebTest1". As a side-note: I created a separate DLL project (QuidData) containing the Quid Data Access Layer (DAL), and EntityFramework classes.

Create your interface, and concrete class

A typical DI implementation would involve some data access layer (DAL) that gets injected into the constructor of your controllers. This DAL can later be mocked to assist with unit tests. You begin by creating an interface that defines your methods for interacting with the database. Then at least one concrete implementation.

Here is my interface, which includes a single method that returns a list of my current Envelopes:

    public interface IQuidDAL
    {
        List<EnvelopeDetails> GetEnvelopeDetails(int accountId);
    }

And here is my concrete implementation that accesses the database:

    public class QuidDAL : IQuidDAL
    {
        public List<EnvelopeDetails> GetEnvelopeDetails(int accountId)
        {
            using (QuidData.EF.Quid_ReleaseContext context = new QuidData.EF.Quid_ReleaseContext())
            {
                List<EnvelopeDetails> envelopes = context.Envelopes.Where(e => e.Active??true && e.BankAccountId == accountId)
                    .Select(e => new EnvelopeDetails { Name = e.Name, EnvelopeId = e.EnvelopeId, BankAccountId = accountId }).ToList();

                return envelopes;
            }
        }
    }

Prep the Controller for dependency injection

This simply involves passing the interface to the constructor, and storing it in a member variable:

    public class HomeController : BaseController
    {
        private readonly IQuidDAL _quidDAL;

        public HomeController(IQuidDAL quidDAL)
        {
            _quidDAL = quidDAL;
        }

        ...
    }

Use the DAL in a method

This one's pretty straightforward. I added the following method to my HomeController:

        public IActionResult Envelopes()
        {
            return View(_quidDAL.GetEnvelopeDetails(CurrentBankId()));
        }

Wire up the DI!

Up to this point, this is all simple coding constructs that would appear in any DI-style web application: Create an interface and one concrete implementation. Pass the interface to Controller's constructor, use it in the publicly exposed method.

Now the ASP.NET Core magic: wire up the DI. This is done in Startup.ConfigureServices. There are three flavors of DI registration: Singleton, Transient, and Scoped. The differences are related to service lifetimes. For more details, see the Service lifetimes section here..

Since we're passing the dependency in the constructor of the controller, all we need is a call to AddScope as follows:

        public void ConfigureServices(IServiceCollection services)
        {
            ...
            services.AddScoped<IQuidDAL, QuidDAL>();
        }

How easy is that??! Compile and run, and see that it works.

Add a Unit Test

The real elegance of DI is seen during Unit Testing. I started by creating a new .Core testing project, then added library dependencies to QuidWebTest1 and QuidData.

Next, create a Mock of IQuidDAL:

    public class MockQuidDAL : QuidData.DAL.IQuidDAL
    {
        public List<EnvelopeDetails> GetEnvelopeDetails(int accountId)
        {
            List<EnvelopeDetails> list = new List<EnvelopeDetails>();
            list.Add(new EnvelopeDetails { Name = "Envelope1", EnvelopeId = 1 });
            list.Add(new EnvelopeDetails { Name = "Envelope2", EnvelopeId = 2 });
            return list;
        }
    }

Now, write your Unit Test, using this Mock:

        [TestMethod]
        public void TestGetEnvelopes()
        {
            // Arrange
            HomeController controller =
                new HomeController(new MockQuidDAL());

            // Act
            var viewResult = controller.Envelopes();

            // Assert
            // TODO
        }

And that's all there is to it. Kudos to Microsoft for baking in DI so well into ASP.NET Core.