Friend Dependency Remocation Refactoring

En el ámbito del desarrollo de software, las declaraciones de amigos pueden introducir problemas de acoplamiento y mantenimiento estrictos. Esta guía proporciona una hoja de ruta detallada para refactorizar una dependencia de un amigo correctamente, transformando su base de código en una estructura más mantenible y resistente.

revelando la necesidad de refactorizar

Considere el siguiente escenario: ClassA y ClassAaccessor Comparte un amigo Dependence, otorgando el acceso a ClassAacCeCeCCEACCEACCECCEAR a un profesor protegido de ClassAse de ClassAd de ClassAs de ClassA. Si bien esto puede parecer conveniente, plantea varios inconvenientes:

• uml 2.2 ha desaprobado el estereotipo de amigo.
• La mayoría de las pautas de codificación desalientan el uso de un amigo debido a la dependencia excesiva que crea. Nightmares.

refactoring step-by-step

Paso 1: Introducir una interfaz abstracta

Reemplace la declaración de un amigo con una interfaz de clase llamada Interinterface, dividiendo la relación de un amigo en una relación de llamada y una llamada directa de la dependencia de la dependencia y una llamada de la dependencia de la dependencia directa de la dependencia. InternalInterface.

Paso 2: Mueva las operaciones a la interfaz

Identifique las operaciones que constituyen la dependencia de la llamada y las mueven de classA a InternerFace, extendiendo Interface Interface con un constructor protegido y marcan la Asociación de Generalización de ClassA a la Interna Interna como protegido. Componentes

ClassAaccessor necesita una referencia a InternerInterface. Implemente un método adicional, adjunteCcessor (), en ClassA y úselo para pasar una referencia a InternalInterface a ClassAaccessor a través de SetInternalInterfaceref (). Este método se llamará cuando se invoca ClassA :: adjectAccessor ().

c Implementación

// Definición de ClassAacCessor clase ClassAaccessor { público: ClassAaccessor (ClassA & ClassA); void setInternalInterfaceref (InternalInterface y NewValue); privado: InternalInterface* InternalInterfaceref; }; // Método para establecer la referencia a InternerInterface ClassA :: AttachACCessor (ClassAacCesor & Accessor) { accesor.setinternalinterfaceref (*esto); }

mejora opcional: introducir una internaintainterface

// 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);
}

[&] [&] Puede refactorizar efectivamente una dependencia de un amigo, mejorar la estabilidad del código, la mantenimiento y el cumplimiento de la codificación de las mejores prácticas. Recuerde evaluar cuidadosamente los posibles inconvenientes asociados con este enfoque antes de implementarlo en su propia base de código.