L'injection de plusieurs implémentations avec l'injection de Dépendance

La fonctionnalité que vous recherchez n'est pas facile à mettre en œuvre, au moins lorsque vous l'utilisez dans le contrôleur parce que les contrôleurs sont traités un peu spécialement (Par défaut, les contrôleurs ne sont pas enregistrés avec ServiceCollection et n'est donc pas résolu/instancié par le conteneur et instanciées par ASP.NET de Base lors de la demande, voir aussi l'explication et exemple sur mes réponse).

Avec construit-dans le conteneur IoC, vous ne pouvez le faire via la méthode de fabrique, ici avec un exemple sur un BmwCarFactory classe:

services.AddScoped<ICar, BmwCar>();
services.AddScoped<BmwCar>();
services.AddScoped<BmwCarFactory>(p => new BmwCarFactory(p.GetRequiredService<BmwCar>())));

La valeur par défaut conteneur IoC est intentionnellement simple de fournir des notions de base de l'injection de dépendance pour vous aider à démarrer et pour les autres conteneurs IoC pour être en mesure de facilement plugin-y, et remplacez la valeur par défaut de mise en œuvre.

Pour des scénarios plus avancés, les utilisateurs sont encouragés à utiliser un Cio de leur choix qui prend en charge davantage de fonctionnalités avancées (assemblée scan, décorateurs, conditionnel/paramétrée dépendances, etc.

AutoFac (que j'utilise dans mes projets) prend en charge de tels scénarios. Dans l'AutoFac documentation il y a 4 scénarios (tout à fait avec le 3e que @pwas suggéré dans les commentaires):

1. Refonte des classes

Besoins des surcharges supplémentaires de la refactorisation de votre code et de la hiérarchie de classe, mais simplifie fortement la consommation de injectés services

2. Modifier les enregistrements

Les documents décrivent il ici, si vous ne sont pas disposés ou pas en mesure de modifier le code.

//Attach resolved parameters to override Autofac's
//lookup just on the ISender parameters.
builder.RegisterType<ShippingProcessor>()
       .WithParameter(
         new ResolvedParameter(
           (pi, ctx) => pi.ParameterType == typeof(ISender),
           (pi, ctx) => ctx.Resolve<PostalServiceSender>()));
builder.RegisterType<CustomerNotifier>();
       .WithParameter(
         new ResolvedParameter(
           (pi, ctx) => pi.ParameterType == typeof(ISender),
           (pi, ctx) => ctx.Resolve<EmailNotifier>()));
var container = builder.Build();

3. À l'aide assortie de services (ici)

Il est assez similaire à l'approche précédente à 2. mais résout les services basés sur une touche, plutôt que de leur type de béton

4. Utiliser Les Métadonnées

C'est tout à fait similaire à 3. mais vous définissez via les touches de l'attribut.

Autres contenants comme L'unité ont des attributs spéciaux, comme DependencyAttribute que vous pouvez utiliser pour annoter la dépendance, comme

public class BmwController : Controller
{
    public BmwController([Dependency("Bmw")ICar car)
    {
    }
}

Mais ce et la 4e option de Autofac faire le conteneur IoC fuite dans vos services, et vous devriez envisager d'autres approches.

Alternativement, vous pouvez créer des classes et des usines qui résoudre vos services basés sur des conventions. Par exemple, un ICarFactory:

public ICarFactory
{
    ICar Create(string carType);
}

public CarFactory : ICarFactory
{
    public IServiceProvider provider;

    public CarFactory(IServiceProvider provider)
    {
        this.provider = provider;
    }

    public ICar Create(string carType)
    {
        if(type==null)
            throw new ArgumentNullException(nameof(carType));

        var fullQualifedName = $"MyProject.Business.Models.Cars.{carType}Car";
        Type carType = Type.GetType(fullQualifedName);
        if(carType==null)
            throw new InvalidOperationException($"'{carType}' is not a valid car type.");

        ICar car = provider.GetService(carType);
        if(car==null)
            throw new InvalidOperationException($"Can't resolve '{carType.Fullname}'. Make sure it's registered with the IoC container.");

        return car;
    }
}

Puis l'utiliser comme

public class BmwController : Controller
{
    public ICarFactory carFactory;

    public BmwController(ICarFactory carFactory)
    {
        this.carFactory = carFactory;

        //Get the car
        ICar bmw = carFactory.Create("Bmw");
    }
}

Alternative à IServiceProvider

//alternatively inject IEnumerable<ICar>
public CarFactory : ICarFactory
{
    public IEnumerable<ICar> cars;

    public CarFactory(IEnumerable<ICar> cars)
    {
        this.cars = cars;
    }

    public ICar Create(string carType)
    {
        if(type==null)
            throw new ArgumentNullException(nameof(carType));

        var carName = ${carType}Car";
        var car = cars.Where(c => c.GetType().Name == carName).SingleOrDefault();

        if(car==null)
            throw new InvalidOperationException($"Can't resolve '{carName}.'. Make sure it's registered with the IoC container.");

        return car;
    }
}

OriginalL'auteur Tseng