Refactorisation: Classe imbriquée ou classes séparées?

Question

Je suis actuellement en train de refactoring (ajout de nouvelles fonctionnalités) à certaines de nos classes de frameworks. La situation est que nous avons une seule classe (semblable à un dieu) qui fait un tas de logique que nous aimerions diviser. La classe représente quelque chose comme une règle de validation pour les codes fiscaux. Ce que je vais faire est de le diviser en règles uniques, essentiellement une règle qui valide le prénom de la personne par rapport au code fiscal, une autre pour la date de naissance et ainsi de suite. Pour le programmeur à la fin, il ressemble presque à la même chose. Au lieu d'invoquer l'énorme constructeur de la règle FiscalCode, il va faire quelque chose comme FiscalCode.GetRules(...) et passer les paramètres ici. Le GetRules(...) va ensuite construire en interne les règles uniques et les renvoyer en tant que tableau. C'est parfaitement bien et correct pour nous.

Voilà pour votre expérience. Maintenant, ma question est la suivante. La classe FiscalCode (qui est notre classe dieu puissante actuelle) a beaucoup de méthodes utilitaires qui seront nécessaires par plus de «classes de règles» que je vais créer. Ce que je sais, c'est que je vais toujours avoir besoin de la classe FiscalCode, pour faire la chose GetRules(...) (cela doit rester constant d'une manière ou d'une autre pour les programmeurs, pas qu'ils aient à faire quelque chose de complètement nouveau).

J'ai deux options qui me viennent à l'esprit:

1. Créer mes nouvelles classes de règles et accéder aux méthodes utilitaires statiques publics de la classe FiscalCode
2. Créer mes nouvelles classes de règles que les classes imbriquées internes du Classe FiscalCode st J'ai déjà accès aux méthodes utilitaires (et donc pas besoin d'exposer mes méthodes utilitaires)

J'ai déjà un favori, mais j'aimerais d'abord entendre l'opinion de certains d'entre vous.

Thx

Answer 1

Comme vos méthodes sont devenues « méthodes utilitaires » dont vous avez besoin pour les rendre statiques et public, mais probablement vous devez renommer votre FiscalCode à FiscalCodeUtil. Donc, il sera évident quel genre de méthodes il contient.

Answer 2

Quelles sont les dépendances de ces méthodes d'utilitaire sur la classe FiscalCode ou les classes de règles? Y a-t-il un état gardé par eux? S'il n'y a pas de dépendances, je suggère de déplacer ces méthodes utilitaires vers une classe séparée, et d'avoir la classe FiscalCode ou la classe de règles appelée dans ces méthodes, selon le cas.

Pour les options que vous donnez, la seule différence entre 1) et 2) est de savoir si les classes de règles sont visibles pour les classes qui ne les utilisent pas. Je ne pense pas que ce soit vraiment un objectif important. J'avais l'habitude de m'inquiéter à ce sujet tout le temps quand j'ai fait du C++ ... c'était une perte de temps.

Answer 3

IMO vous devriez aller pour la première option parce que de cette façon, vous pouvez exposer les classes nouvellement créées au monde extérieur, et pouvez écrire du code qui est réutilisable ailleurs aussi bien. Si vous allez avec la deuxième option, vous créez des classes très spécialisées. Votre code extérieur peut même ne pas connaître son existence, mais cela pourrait être bon pour l'encasulation. Cependant, à un moment donné, vous pouvez décider d'utiliser les règles spécialisées en dehors de la portée de votre classe plus grande, et pour ce scénario, vous serez mieux servi avec la première option. Quel est votre choix si?

Answer 4

Si la classe ne sera pas utilisée en dehors de la classe FiscalCode, rendez-la imbriquée.L'important est de tirer la responsabilité de cette nouvelle classe sur FiscalCode; où elle réside alors devient une simple question de choix. Lorsque la nouvelle classe aura plus de personnes à charge, vous pourriez en faire une classe extérieure.

Answer 5

j'aller avec elle comme ça (je ne suis pas bon à POO prendre donc avec un grain de sel):

classes Règle (nichée dans FiscalCode) mettre en œuvre une interface IRule exposant les méthodes de règles (comme Validate(), quel que soit le type de retour, fait flotter votre bateau). FiscalCode a une méthode AddRule() qui gère une collection interne de règles et renvoie une référence à l'auto afin de permettre l'enchaînement de la méthode:

FiscalCode fc = new FiscalCode(); 
fc.AddRule(new RuleClass1(<params specific to RuleClass1>) 
    .AddRule(new RuleClass2(<params specific to RuleClass2>) 
    ... 

En outre, FiscalCode a une méthode validate() qui le fait passer Valider de chaque règle() et gère les erreurs.

IMO est très pratique à utiliser et permet toujours aux classes de règles imbriquées d'accéder aux méthodes utilitaires de FiscalCode.

Answer 6

Je voudrais également suggérer un examen de la Specification Pattern, qui donne quelques indications sur la façon d'aborder ce type de problème. This post donne aussi quelques exemples en C#.

Le Specification Pattern suggéré vous guiderait vers votre option # 1.