Wat is een service-locator?

Service Locator is een ontwerppatroon dat een globaal toegangspunt tot services (objecten die specifieke taken uitvoeren) biedt, zonder dat de clientcode de specifieke implementatietypen van deze services hoeft te kennen. Het encapsuleert het proces van het verkrijgen van de benodigde service.

Voordelen van Service Locator:

• Gecentraliseerde toegang: Maakt het gemakkelijk om services vanaf elke plek in de applicatie te verkrijgen.
• Flexibiliteit: Maakt het eenvoudig om de implementaties van services te wijzigen zonder de clientcode aan te passen.

Nadelen van Service Locator (de belangrijkste reden voor kritiek):

• Verborgen afhankelijkheden: De clientcode declareert zijn afhankelijkheden niet expliciet, wat het moeilijk maakt te begrijpen welke services nodig zijn.
• Testbaarheid: Het is moeilijk om klassen te testen die de Service Locator gebruiken, omdat afhankelijkheden niet gemakkelijk kunnen worden vervangen (gemockt).
• Overschrijding van het principe van afhankelijkheidsomkering (DIP): In plaats van afhankelijkheden via de constructor of eigenschappen te verkrijgen, vraagt de klasse er actief om.
• Moeilijkheden bij het beheren van de levenscyclus: Service Locator kan vaak de levenscyclus van geregistreerde services niet beheren (bijvoorbeeld singleton of transient objecten maken).

Voorbeeld van een eenvoudige implementatie:

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 van type {typeof(TService).Name} is al geregistreerd.");
        }
        _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 van type {typeof(TService).Name} niet gevonden.");
    }
}

Voorbeeld van gebruik:

// Registratie van de service
ServiceLocator.RegisterService<ILogger>(new ConsoleLogger());

// Verkrijgen van de service
ILogger logger = ServiceLocator.GetService<ILogger>();
logger.LogInfo("Hello, Service Locator!");

In moderne C#-ontwikkeling wordt de Service Locator vaak vervangen door het gebruik van Inversion of Control (IoC) containers, die volledige Dependency Injection (DI) bieden, wat een meer aanbevolen aanpak is voor het beheren van afhankelijkheden en het verbeteren van de testbaarheid van de code. IoC-containers maken het mogelijk om afhankelijkheden expliciet te declareren en automatisch te injecteren, volgens de principes van DIP.