Benefit of using Dependency Injection inside ASP.NET Core MVC

Question

I am reading this article about using DI inside ASP.NET Core @ https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-6.0 .. but i can not understand its benefit of providing abstraction level.

for example without DI, we will have those classes:-

public class MyDependency
{
    public void WriteMessage(string message)
    {
        Console.WriteLine($"MyDependency.WriteMessage called. Message: {message}");
    }
}

public class IndexModel : PageModel
{
    private readonly MyDependency _dependency = new MyDependency();

    public void OnGet()
    {
        _dependency.WriteMessage("IndexModel.OnGet");
    }
}

and with DI we will have those classes:-

public interface IMyDependency
{
    void WriteMessage(string message);
}
public class MyDependency : IMyDependency
{
    public void WriteMessage(string message)
    {
        Console.WriteLine($"MyDependency.WriteMessage Message: {message}");
    }
}
public class Index2Model : PageModel
{
    private readonly IMyDependency _myDependency;

    public Index2Model(IMyDependency myDependency)
    {
        _myDependency = myDependency;            
    }

    public void OnGet()
    {
        _myDependency.WriteMessage("Index2Model.OnGet");
    }
}

but at the end with DI or without DI if i want to modify the WriteMessage method, to accept 2 strings instead of one as follow:-

public void WriteMessage(string message,string message2)
        {
            Console.WriteLine($"MyDependency.WriteMessage called. Message: {message}{message2}");
        }

i will have to modify the related classes; without DI case:-

public class IndexModel : PageModel
{
    private readonly MyDependency _dependency = new MyDependency();

    public void OnGet()
    {
        _dependency.WriteMessage("IndexModel.OnGet","two");
    }
}

with DI case:-

public class Index2Model : PageModel
{
    private readonly IMyDependency _myDependency;

    public Index2Model(IMyDependency myDependency)
    {
        _myDependency = myDependency;            
    }

    public void OnGet()
    {
        _myDependency.WriteMessage("Index2Model.OnGet","two");
    }
}

so not sure how using DI will create an abstraction between the WriteMessage implementation and the classes which consume it.. or i am understanding DI and its benefits wrongly?

Thanks

Answer 1

One of the primary benefits of using interfaces with dependency injection is the ability to easily mock the dependencies and make unit testing easier. Your test code merely needs to provide a non-functional object to stand in for the real thing so you can ensure the code you wrote in the controller does what you need it to. Without actually calling the classes you wrote to persist or retrieve data, you also avoid potentially corrupting your database with unit test data.

In some cases, you may have multiple implementations for the interface, and the interface simply defines the methods used to interact with the other implementations. The code using those implementations doesn't really care which one it is, and you can substitute the implementation based on subscription models or whatever other business reasons to do so.

Once you are used to the process, it's a lot easier to think through the interfaces and what needs to be done without worrying about how it needs to be done right then. The interfaces provide a means of defining the what so you don't lose focus on the code you are writing at the moment, and still be able to compile and run unit tests. You can go back later and implement the interface for a working system.