Pentru ce se utilizează injecția de dependențe…

Injecția de dependințe (Dependency Injection, DI) este utilizată pentru gestionarea dependențelor dintre componentele unei aplicații.

Obiectivele principale ale DI:

Reducerea cuplajului: Componentele nu creează direct dependențele lor, ci le primesc din exterior. Acest lucru face ca componentele să fie mai independente și să faciliteze reutilizarea lor.
Îmbunătățirea testabilității: Testarea izolată a componentelor individuale devine mai ușoară, deoarece se pot folosi obiecte mock sau simulări în locul dependențelor reale.
Creșterea flexibilității și extensibilității: Este mai ușor să înlocuiți implementările dependențelor fără a modifica codul componentelor care le utilizează.
Simplificarea configurației: Dependențele pot fi configurate centralizat, de exemplu, la pornirea aplicației.

Abordări principale ale DI:

Injecție prin constructor (Constructor Injection): Dependențele sunt transmise ca parametri ai constructorului. Aceasta este cea mai comună și recomandată abordare, deoarece garantează disponibilitatea tuturor dependențelor necesare la crearea obiectului.

// Dependență
public interface ILogger
{
    void Log(string message);
}

// Componentă cu dependență
public class MyService
{
    private readonly ILogger _logger;

    public MyService(ILogger logger) // Injecție prin constructor
    {
        _logger = logger;
    }

    public void DoSomething()
    {
        _logger.Log("Fac ceva.");
    }
}

Injecție prin proprietate (Property Injection): Dependențele sunt stabilite prin proprietăți publice. Este mai puțin preferată, deoarece nu garantează că dependența va fi setată.

public class MyService
{
    public ILogger Logger { get; set; } // Injecție prin proprietate

    public void DoSomething()
    {
        Logger?.Log("Fac ceva."); // Verificare null
    }
}

Injecție prin metodă (Method Injection): Dependențele sunt transmise ca parametri ai metodei. Se folosește atunci când dependența este necesară doar pentru executarea unei metode specifice.
```
public class MyService
{
    public void DoSomething(ILogger logger) // Injecție prin metodă
    {
        logger.Log("Fac ceva.");
    }
}
```

DI este adesea implementată cu ajutorul unui container DI (Inversion of Control Container), care gestionează ciclul de viață al obiectelor și rezolvă dependențele acestora. Exemple populare de containere DI în .NET: Microsoft.Extensions.DependencyInjection (încorporat), Autofac, Ninject, Castle Windsor.

DI este un principiu cheie pentru construirea de aplicații ușor de întreținut, testat și extins.

Pentru ce se utilizează injecția de dependențe (Dependency Injection)?