Comment refactoriser une dépendance d'ami dans votre code ?

Refactoring de suppression des dépendances d'amis

Dans le domaine du développement logiciel, les déclarations d'amis peuvent introduire des problèmes de couplage étroit et de maintenance. Ce guide fournit une feuille de route détaillée pour refactoriser correctement une dépendance d'ami, transformant votre base de code en une structure plus maintenable et plus résiliente.

Dévoilement de la nécessité d'une refactorisation

Considérez ce qui suit Scénario : ClassA et ClassAAccessor partagent une dépendance ami, accordant à ClassAAccessor l'accès aux membres protégés de ClassA. Bien que cela puisse sembler pratique, cela présente plusieurs inconvénients :

• UML 2.2 a rendu obsolète le stéréotype de l'ami.
• La plupart des directives de codage découragent l'utilisation des amis en raison de la dépendance excessive qu'elle crée.
• Cela peut conduire à des cauchemars de maintenance.

Refactoring étape par étape

Étape 1 : introduire une interface abstraite

Remplacez la déclaration d'ami par une interface de classe appelée InternalInterface, divisant la relation d'ami en une dépendance directe et une dépendance d'appel sur InternalInterface.

Étape 2 : Déplacer les opérations vers l'interface

Identifiez les opérations constituant la dépendance d'appel et déplacez-les de ClassA vers InternalInterface, en étendant InternalInterface avec un constructeur protégé et en marquant l'association de généralisation de ClassA à InternalInterface comme protégée.

Étape 3 : Connectez les composants

ClassAAccessor a besoin d'une référence à InternalInterface. Implémentez une méthode supplémentaire, attachAccessor(), dans ClassA et utilisez-la pour transmettre une référence à InternalInterface à ClassAAccessor via setInternalInterfaceRef(). Cette méthode sera appelée lorsque ClassA::attachAccessor() est invoquée.

Implémentation C

<code class="cpp">// ClassAAccessor definition
class ClassAAccessor {
public:
    ClassAAccessor(ClassA& classA);
    void setInternalInterfaceRef(InternalInterface &newValue);
private:  
    InternalInterface* internalInterfaceRef;
};

// Method to set the reference to InternalInterface
ClassA::attachAccessor(ClassAAccessor &accessor) {
    accessor.setInternalInterfaceRef(*this);
}</code>

Amélioration facultative : introduction d'une interface client interne

Pour découpler davantage l'implémentation, envisagez d'introduire une autre InternalClientInterface comme intermédiaire entre ClassA et ClassAAccessor.

Conclusion

En suivant ces étapes, vous pouvez refactorisez efficacement une dépendance d'ami, améliorant ainsi la stabilité du code, la maintenabilité et le respect des meilleures pratiques de codage. N'oubliez pas d'évaluer soigneusement les inconvénients potentiels associés à cette approche avant de l'implémenter dans votre propre base de code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!