Come gestire strutture di tipo fabbrica con un'enorme quantità di classi?

Cercherò di evitare l'istanziazione di nuove classi per messaggio.

Invece hai un tipo di messaggio generico e una raccolta di gestori specifici del tipo in un dizionario.

Dictionary<string, IHander> Handlers;

public void ReadMessage(Message m)
{
    var handler = Handlers[m.TypeName];
    if(handler == null) { handler = DefaultHandler;)
    handler.ReadMessage(m);
}

Ovviamente puoi fare la stessa cosa con un Dizionario delle Fabbriche, ma sebbene il modello di gestore sia più procedurale è più elegante. Non richiedendo di creare nuove istanze di classi diverse, chiama un singolo metodo e disponili immediatamente.

Inoltre, puoi immaginare il caso in cui una classe Message ha parametri di costruzione diversi dagli altri. Questo modello consente di creare un'istanza dei gestori una volta all'avvio, in cui è possibile specificare la costruzione di ciascuno individualmente. Piuttosto che nel ciclo di gestione dei messaggi in cui è necessario un parametro condizionale ed extra.

Aggiungi un metodo all'interfaccia della fabbrica astratta che controlla se una determinata stringa di messaggi corrisponde alla fabbrica. In questo modo puoi mettere la logica che decide quando utilizzare una fabbrica specifica nella fabbrica stessa e non è necessario creare un enorme albero if-else. Questo sarebbe simile a questo:

private List<AbstractMessageFactory> messageFactories = new ArrayList<>();

public void registerMessageFactory(AbstractMessageFactory factory) {
      messageFactories.add(factory);
}

public Message createMessageFromString(String messageString) {

    for (AbstractMessageFactory f: messageFactories) {
          if (f.matches(messageString) {
               return f.createMessage(messageString);
          }
    }

    throw new UnhandledMessageException(messageString);
}

Un esempio di una classe factory astratta:

public TrapMessageFactory implements AbstractMessageFactory {

     public matches(String messageString) {
         return messageString.contains("1.1.1.0.2.6.22.33");
     }

     public createMessage(String messageString) {
          return new TrapMessage(messageString);
     }
}

Ora potrebbe annidare fabbriche del genere con alcune fabbriche che fanno lo stesso e delegano alla propria lista di fabbriche di messaggi, che delegano anche e così via. Ciò potrebbe avere benefici in termini di prestazioni, poiché può ridurre alcuni confronti ridondanti. Ma vorrei comunque sconsigliarlo, perché ora non puoi più dire in quali condizioni verrà creato esattamente un determinato messaggio semplicemente guardando il matches -method di un singolo factory.