¿Es una buena práctica usar constantes, tipos y funciones globales dentro de las clases de VBA?

Question

Empecé a usar clases de VBA y siempre he tratado de escribir mi código de modo que cada clase sea "independiente", es decir, tiene todo lo que necesita, constantes, funciones, etc. dentro. Últimamente, sin embargo, este enfoque ha resultado en duplicación de código ya que, en lugar de llamar funciones públicas en diferentes módulos, copié un código del "mundo exterior" (en el mismo proyecto) en una clase solo para mantener su "autosuficiencia" .

Estoy considerando cambiar algunas clases para que puedan acceder a funciones, constantes, tipos, etc. desde otros módulos como cualquier otro módulo, pero algo en mí me dice que esto podría no ser una buena práctica. ¿Puede alguien decirme que lo que la pequeña voz dice es incorrecto? ¿Hay un mejor enfoque?

Gracias.

actualizaciones:

Mis disculpas por no proporcionar detalles anteriormente. He aquí un ejemplo de código:

'------------------------------------- 
'Module 1 
'------------------------------------- 

Public Const INITIAL_VALUE As String = "Start" 
Public Const FINAL_VALUE As String = "End" 

'more constants ... 

Public Type SheetLoc 
    SheetName As String 
    SheetRow As Long 
    SheetColumn As Long 
End Type 

'more types ... 

'------------------------------------- 
'Module 2 
'------------------------------------- 

Public Function GetLocation(key As String) As SheetLoc 

    Dim myLoc As SheetLoc 

    'some codes here... 
    ' 
    With myLoc 
     .SheetName = someValue 
     .SheetColumn = anotherValue 
     .SheetRow = stillAnotherValue 
    End With 

    GetLocation = myLoc 

End Function 

'more module functions 

'------------------------------------- 
'Class Module 
'------------------------------------- 

'some codes... 

Public Sub SaveResults() 

    Dim currLoc As SheetLoc  '<==== using a type defined outside of the class 

    'more declarations .... 
    'some codes here .... 

    If currentValue = INITIAL_VALUE Then  '<=== referring to external constant 
     currLoc = GetLocation(someKey)   '<=== calling an external function 
    ElseIf currentValue = FINAL_VALUE Then '<=== referring to an external constant 
     currLoc = GetLocation(anotherKey) 
    Else 
     currLoc = GetLocation(defaultKey) 
    End If 

    'populate data ... 
    'save results ... 

End Sub 

Nota con los códigos "< ====" en los comentarios; la clase usa tipos, funciones y constantes definidas fuera de la clase, y esto es lo que me hace preguntarme si es una buena práctica o si hay una mejor opción. Supongo que simplemente no entiendo completamente el concepto de encapsulación.

Answer 1

Nunca puse constantes públicas en un módulo de clase. Todas, y quiero decir todas, mis variables públicas y constantes están en un módulo estándar llamado MGlobals. Eso tiene dos beneficios. En primer lugar, usted y yo sabemos que ambos saben dónde encontrarlos: son algo peligrosos y deben poder ser encontrados. En segundo lugar, si ese módulo alguna vez obtiene más que unas pocas líneas, sé que soy flojo y necesito refactorizar.

Es una buena práctica intentar mantener sus módulos de clase modulares. Pero no te vuelvas loco con eso. Una buena programación nunca dejará caer una selección de módulos en un proyecto y simplemente tendrá que funcionar. Hay, y debería haber, una integración que hacer en cualquier proyecto de importancia.

Answer 2

Esto está tan mal. Op hizo mi propia pregunta perfectamente, y la respuesta es muy plana.

IME, la respuesta que OP estaba buscando (en 2012!), Era que deberían reenviar los valores necesarios a través del ClassName.Module (cosa opcional como var,). Luego pueden enviar los valores específicos para las variantes supuestamente repetibles de una solicitud, y recibir una nueva respuesta para una solicitud que coincida con otras solicitudes en otras máquinas y se puede usar en otro proyecto sin cambiar la clase. Si bien es cierto que la integración requiere cambios, nunca debe estar en el lado de la clase. Si destruyes la integridad de la clase, se convierte en un módulo.

archivos INI fuera en el otro lado ...