Choisir une implémentation concrète basée sur des options

Vous pouvez sélectionner une implémentation concrète d'une interface basée sur un type d'options à l'aide de AddSingleton (implementationFactory) code> surcharge. En utilisant cette surcharge, vous pouvez retarder la résolution du type de béton à utiliser jusqu'à ce que vous puissiez accéder à un ioptionsSnapshot code>. En fonction de vos besoins et des implémentations de l'interface que vous utilisez, vous pouvez changer de type de type de manière dynamique à l'aide d'un ioptionsMonitor code> à la place. P>

Si cela aide, vous pouvez Pensez au modèle d'usine comme un moyen de Curry Création d'objet lors de l'utilisation du conteneur DI. p>

// when configuring services, add a call to AddAutoRegisterTypes()

// ...
            .ConfigureServices((hostContext, services) =>
            {
                services
                    // Finds and registers config & the type for all types with [AutoRegister]
                    .AddAutoRegisterTypes(hostContext.Configuration)
                    // ...
            });

// ...

// The first concrete implementation. See below for how AutoRegister
// is used & implemented.
[AutoRegister(optionsType: typeof(FooFirstOptions), configSection: "Foo1")]
public class FooFirst : IFoo
{
    public FooFirst(IOptionsSnapshot<FooFirstOptions> options)
    {
        Value = $"{options.Value.ValuePrefix}First";
    }

    public string Value { get; }
}

public class FooFirstOptions
{
    public string ValuePrefix { get; set; } = string.Empty;
}

// The second concrete implementation. See below for how AutoRegister
// is used & implemented.
[AutoRegister(optionsType: typeof(FooSecondOptions), configSection: "Foo2")]
public class FooSecond : IFoo
{
    public FooSecond(IOptionsSnapshot<FooSecondOptions> options)
    {
        Value = $"Second{options.Value.ValueSuffix}";
    }

    public string Value { get; }
}

public class FooSecondOptions
{
    public string ValueSuffix { get; set; } = string.Empty;
}

// Attribute used to annotate a type that should be:
// 1. automatically added to a service collection and
// 2. have its corresponding options type configured to bind against
//    the specificed config section.
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
public class AutoRegisterAttribute : Attribute
{
    public AutoRegisterAttribute(Type optionsType, string configSection)
    {
        OptionsType = optionsType;
        ConfigSection = configSection;
    }

    public Type OptionsType { get; }

    public string ConfigSection { get; }
}

public static class AutoRegisterServiceCollectionExtensions
{
    // Helper to call Configure<T> given a Type argument. See below for more details.
    private static readonly Action<Type, IServiceCollection, IConfiguration> s_configureType
        = MakeConfigureOfTypeConfig();

    // Automatically finds all types with [AutoRegister] and adds
    // them to the service collection and configures their options
    // type against the provided config.
    public static IServiceCollection AddAutoRegisterTypes(
        this IServiceCollection services,
        IConfiguration config)
    {
        foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
        {
            foreach (Type type in assembly.GetTypes())
            {
                var autoRegAttribute = (AutoRegisterAttribute?)Attribute
                    .GetCustomAttributes(type)
                    .SingleOrDefault(attr => attr is AutoRegisterAttribute);

                if (autoRegAttribute != null)
                {
                    IConfiguration configForType = config.GetSection(
                        autoRegAttribute.ConfigSection);
                    s_configureType(
                        autoRegAttribute.OptionsType,
                        services,
                        configForType);
                    services.AddSingleton(type);
                }
            }
        }

        return services;
    }

    // There is no non-generic analog to
    // OptionsConfigurationServiceCollectionExtensions.Configure<T>(IServiceCollection, IConfiguration)
    //
    // Therefore, this finds the generic method via reflection and
    // creates a wrapper that invokes it given a Type parameter.
    private static Action<Type, IServiceCollection, IConfiguration> MakeConfigureOfTypeConfig()
    {
        const string FullMethodName = nameof(OptionsConfigurationServiceCollectionExtensions) + "." + nameof(OptionsConfigurationServiceCollectionExtensions.Configure);

        MethodInfo? configureMethodInfo = typeof(OptionsConfigurationServiceCollectionExtensions)
            .GetMethod(
                nameof(OptionsConfigurationServiceCollectionExtensions.Configure),
                new[] { typeof(IServiceCollection), typeof(IConfiguration) });

        if (configureMethodInfo == null)
        {
            var msg = $"Cannot find expected {FullMethodName} overload. Has the contract changed?";
            throw new Exception(msg);
        }

        if (   !configureMethodInfo.IsGenericMethod
            || configureMethodInfo.GetGenericArguments().Length != 1)
        {
            var msg = $"{FullMethodName} does not have the expected generic arguments.";
            throw new Exception(msg);
        }

        return (Type typeToConfigure, IServiceCollection services, IConfiguration configuration) =>
        {
            configureMethodInfo
                .MakeGenericMethod(typeToConfigure)
                .Invoke(null, new object[] { services, configuration });
        };
    }
}

Comme @weichch mentionné, le principal point de douleur ici est le manque d'existence d'une surcharge non générique de configuration . Je pense que cela est peut être considéré comme une omission de la part de Microsoft (mais la création d'une demande de fonctionnalité pour cela serait une bonne idée).

En outre, la solution de Weichch, vous pouvez également utiliser la réflexion pour appeler le Configurer la méthode de votre choix. Cela ressemblerait à ceci: xxx

où la configuration peut être la suivante: xxx