Castle Windsor: Uma maneira melhor de implementar 2 níveis de fábricas (aninhadas)?

Temos um padrão que usamos várias vezes, no qual implementamos manipuladores e fábricas em DLLs separadas. Configuramos exe's em tempo de execução dizendo quais dlls são carregadas e, portanto, quais manipuladores estão disponíveis para o aplicativo.

Fazemos isso porque temos manipulação personalizada para alguns clientes, mas também permite uma grande flexibilidade, porque podemos desenvolver rapidamente novos manipuladores isoladamente e testá-los e implantá-los com confiança de que nem tocamos em nenhuma outra parte de um aplicativo em execução. Também podemos corrigir os manipuladores simplesmente inserindo uma única DLL de substituição, temos clientes com procedimentos rigorosos de gerenciamento de alterações e eles adoram isso.

Para fazer isso, o padrão se baseia em dois níveis de fábricas, fábricas específicas que implementam manipuladores específicos e uma fábrica abrangente (que chamamos deFornecedor) O provedor escolhe qual fábrica de manipuladores usar para criar um manipulador.

A pergunta: Windsor contém algo que simplificaria esse processo para nós?
Especificamente, estou procurando por algo que possa omitir os objetos de fábrica do Handler,sente como algo que deveria ser capaz de fazer.
Eu li sobre oInstalação de fábrica digitada e aUsingFactory & UsingFactoryMethod métodos, mas não consigo ver como eles ajudariam aqui.
Dito isto, muitas vezes acho a documentação do Castle Windsor obtusa para que eu possa estar perdendo algo óbvio Ou existe apenas uma maneira melhor de obter o mesmo objetivo final que eu não considerei.

Aqui estão alguns códigos para ilustrar, primeira mensagem, manipulador e interfaces de fábrica

public interface IMessage
{
    string MessageType { get; }
}
public interface IMessageHandler
{
    void Process(IMessage message);
}
public interface IMessageHandlerFactory
{
    bool CanProcessType(string type);
    IMessageHandler Create();
}

Em uma segunda DLL, implementamos um manipulador e uma fábrica para o Type1

public class Type1MessageHandler
    : IMessageHandler
{
    public void Process(IMessage message) { }
}
public class Type1MessageHandlerFactory
    : IMessageHandlerFactory
{
    public bool CanProcessType(string type)
    {
        return type == "Type1";
    }
    public IMessageHandler Create()
    {
        return new Type1MessageHandler();
    }
}

Em uma terceira DLL, implementamos um manipulador e uma fábrica para o Type2

public class Type2MessageHandler
    : IMessageHandler
{
    public void Process(IMessage message) { }
}
public class Type2MessageHandlerFactory
    : IMessageHandlerFactory
{
    public bool CanProcessType(string type)
    {
        return type == "Type2";
    }
    public IMessageHandler Create()
    {
        return new Type2MessageHandler();
    }
}

Em um serviço Windows, implementamos o provedor

public interface IMessageHandlerProvider
{
    IMessageHandler Create(string messageType);
}
public class MessageHandlerProvider
    : IMessageHandlerProvider
{
    IEnumerable<IMessageHandlerFactory> factories;
    public MessageHandlerProvider(IWindsorContainer wc)
    {
        factories = wc.ResolveAll<IMessageHandlerFactory>();
    }
    public IMessageHandler Create(string messageType)
    {
        foreach (var factory in factories)
            if (factory.CanProcessType(messageType))
                return factory.Create();
        throw new UnableToFindMessageHandlerFactoryForType(messageType);
    }
}

O serviço que realmente precisa dos manipuladores usa apenas o provedor

public class MessageService
{
    public MessageService(IMessageHandlerProvider handlerProvider) {}
}