J'ai le scénario suivant.Quelle serait l'approche de conception correcte?
J'ai une classe Validator contenant la fonction validate (Command *) qui valide la commande qui lui est passée. J'ai trois classes disons WindowsExecute, SolarisExecute et AIXExecute
La fonction membre execute() dans SolarisExecute et AIXExecute créent directement l'objet Validator et utilisent la fonction validate (Comman *) pour valider la commande avant l'exécution. WindowsExecute est complètement différent et ne possède aucune commande.Au lieu de cela, il doit valider certaines données de chaîne. Pour ce faire, il existe une classe distincte appelée WindowsValidator héritée de Validator. WindowsExecute :: execute() utilise WindowsValidator au lieu de Validator.
class WindowsValidator : Validator
{
public:
validate(const string &xmlData)
{
// specific validation logic
}
}
class WindowsExecute
{
public:
execute(const string &data)
{
WindowsValidate v;
bool valid = v.validate(data);
// some processing depending on 'valid'
}
}
Ceci est un code existant.
Maintenant, j'ai besoin de faire des validations spécifiques de Solaris et je ne peux donc pas utiliser Validator :: validate (Command *). Suivant la conception actuelle, je devrais créer une nouvelle classe appelée SolarisValidator et avoir ma propre implémentation de validate (Command *).
Je ne suis pas à l'aise avec cette approche. Quelques problèmes/commentaires Je pense:
La classe Validator ne sera utilisée que par AIXExecute. Alors pourquoi avoir une classe de base s'il n'y a plus de logique commune? Il suffit d'avoir trois classes SolarisValidator, AIXValidator, WindowsValidator.
Validator :: validate (Command *) est hérité inutilement dans la classe WindowsValidate. Notez que la signature de WindowsValidate :: validate (string) et Validator :: validate (Command *) sont différentes.
Je devrais rendre Validator :: validate (Command *) virtual si je présente SolarisValidator :: validate (Command *). Cela signifie que j'introduis de l'overhead de pointeurs virtuels même si je n'utilise aucun polymorphisme dynamique. Alors pourquoi ne pas aller aveC# 1 ci-dessus et créer trois classes distinctes?
Quelle serait la meilleure solution pour ce scénario qui serait également extensible à l'avenir? J'utilise C++ pour la mise en œuvre.
Merci d'avance.
-GP