Quel modèle de conception pour les fonctions qui produisent le même résultat mais prennent des paramètres différents? - c #, oop, design-patterns

J'ai hérité d'un peu plus de 1000 lignes de spaghettiscode. Je peux le décomposer en une douzaine de méthodes créant chacune un FinancialTransactionObject mais prenant différentes dates, quantités et autres paramètres pour créer leur transaction.

Mon instinct me dit de faire de chaque méthode sa propre classe. Je peux donc avoir une douzaine de classes héritées d'une classe de base ou d'une interface avec 1 méthode:

abstract FinancialTransactionObject Calculate();

et déplacez les paramètres soit vers les constructeurs ouen faire des propriétés publiques. Les constructeurs signifient que je ne peux pas réutiliser mon instance et que je dois créer un nouvel objet à chaque fois. Les propriétés signifient que le code consommateur peut oublier de les définir. Laisser des paramètres sur chaque méthode me donne juste une douzaine de méthodes dans des fichiers séparés et ne se sent pas orienté objet.

Il semble qu'une variante de ce problème se pose souvent. Existe-t-il un modèle de conception cohérent pour l’ensemble du secteur?

Réponses:

0 pour la réponse № 1

Cela me semble vraiment comme un Modèle de visiteur.

L'idée de base du modèle de visiteur est donc de modifier le comportement de manière dynamique en fonction du type d'implémentation.

Vous aurez besoin de 2 choses principales:

1. IVisitable avec un Accept méthode ayant le IVisitor comme le paramètre.
2. IVisitor avec beaucoup Visit méthodes pour chaque implémentation de IVisitable

Je vais commencer par le numéro 2. Ceci (dans votre cas) sera une interface, qui a toutes les implémentations de votre méthode de calcul (pour chacune des classes que vous avez mentionné que vous voulez créer). Permet d'appeler votre Visitor et Visit méthodes Calculator et Calculate. Ensuite, vous aurez:

interface ICalculator
{
FinancialTransactionObject Calculate(Element1 element);
FinancialTransactionObject Calculate(Element2 element);
FinancialTransactionObject Calculate(Element3 element);
.
.
}

Ensuite, la première partie - toutes les classes d'éléments, héritera d'une classe de base Element, qui mettra en œuvre IVisitable. Et puis quelque chose comme:

abstract class Element
{
public FinancialTransactionObject result { get; private set; }

protected void Accept(ICalculator calculator)
{
this.result = calculator.Calculate(this);
}
}

Vous allez vous retrouver avec quelque chose comme:

var calculator = new Calculator(); //this is the class that implements the interface
var el1 = new Element1();
var el2 = new Element2();

el1.Accept(calculator);
el2.Accept(calculator);

Ensuite, bien sûr, en fonction de la mise en œuvre, vos objets el auront leurs valeurs de résultat.

Je ne suis pas sûr que ce soit la meilleure solution à votre problème (s’il en est un), mais me semble être celle que vous recherchez. J'espère que cela vous aidera.

PS: Je pensais nommer IVisitable à ICalculatable mais ça sonnait bizarre :)

---