Dependency Injection in Asp.Net Core

Table of Content

What is Dependency Injection?

Dependency Injection technique is used tocreate a maintainable code in .Net Core.The Dependency Injection provides extensive support in .Net Core, it depends onyou how to apply it. The class and their dependencies to achieve inversion of controlin dependency injection. A dependency is an object depends on another object. It is also called DI. The Dependency Injection provide loose coupling and promotes testability and maintenance. DI used to design pattern used implemented to IoC.

There are three types of class in Dependency Injection pattern:

1. Client Class:-> This is dependent class it depends on service class.

2. Service Class:-> That class provides service to the client class in the service class.

3. Injector Class:-> It injects to the service class object into the client class.

Overviewof Dependency Injection

You can understand the Dependency Inversion Principle so it is helpful before initiating Dependency Injection, it gives us the guidelines for loosely-coupled classes.

1. Low level modules should depend on high-level modules and both are depending on abstractions.
2. The details should depend upon abstractions but abstractions should not depend upon details.

This is actually mechanism of you can use to make higher-level modules that depends on abstraction.You can create a class of MyDependency and create a Message method in Asp.Net Core.

Example:

publicclassMyDependency
{
	publicvoidMessage (string message)
    {
			Console.WriteLine($"My Dependency.Message called. Message: {message} ");
    }
}

In the MyDependency.cs file, you can add another class, IndexModel and derived to PageModel and create a variable name of MyDependency. Create a new method of OnGet in this method you will pass theMydependency method.

Example

publicclassIndexModel: PageModel
    {
	privatereadonlyMyDependency _dependency = newMyDependency ();

publicvoidOnGet ()
        {
            _dependency.Message("Indexmodel.OnGet created this message. ");
		}
  }

The IndexModel class creates and directly depends on the MyDependency. In the above example, there are following reasons we should avoid.

1. The IndexModel class must be modified and Mydependency replace with different implementation.
2. The MyDependency must be configured by IndexModel class. If a large project MyDependency class is depends by multiple class. It becomes scattered across the app.

These are problems throughDependency Injection:

1. The Dependency implementation use of an interface or base class to abstract in Dependency Injection.
2. Asp.Net Core provides built-in service provider that is IServiceProvider. If you add class it will offer services, always registered in the Startup.ConfigureServices method.

You can create interface IDependency and method, Message creates.

Example:

publicinterfaceIDependency
{
	voidMessage(string message);
}

In MyDependency, you applied to the interface.

Example:

publicclassMyDependency :IDependency
{
	publicvoidMessage(string message)
	{
		Console.WriteLine($"My Dependency.Message called. Message: {message}");
	}
}

Now you can add this class in Startup.ConfigureServices method.

Example:

publicvoidConfigureServices(IServiceCollection services)
        {
services.AddScoped();

publicclassIndex2Model: PageModel
{
	privatereadonlyIDependency _dependency;

	publicIndex2Model (IDependency dependency)
        {
            _dependency = dependency;
        }
	publicvoidOnGet ()
        {
            _dependency.Message("Working");
        }
}

publicclassDependency2 :IDependency
    {
privatereadonlyILogger _logger;
publicDependency2(ILogger logger)
        {
            _logger = logger;
        }
publicvoidMessage(string message)
        {
            _logger.LogInformation($"Dependency method created Mesaage:{message}");
        }
    }

publicvoidConfigureServices(IServiceCollection services)
{
	services.AddScoped();
	services.AddRazorPages();
}

publicclassDisplayModel :PageModel
    {
privatereadonlyILogger _logger;
publicDisplayModel(ILogger logger)
        {
            _logger = logger;
        }
publicstring Message { get; set; }

publicvoidOnGet()
        {
            Message = $"Display Page visited at {DateTime.UtcNow.ToLongTimeString() }";
            _logger.LogInformation(Message);
        }
    }

publicvoidConfigure (IApplicationBuilder app,IWebHostEnvironmentenv,ILogger logger)
    {
			….
    }

publicvoidConfigureServices(IServiceCollection services)
{
	services.Add(newServiceDescriptor(typeof(IDependency), newMyDependency())); //singleton

	services.Add(newServiceDescriptor(typeof(IDependency), typeof(MyDependency), ServiceLifetime.Transient)); //Transient

	services.Add(newServiceDescriptor(typeof(IDependency), typeof(MyDependency), ServiceLifetime.Scoped)); //Scoped

}

publicvoidConfigureServices(IServiceCollection services)
{
	services.AddSingleton();
	services.Add(newServiceDescriptor(typeof(IDependency), newMyDependency())); //singleton

	services.AddTransient();
	services.Add(newServiceDescriptor(typeof(IDependency), typeof(MyDependency), ServiceLifetime.Transient)); //Transient

	services.AddScoped();
	services.Add(newServiceDescriptor(typeof(IDependency), typeof(MyDependency), ServiceLifetime.Scoped)); //Scoped

}

publicclassLogController : Controller
    {
        ILogger _logger;

	publicLogController(ILogger logger)
        {
            _logger = logger;
        }

publicIActionResultIndex()
        {
            _logger.LogInformation("Executing /home/Index");

			returnView();
        }
}

usingMicrosoft.AspNetCore.Mvc;

publicclassLogController : Controller
    {
	publicLogController()
        {

        }
publicIActionResult Index([FromServices] ILogger logger)
        {
            _logger.LogInformation("Executing /home/Index");

returnView();
        }
}

publicLogController()
        {

}
publicIActionResultIndex()

    {
	var service = this.HttpContext.RequestServices;
	var log = (ILogger)service.GetService(typeof(ILogger));
	log.LogInformation("Executing /home/Index");

	returnView()
}