Sto avendo un po 'di dilemma del design qui. Sto scrivendo una libreria che consiste in un gruppo di classi template progettate per essere utilizzate come base per la creazione di contenuti. Ad esempio:
public class Template
{
public string Name {get; set;}
public string Description {get; set;}
public string Attribute1 {get; set;}
public string Attribute2 {get; set;}
public Template()
{
//constructor
}
public void DoSomething()
{
//does something
}
...
}
Il problema è, non solo la libreria che fornisce i modelli, ma fornirà anche alcuni modelli predefiniti che sono esempi di queste classi template. La domanda è: dove inserisco queste istanze dei modelli?
Le tre soluzioni che ho inventato finora sono:
1) Fornisci istanze serializzate dei modelli come file.
Da un lato, questa soluzione manterrebbe le istanze separate dalla libreria stessa, il che è bello, ma potrebbe anche aggiungere complessità per l'utente. Anche se forniamo metodi per caricare / deserializzare i file, dovrebbero comunque avere a che fare con un mucchio di file e qualche tipo di file di configurazione in modo che l'app sappia dove cercare quei file. Inoltre, la creazione dei file modello richiederebbe probabilmente un'app separata, quindi se l'utente volesse attenersi al metodo dei file di archiviazione dei modelli, dovremmo fornire un qualche tipo di app per la creazione dei file modello.
Inoltre, questo richiede dipendenze esterne per testare i modelli nel codice dell'utente.
2) Aggiungi istanze di sola lettura alla classe template
Esempio:
public class Template
{
public string Name {get; set;}
public string Description {get; set;}
public string Attribute1 {get; set;}
public string Attribute2 {get; set;}
public Template PredefinedTemplate
{
get
{
Template templateInstance = new Template();
templateInstance.Name = "Some Name";
templateInstance.Description = "A description";
...
return templateInstance;
}
}
public Template()
{
//constructor
}
public void DoSomething()
{
//does something
}
...
}
Questo metodo sarebbe conveniente per gli utenti, poiché sarebbero in grado di accedere direttamente ai modelli predefiniti nel codice e sarebbero in grado di unificare il codice di test che li ha usati. Lo svantaggio qui è che i modelli predefiniti inquinano lo spazio dei nomi del tipo di modello con un mucchio di cose extra. Suppongo che potrei mettere i modelli predefiniti in uno spazio dei nomi diverso per ovviare a questo inconveniente. L'unico altro problema con questo approccio è che dovrei praticamente duplicare tutti gli spazi dei nomi nella libreria nello spazio dei nomi predefinito (ad esempio Templates.SubTemplates e Predefined.Templates.SubTemplates) che sarebbe un problema, e renderebbe anche il refactoring più difficile.
3) Rendi i modelli delle classi astratte e fai ereditare i modelli predefiniti da quelle classi.
Ad esempio:
public abstract class Template
{
public string Name {get; set;}
public string Description {get; set;}
public string Attribute1 {get; set;}
public string Attribute2 {get; set;}
public Template()
{
//constructor
}
public void DoSomething()
{
//does something
}
...
}
e
public class PredefinedTemplate : Template
{
public PredefinedTemplate()
{
this.Name = "Some Name";
this.Description = "A description";
this.Attribute1 = "Some Value";
...
}
}
Questa soluzione è molto simile alla # 2, ma finisce per creare un sacco di classi che non fanno veramente nulla (nessuno dei nostri modelli predefiniti ha un comportamento prevalente) e non hanno alcun metodo, quindi io Non sono sicuro di quanto sia buona questa pratica.
Qualcun altro ha avuto qualche esperienza con qualcosa del genere? Esiste una buona pratica di qualche tipo o un approccio diverso / migliore a cui non ho pensato? Sto quasi sbattendo la testa contro un muro cercando di capire il modo migliore per andare.
Grazie!