dependency injection in asp.net core

Hi,

Please have a look into my below article to understand DI in detail with some practical examples.

https://www.c-sharpcorner.com/blogs/dependency-injection-using-net-core-api

Dependency Injection is the Technique not only specific to .net. It is used across multiple languages

Dependency Injection (DI) is a design pattern used to implement Inversion of Control (IoC). It allows a class to receive its dependencies from an external source rather than creating them itself. This leads to more modular, testable, and maintainable code.

Simple Explanation

Imagine you have a car, and the car needs an engine to function. Instead of the car creating its own engine, it receives an engine from outside. This way, you can easily swap the engine with another one if needed, and you can test the car by providing a mock engine.

Basic Components of DI

1. Service: The dependency (e.g., Engine).
2. Client: The class that depends on the service (e.g., Car).
3. Injector: The mechanism or code that injects the service into the client (e.g., a factory or a DI framework).

Example in C#

Let's see a simple example in C# without using any DI framework.

Without Dependency Injection

In this example, the Car class creates its own Engine.

public class Engine
{
    public void Start() => Console.WriteLine("Engine started");
}

public class Car
{
    private Engine _engine;

    public Car()
    {
        _engine = new Engine(); // Car creates its own Engine
    }

    public void Start()
    {
        _engine.Start();
    }
}

public class Program
{
    public static void Main()
    {
        var car = new Car();
        car.Start();
    }
}

With Dependency Injection

Here, the Engine is injected into the Car from the outside.

public class Engine
{
    public void Start() => Console.WriteLine("Engine started");
}

public class Car
{
    private Engine _engine;

    // Constructor injection
    public Car(Engine engine)
    {
        _engine = engine; // Engine is injected
    }

    public void Start()
    {
        _engine.Start();
    }
}

public class Program
{
    public static void Main()
    {
        var engine = new Engine();
        var car = new Car(engine); // Engine is provided by the injector
        car.Start();
    }
}

Types of Dependency Injection

1. Constructor Injection: Dependencies are provided through a class constructor.
2. Property Injection: Dependencies are provided through public properties.
3. Method Injection: Dependencies are provided through method parameters.

Benefits of Dependency Injection

1. Decoupling: Reduces the dependency between classes.
2. Testability: Makes it easier to test components independently by injecting mock dependencies.
3. Maintainability: Simplifies the management and replacement of dependencies.

In summary, Dependency Injection is a powerful pattern that helps to create flexible, testable, and maintainable code by externalizing the creation and management of dependencies.