Création de code avec plusieurs services en utilisant IEnumerable dans l’injection de dépendances / Blogs / Perficient

Services d’enregistrement pour l’injection IEnumerable

Principes fondamentaux de l’enregistrement des services

L’enregistrement du service est le processus consistant à indiquer au conteneur DI comment créer des instances d’un service, généralement effectué au démarrage de l’application.

Enregistrement des services pour IEnumerable

Lorsque les services implémentent une interface commune, vous pouvez les enregistrer de telle manière que le conteneur DI puisse fournir un IEnumerable de ces prestations. Dans .NET, par exemple :

services.AddTransient<ICommonService, ServiceA>();
services.AddTransient<ICommonService, ServiceB>();

Pourquoi enregistreriez-vous plusieurs instances de la même interface ? Un cas d’utilisation est qu’il s’agit du même service avec une configuration différente. Voici un exemple de ce à quoi cela ressemblerait :

services.Configure<CustomOption>("Opt1", configuration.GetSection("Options1"));
services.Configure<CustomOption>("Opt2", configuration.GetSection("Options2"));

builder.Services.AddSingleton<ICommonService,ServiceA>(sp => { 
    var options = sp.GetRequiredService<IOptionsMonitor<CustomOption>>().Get("Opt1"); 
    return new ServiceA(options);
});

builder.Services.AddSingleton<ICommonService, ServiceA>(sp => {
    var options = sp.GetRequiredService<IOptionsMonitor<CustomOption>>().Get("Opt2");
    return new ServiceA(options);
});

Meilleures pratiques en matière d’inscription

Maintenez une organisation logique dans vos inscriptions de services. Le regroupement des services associés et l’utilisation de méthodes d’extension peuvent conduire à un code plus maintenable.

Résolution des services en tant que IEnumerable

Injection et utilisation d’IEnumable de services

Lorsque vous avez plusieurs services enregistrés sous la même interface, vous devez injecter un IEnumerable d’une interface de service, le conteneur DI fournit toutes les implémentations enregistrées de cette interface. Par exemple:

public class ConsumerClass
{
    private readonly IEnumerable<ICommonService> _services;

    public ConsumerClass(IEnumerable<ICommonService> services)
    {
        _services = services;
    }

    public void UseServices()
    {
        foreach (var service in _services)
        {
            service.PerformAction();
        }
    }
}

Vous pouvez également extraire un service de IEnumerable avec une clause Where ou ajouter votre propre résolveur :

public class ConsumerClass
{
    private readonly ICommonService _myService;

    public ConsumerClass(IEnumerable<ICommonService> services)
    {
        _services = services.Where(x => x.Name = "Mine");
    }

    public void UseServices()
    {
        foreach (var service in _services)
        {
            service.PerformAction();
        }
    }
}

Gestion de plusieurs implémentations

Lors de l’injection d’un IEnumerable de services, il est crucial de gérer chaque service de manière appropriée, en tirant parti de leurs fonctionnalités individuelles.

Sujets avancés et pièges

Comprendre les cycles de vie des services

Reconnaissez les cycles de vie de vos services.

• Transitoire : nouvelle instance avec chaque objet qui en a besoin
• Portée : nouvelle instance pour la demande d’application, l’objet dépendant partagera l’instance jusqu’à ce que la demande soit terminée
• Singleton : nouvelle instance pour la durée de vie de l’application. Ces services ne créeront de nouvelles instances qu’au redémarrage de l’application.

Éviter les erreurs courantes

Soyez prudent lorsque vous utilisez le modèle de localisateur de service et assurez-vous que DI ne conduit pas à un code étroitement couplé.

N’oubliez pas qu’une utilisation efficace de l’ID, en particulier avec IEnumerable injections, améliore la flexibilité et la maintenabilité de votre code. Continuez à expérimenter et à affiner votre approche pour obtenir les meilleurs résultats. Bon codage !