Creazione di più istanze di una classe di implementazione

Question

Creazione di più istanze di una classe di implementazione

#1 da (1 voti)

2

Al momento ho una classe astratta e più classi che la estendono. Il mio problema è che ci deve essere un modo per creare un numero variabile di istanze di una classe estesa. Il numero di istanze dipende da alcuni risultati di un'operazione precedente e dalla stessa classe di estensione.

Per ora, c'è solo un metodo separato dalle classi che crea le istanze. Questo è un problema, perché voglio essere in grado di aggiungere una nuova classe di estensione senza modificare il codice da qualche altra parte nel programma .

Un modo per risolvere il problema potrebbe essere quello di dichiarare un metodo statico nella classe astratta e sovrascrivere la classe extendente. Ma questo è un po 'complicato perché i metodi statici e il concetto di classi astratte non funzionano bene insieme. Inoltre, la definizione di metodi statici astratti non è consentita, il che ha senso.

Come risolveresti questo problema? Forse una classe Factory per estensione della classe?

design c# inheritance abstract-class

posta Leifb 18.02.2016 - 11:31

fonte

1 risposta

Leggi altre domande sui tag design c# inheritance abstract-class

Quale tecnologia per il software di gestione alberghiera basato su web / desktop multipiattaforma Chi è responsabile per le licenze software in ITIL?

score 1 · Answer 1

Seguendo gli schemi di progettazione proposti dalla Gang of Four , puoi utilizzare Factory Abstract modello per creare un'istanza delle diverse implementazioni. Ad esempio:

abstract class Parent {
   // some abstract behaviour
}

interface ParentFactory {
    Parent Make();
}

class Impl1 : Parent {
  // some concrete behaviour
}

class Impl1Factory : ParentFactory {
    public Parent Make() {
        return new Impl1();
    }
}

class Impl2 : Parent {
  // some concrete behaviour
}

class Impl2Factory : ParentFactory {
    public Parent Make() {
        return new Impl2();
    }
}

Questo isolerà le responsabilità di creare istanze di ogni sottotipo nelle proprie classi, che possono essere collocate in spazi dei nomi diversi o anche librerie separate, consentendo di apportare modifiche isolate ogni volta che è necessario.

Ma solo il modello astratto di fabbrica da solo non è molto facile da usare, quindi una pratica comune è creare una sorta di registro, in cui il resto del sistema può richiedere una specifica implementazione. Un esempio potrebbe essere quello di utilizzare qualcosa di simile al modello Localizzatore di servizio , in questo modo:

class ParentFactories {
    private Dictionary<string, ParentFactory> factories;

    // constructor and such - probably private and following the Singleton pattern

    public void Register(string key, ParentFactory factory) {
        factories.Add(key, factory);
    }

    public Parent Make(string key) {
        return dictionary[key].Make();
    }
}

Nell'esempio precedente, ho usato un string per key , ma questo era solo per mostrare come registrare una fabbrica nel localizzatore usando un Dictionary , che è l'approccio comune. Puoi usare tutto ciò che è rilevante per le tue regole di business, inclusi i tuoi oggetti come una sorta di identificatore / oggetto di query che dice al locatore quale implementazione è richiesta.

In ogni caso, il punto di un oggetto simile a Locator è di consentire al sistema di aggiungere e / o rimuovere diversi sistemi di implementazione ParentFactory in fase di runtime. Seguendo questo schema, puoi separare le implementazioni concrete della tua classe astratta in diversi moduli dell'applicazione, e fare in modo che ogni modulo registri le sue implementazioni sul localizzatore all'avvio.