🔹 1. Qu'est-ce que l’injection de dépendances (Dependency Injection) et pourquoi est-elle utilisée ?

✅ Définition :

L’injection de dépendances (DI) est un design pattern qui consiste à fournir les dépendances d’un objet depuis l’extérieur, plutôt que de les créer à l’intérieur.

Autrement dit, au lieu de :

public class OrderService
{
    private EmailService _emailService = new EmailService(); // dépendance directe ❌
}

on écrit :

public class OrderService
{
    private readonly IEmailService _emailService;
    public OrderService(IEmailService emailService) // injection par constructeur ✅
    {
        _emailService = emailService;
    }
}

✅ Objectifs :

Découpler les composants (principe SOLID : D = Dependency Inversion).
Faciliter les tests unitaires (mocking, substitution).
Simplifier la maintenance et l’évolution du code.
Favoriser la réutilisation et la configuration centralisée des dépendances.

🧠 En résumé :

La DI permet d’écrire un code modulaire, testable et extensible, en confiant la création des objets à un conteneur IoC.

🔹 2. Quelle est la différence entre Service Locator et Dependency Injection ?

Critère	Service Locator	Dependency Injection
Principe	L’objet va chercher ses dépendances dans un conteneur global	Les dépendances sont fournies automatiquement à l’objet
Couplage	Couplage fort au conteneur (anti-pattern)	Couplage faible, respecte l’inversion de dépendances
Lisibilité	Masque les dépendances réelles	Les dépendances sont explicites
Testabilité	Difficile à tester	Facile à mocker et injecter

Exemple Service Locator (❌ à éviter) :

var emailService = ServiceLocator.GetService<IEmailService>();

Exemple Dependency Injection (✅) :

public class OrderService
{
    public OrderService(IEmailService emailService) { ... }
}

🧠 En résumé :

Le Service Locator cache les dépendances → difficile à maintenir.
La Dependency Injection les rend explicites → claire et testable.

🔹 3. Quels sont les trois types d’injection de dépendances ?

Type d’injection	Description	Exemple
Constructeur	Dépendances fournies via le constructeur (le plus courant)	`public MyClass(IMailService mailService)`
Propriété	Dépendances assignées après création via des propriétés publiques	`public IMailService MailService { get; set; }`
Méthode	Dépendances passées en paramètre d’une méthode spécifique	`void Initialize(IMailService mailService)`

Exemple global :

public class NotificationService
{
    // 1️⃣ Constructeur
    public NotificationService(IEmailService emailService) { ... }

    // 2️⃣ Propriété
    public ISmsService SmsService { get; set; }

    // 3️⃣ Méthode
    public void Init(ILogService logService) { ... }
}

🧠 Bonne pratique :

L’injection par constructeur est la plus recommandée car elle garantit que toutes les dépendances sont fournies dès la création de l’objet.

🔹 4. Comment configurer l'injection de dépendances dans ASP.NET Core ?

ASP.NET Core intègre un conteneur IoC natif via IServiceCollection et IServiceProvider.

Étapes :

Déclarer une interface et son implémentation :

public interface IEmailService
{
    void SendEmail(string to, string message);
}

public class EmailService : IEmailService
{
    public void SendEmail(string to, string message) => Console.WriteLine($"Email sent to {to}");
}

Enregistrer le service dans Program.cs ou Startup.cs :

builder.Services.AddScoped<IEmailService, EmailService>();

L’injecter dans un contrôleur ou un service :

public class OrderController : Controller
{
    private readonly IEmailService _emailService;

    public OrderController(IEmailService emailService)
    {
        _emailService = emailService;
    }

    public IActionResult Confirm()
    {
        _emailService.SendEmail("client@mail.com", "Order confirmed!");
        return Ok();
    }
}

🧠 Résumé :

L’enregistrement se fait dans le IServiceCollection, et l’injection se fait automatiquement par le framework.

🔹 5. Quelle est la différence entre les portées de services : Transient, Scoped et Singleton ?

Portée	Durée de vie	Description	Exemple
Transient	À chaque injection	Nouvelle instance à chaque appel	`AddTransient<IService, Impl>()`
Scoped	Par requête HTTP (ASP.NET)	Même instance pour toute la requête	`AddScoped<IService, Impl>()`
Singleton	Unique pour toute l’application	Instance partagée et persistante	`AddSingleton<IService, Impl>()`

Exemple pratique :

builder.Services.AddTransient<IEmailService, EmailService>(); // Nouveau à chaque injection
builder.Services.AddScoped<IUserService, UserService>();      // 1 par requête
builder.Services.AddSingleton<ILogService, LogService>();     // Unique globale

🧠 Bonnes pratiques :

Transient → objets légers, stateless.
Scoped → services dépendant du contexte de requête (EF DbContext).
Singleton → services partagés, thread-safe (cache, logger).

🔹 6. Comment utiliser IServiceCollection pour enregistrer des dépendances ?

IServiceCollection est l’interface utilisée pour configurer le conteneur IoC dans .NET Core.

Exemple d’enregistrement :

public void ConfigureServices(IServiceCollection services)
{
    // Enregistre un service simple
    services.AddScoped<IEmailService, EmailService>();

    // Enregistre un service avec fabrique personnalisée
    services.AddSingleton<IMyService>(provider => new MyService("param"));

    // Enregistre une instance spécifique
    var settings = new AppSettings { Timeout = 30 };
    services.AddSingleton(settings);
}

Résolution manuelle :

var provider = services.BuildServiceProvider();
var emailService = provider.GetRequiredService<IEmailService>();

🧠 Résumé :

IServiceCollection permet d’enregistrer les dépendances, et IServiceProvider les résout à l’exécution.

🔹 7. Qu'est-ce que l’inversion de contrôle (IoC) ?

✅ Définition :

L’Inversion de Contrôle (Inversion of Control) est un principe architectural où le contrôle du flux d’exécution est inversé :
ce n’est plus votre code qui crée et gère les dépendances, mais le framework ou conteneur IoC.

Exemple sans IoC :

var emailService = new EmailService();
var orderService = new OrderService(emailService);

Exemple avec IoC :

public class OrderService
{
    private readonly IEmailService _emailService;
    public OrderService(IEmailService emailService)
    {
        _emailService = emailService;
    }
}

➡️ Le conteneur IoC s’occupe de fournir l’instance EmailService.

🧠 Résumé :

IoC = principe, DI = son implémentation concrète.
Le conteneur gère le cycle de vie, la création et la destruction des objets.

🔹 8. Exemple complet d’injection de dépendances avec Microsoft.Extensions.DependencyInjection

✅ Étape 1 : Ajouter le package (si projet console)

dotnet add package Microsoft.Extensions.DependencyInjection

✅ Étape 2 : Créer les interfaces et implémentations

public interface IMessageService
{
    void Send(string message);
}

public class EmailMessageService : IMessageService
{
    public void Send(string message)
    {
        Console.WriteLine($"Email envoyé : {message}");
    }
}

✅ Étape 3 : Configurer le conteneur

using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();
services.AddTransient<IMessageService, EmailMessageService>();

var provider = services.BuildServiceProvider();

✅ Étape 4 : Résoudre la dépendance

var msgService = provider.GetRequiredService<IMessageService>();
msgService.Send("Bonjour DI !");

🧠 Résumé :

Microsoft.Extensions.DependencyInjection fournit le même moteur d’injection que celui d’ASP.NET Core, utilisable dans toute application .NET (console, WPF, etc.).