Esiste un modello per descrivere una classe che simboleggia un'istanza di un'istanza di un'altra classe?

Bene, ecco i miei pensieri dopo aver ascoltato i tuoi suggerimenti:

Prima di tutto, un Template dovrebbe essere solo una classe di dati che legge un file di configurazione e quindi esiste in quello stato senza fare molto.

Ci sono due modi in cui un modello può essere interagito con:

1) la sua configurazione può essere cambiata (cioè campi Template aggiunti / rimossi, beni modificati, anteprime generate ecc ...)

2) i suoi campi possono essere riempiti con valori e possono essere resi

Avevo la prima mescolata con i dati del modello e la seconda è stata modellata come un lavoro.

Quindi, tenendo conto di ciò, ho trovato questo:

// this is a necessity for mixins in TypeScript
type Constructor<T> = new(...args: any[]) => T;

// the "pure data" template class
class Template {
    templateFieldGroups : TemplateFieldGroup[];
    // other properties

    constructor() {
        // load from disk
    }
}

// The mixin to add Job-specific functionality (saving TemplateField values and rendering)
function JobMixin<T extends Constructor<Template>>(Base : T) {
    return class extends Base {
        constructor(...args: any[]) {
            super(...args);
        }

        render(){}
        saveValuesToDB(){}
        loadValuesFromDB(){}
    }
}

// The mixin to add management functionality
function TemplateManagerMixin<T extends Constructor<Template>>(Base : T) {
    return class extends Base {
        constructor(...args: any[]) {
            super(...args);
        }

        createPreviews(){}
    }
}

// The class that will be used to configure the templates
class TemplateManager extends TemplateManagerMixin(Template) {
}

// The class that will be used to handle specific template instances and render them
class Job extends JobMixin(Template) {
}

Non so se questo è davvero il modo migliore per farlo, ma sembra essere abbastanza intuitivo dal punto di vista dell'usabilità per me.

Grazie ancora a kamikaze e Thomas Junk per il tuo contributo.

La domanda è: cosa vuoi ottenere usando questo design. Se ciò che intendi fare ha un senso può anche dipendere dal fatto che è il modo comune per farlo nella lingua che hai scelto.

Per me la tua spiegazione mi sembra che il tuo lavoro sia ereditato dal tuo Template.

Il tuo codice sembra che il tuo modello sia una fabbrica di lavoro.

Quest'ultimo ha più senso per me. Lo scopo dell'ereditarietà è quello di ottenere il polimorfismo di runtime. Un modello non è un lavoro e viceversa.

Rendere il tuo modello una fabbrica di lavoro ha perfettamente senso. Quello che vorrei raccomandare è che il tuo lavoro prenda un riferimento di modello nel suo costruttore per creare un'aggregazione (questo è anche chiamato iniezione di dipendenza).

In C ++ vorrei dichiarare friend class Template e rendere privato il costruttore di Job in modo che solo il tuo Job factory (ovvero la classe Template) possa creare lavori.

In Java renderei protetto il costruttore di Job e inserirli in uno spazio dei nomi comune.

Da quello che vedo qui, avrebbe senso avere i seguenti componenti:

• Modello: contiene le informazioni necessarie per il rendering. Limita la modifica di alcune delle sue parti. Rende stesso

• Template Builder - che configura il modello con le informazioni necessarie.

Il flusso modellato sarebbe qualcosa del tipo:

template = new TemplateBuilder(config).build();
template.render()

Nessun "lavoro" richiesto.

Il tuo "modello" è qualcosa come un factory e il tuo job esegue qualche configurazione ed esegue il "rendering", che dal mio punto di vista non dovrebbe - perché non è una sua responsabilità.