Разрешить автоматическую фабрику из именованной регистрации для универсального типа

К сожалению, вы не можете использовать RegisterAssemblyTypes в этом случае — он не полностью обрабатывает общие регистрации так, как вам нужно (вам необходимо явно зарегистрировать каждый конкретный обработчик команд для его реализованного интерфейса, включая универсальный тип этого интерфейса).

Вместо этого вы можете использовать следующее в качестве регистрации:

assembly.GetTypes()
    .Where(type => type.Name.EndsWith("CommandHandler"))
    .ToList()
    .ForEach(t => builder.RegisterType(t)
        .Named("concreteCommandHandler", typeof (ICommandHandler<>)
            .MakeGenericType(t.GetInterfaces()[0].GenericTypeArguments[0])
    ));

builder.RegisterGeneric(typeof(FactoryCommandHandler<>)
   .WithParameter(
         (p, c) => true,
         (p, c) => c.ResolveNamed("concreteCommandHandler", p.ParameterType))
   .As(typeof(ICommandHandler<>));

Это успешно позволит вам сделать что-то подобное, возвращая универсальную фабрику с именованной командой в качестве параметра конструктора:

container.Resolve<ICommandHandler<FooCommand>>().Handle(new FooCommand());

Извините, что подключаю здесь Simple Injector, но я не мог не заметить, что вы боретесь с чем-то, что это детская игра в Simple Injector. В Simple Injector вы можете делать то, что хотите, в двух строках кода:

// using SimpleInjector;
// using SimpleInjector.Extensions;

var container = new Container();

container.RegisterManyForOpenGeneric(
    typeof(ICommandHandler<>), 
    assembly);

container.RegisterSingleDecorator(
    typeof(ICommandHandler<>), 
    typeof(FactoryCommandHandler<>));

Эти две простые строки обеспечивают следующее:

• В предоставленной сборке выполняется поиск конкретных реализаций ICommandHandler<T>.
• Если конкретная реализация определяет интерфейс ICommandHandler<T> несколько раз, он регистрируется для каждой закрытой универсальной версии этого интерфейса.
• FactoryCommandHandler<T> зарегистрирован для использования в ICommandHandler<T> реализациях. Для каждой закрытой универсальной версии ICommandHandler<T> возвращается один экземпляр этого универсального FactoryCommandHandler<T>.
• В этот FactoryCommandHandler<T> вводится Func<ICommandHandler<T>>, что позволяет создать декоративный элемент (завернутый экземпляр). Это эффективно задерживает создание этого экземпляра.
• Введенная фабрика сохранит образ жизни украшенного.

FactoryCommandHandler<T> зависит только от Func<T>, который является синглтоном. Таким образом, FactoryCommandHandler<T> может быть зарегистрирован как синглтон (что происходит при регистрации выше). Если это зависит от зависимостей других образов жизни, возможно, лучше зарегистрировать его как переходный.

Я использовал код в ответе Мэтта Дэвиса и немного улучшил его:

• Теперь он правильно обрабатывает обработчики команд, которые реализуют другие интерфейсы.
• Теперь он правильно обрабатывает обработчики команд, реализующие ICommandHandler<T> несколько раз.
• Я улучшил свою первоначальную версию, зафиксировав первый параметр на WithParameter. Таким образом, теперь он поддерживает несколько параметров конструктора для FactoryCommandHandler<T>.

Результат выглядит следующим образом:

public static class AutofacExtensions
{
    public static void RegisterGenericTypesWithFactoryDecorator(
        this ContainerBuilder builder, 
        IEnumerable<Type> relevantTypes, 
        Type factoryDecorator,
        Type implementedInterfaceGenericTypeDefinition)
    {
        var serviceName = implementedInterfaceGenericTypeDefinition.ToString();

        foreach (var implementationType in relevantTypes)
        {
            var implementedInterfaces =
                implementationType.GetGenericInterfaces(
                    implementedInterfaceGenericTypeDefinition);
            foreach (var implementedInterface in implementedInterfaces)
                builder.RegisterType(implementationType)
                       .Named(serviceName, implementedInterface);
        }

        builder.RegisterGeneric(factoryDecorator)
               .WithParameter(
                   (p, c) => IsSpecificFactoryParameter(p, implementedInterfaceGenericTypeDefinition), 
                   (p, c) => c.ResolveNamed(serviceName, p.ParameterType))
               .As(implementedInterfaceGenericTypeDefinition)
               .SingleInstance();
    }

    private static bool IsSpecificFactoryParameter(ParameterInfo p,
                                                   Type expectedFactoryResult)
    {
        var parameterType = p.ParameterType;
        if (!parameterType.IsGenericType ||
            parameterType.GetGenericTypeDefinition() != typeof(Func<>))
            return false;

        var actualFactoryResult = p.ParameterType.GetGenericArguments()
                                                 .First();
        if (actualFactoryResult == expectedFactoryResult)
            return true;
        if (expectedFactoryResult.IsGenericTypeDefinition && 
            actualFactoryResult.IsGenericType)
            return expectedFactoryResult == 
                   actualFactoryResult.GetGenericTypeDefinition();
        return false;
    }
}

public static class TypeExtensions
{
    public static IEnumerable<Type> GetGenericInterfaces(
        this Type type, Type openGenericInterface)
    {
        return
            type.GetInterfaces()
                .Where(x => x.IsGenericType &&
                            x.GetGenericTypeDefinition() == openGenericInterface);
    }
}

Использование:

var relevantTypes = assembly.GetTypes();
builder.RegisterGenericTypesWithFactoryDecorator(
    relevantTypes.Where(type => type.Name.EndsWith("CommandHandler")), 
    typeof(FactoryCommandHandlerDecorator<>), 
    typeof(ICommandHandler<>));