Qu'est-ce qu'un localisateur de services?

Service Locator est un patron de conception qui fournit un point d’accès global aux services (objets effectuant des tâches spécifiques), sans que le code client ait besoin de connaître les types spécifiques d’implémentation de ces services. Il encapsule le processus d’obtention du service nécessaire.

Avantages du Service Locator:

• Accès centralisé: Facilite l’obtention de services depuis n’importe quel endroit de l’application.
• Flexibilité: Permet de changer facilement les implémentations des services sans modifier le code client.

Inconvénients du Service Locator (la principale raison des critiques):

• Dépendances cachées: Le code client ne déclare pas explicitement ses dépendances, ce qui complique la compréhension des services nécessaires.
• Testabilité: Il est difficile de tester les classes utilisant le Service Locator, car les dépendances ne peuvent pas être facilement substituées (mocked).
• Violation du principe d’inversion des dépendances (DIP): Au lieu d’obtenir les dépendances via le constructeur ou des propriétés, la classe les demande activement.
• Difficultés dans la gestion du cycle de vie: Le Service Locator ne gère souvent pas le cycle de vie des services enregistrés (par exemple, créer des singletons ou des objets transitoires).

Exemple d’implémentation simple:

public static class ServiceLocator
{
    private static Dictionary<Type, object> _services = new Dictionary<Type, object>();

    public static void RegisterService<TService>(TService serviceInstance) where TService : class
    {
        if (_services.ContainsKey(typeof(TService)))
        {
            throw new InvalidOperationException($"Service de type {typeof(TService).Name} déjà enregistré.");
        }
        _services[typeof(TService)] = serviceInstance;
    }

    public static TService GetService<TService>() where TService : class
    {
        if (_services.TryGetValue(typeof(TService), out object service))
        {
            return (TService)service;
        }
        throw new InvalidOperationException($"Service de type {typeof(TService).Name} non trouvé.");
    }
}

Exemple d’utilisation:

// Enregistrement du service
ServiceLocator.RegisterService<ILogger>(new ConsoleLogger());

// Récupération du service
ILogger logger = ServiceLocator.GetService<ILogger>();
logger.LogInfo("Hello, Service Locator!");

Dans le développement moderne en C#, le Service Locator est souvent remplacé par l’utilisation de conteneurs d’Inversion de Contrôle (IoC), qui offrent une injection de dépendances (DI) complète, ce qui est une approche plus recommandée pour gérer les dépendances et améliorer la testabilité du code. Les conteneurs IoC permettent de déclarer explicitement les dépendances et de les injecter automatiquement, en suivant les principes DIP.