Typecast ou méthode de conversion?

Question

J'ai une classe conteneur avec des paramètres qui proviennent de différents types de fichiers de configuration (texte ou xml par exemple). J'ai donc fait une classe pour textConfigurationFiles et une classe pour xmlConfigurationFiles (je pense que je vais implémenter une interface IConfigFile pour cela plus tard).

L'initialisation de ma classe conteneur se présente comme suit:

ContainerClass myContainer = new ContainerClass(); 
myTextConfig = new TextConfig(textFile); 
myContainer.ParameterA = myTextConfig.ParameterA; 
myContainer.ParameterB = myTextConfig.ParameterB; 
myContainer.ParameterC = myTextConfig.ParameterC; 

ou xml

ContainerClass myContainer = new ContainerClass(); 
myXMLConfig = new XMLConfig(xmlFile); 
myContainer.ParameterA = myXMLConfig.ParameterA; 
myContainer.ParameterB = myXMLConfig.ParameterB; 
myContainer.ParameterC = myXMLConfig.ParameterC; 

mais au lieu d'attribuer à chaque valeur unique que je voudrais faire une sorte de conversion. Maintenant, je ne sais pas si je devrais implémenter un transtypage ou simplement une méthode simple qui retourne un objet ContainerClass?

myContainer = myTextConfig.ConvertToContainer(); 

ou

myContainer = (ContainerClass)myTextConfig; 

Quelle serait votre suggestion? Parce que j'essaie de mettre en œuvre le principe de la responsabilité unique, je veux que mon ContainerClass représente un conteneur simple. Donc je pense quelque chose comme

ContainerClass myContainer = new ContainerClass(configFile); 

romprait avec SRP? Peut-être que je devrais mentionner que mon ContainerClass est initialisé par un texte ou un fichier xml; ce n'est pas que les paramètres résultent à la fois d'un texte et un fichier xml.

---

[EDIT: Informations supplémentaires]

ContainerClass représente un conteneur avec des informations de configuration de base de données (chemins, nom, etc.). TextFile représente une configuration de base de données.

XmlFile contient également une configuration de base de données, mais possède plus de paramètres (de configuration de base de données) que mon fichier textFile.

Je pense à sth. comme:

IConfig  config = new TextFileConfig(fileName); 
ContainerClass container = config.ConverToContainer(); 

ou

IConfig  config = new TextFileConfig(fileName); 
ContainerClass container = (ContainerClass)config; 

En TextFileConfig:

public class TextFileConfig : IConfig 
{ 
    ContainerClass container; 

    // 
    // Constructor 
    // 
    public TextFileConfig(string fileName) 
    { 
     // 
     // Initialize all values from file fileName 
     // 
     ... 

     // 
     // Initialize container with standard values 
     // 
     container = new ContainerClass(); 

     // 
     // Merge container with values from textFile 
     // 
     ... 

     // 
     // Now container contains all values from textFile, 
     // all missing parameters are initialized with 
     // standard values. 
     // 
    } 


    public ContainerClass ConvertMethodOrTypecastThatsTheQuestion() 
    { 
     return container; 
    } 
} 

Donc, si je préfère une méthode de conversion, une conversion de type ou les deux? Dans un premier temps, je pense à la performance, au meilleur usage et aux habitudes personnelles.

Answer 1

Je pense que je ferais quelque chose le long des lignes de thèses:

• Créer un type qui représente votre configuration: IConfig
• Créer un type qui représentent votre chargeur de configuration IConfigLoader
• Créer différents chargeur de configuration implémentations (XmlConfigLoader, TextConfigLoader, etc.) qui renvoie IConfig instances.
• Choisissez l'implémentation du chargeur à utiliser de manière dynamique, ou par config, ou par codage, etc. Vous pouvez utiliser une fabrique abstraite ou un conteneur IoC par exemple.
• Transmettez l'instance IConfig chargée au constructeur ContainerClass et laissez-la s'initialiser.

En ce qui concerne votre question, je ne suis pas sûr que passer un objet de configuration au conteneur va casser le SRP. Au moins, vous pourriez avoir une fabrique pour votre conteneur, qui prendrait et lirait la configuration afin d'instancier et d'initialiser le conteneur. Il peut être sur-conçu - cela dépendrait du niveau de complexité de la tâche de création de conteneur, je suppose.