Wir haben ein Muster, das wir mehrmals verwendet haben, wobei wir Handler und Fabriken in separaten Dlls implementieren. Wir konfigurieren exe zur Laufzeit und geben an, welche DLLs geladen sind und welche Handler für die App verfügbar sind.

Wir tun dies, weil wir für einige Kunden eine benutzerdefinierte Behandlung haben, und weil wir neue Handler schnell und isoliert entwickeln und testen und implementieren können, ohne dass wir andere Teile einer laufenden Anwendung berührt haben. Wir können auch Handler patchen, indem wir einfach eine einzige Ersatz-DLL einfügen. Wir haben Kunden, die strenge Änderungsverwaltungsverfahren anwenden und diese lieben.

Zu diesem Zweck stützt sich das Muster auf zwei Ebenen von Fabriken, bestimmte Fabriken, die bestimmte Handler implementieren, und eine übergeordnete Factory (die wir a nennen)Anbieter). Der Provider wählt aus, welche Handler-Factory zum Erstellen eines Handlers verwendet werden soll.

Die Frage: Enthält Windsor etwas, das diesen Prozess für uns vereinfachen würde?
Insbesondere suche ich nach etwas, das die Handler-Factory-Objekte weglassen könnte, nämlichfühlt sich wie etwas sollte es tun können.
Ich habe auf dem nachgelesenFabrikanlage getippt und dasUsingFactory & UsingFactoryMethod Methoden, aber ich kann nicht sehen, wie sie hier helfen würden.
Trotzdem finde ich die Dokumentation zu Castle Windsor oft stumpf, sodass mir etwas Offensichtliches fehlen könnte Oder Gibt es einen besseren Weg, das gleiche Endziel zu erreichen, das ich nicht in Betracht gezogen habe?

Hier ist ein Code zur Veranschaulichung, erste Meldung, Handler und Factory-Schnittstellen

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

In einer zweiten DLL implementieren wir einen Handler und eine Factory für 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();
    }
}

In einer dritten Dll implementieren wir einen Handler und eine Factory für 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();
    }
}

In einem Windows-Dienst implementieren wir den Provider

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);
    }
}

Der Dienst, der die Handler tatsächlich benötigt, verwendet nur den Provider

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