È buona norma utilizzare costanti, tipi e funzioni globali all'interno delle classi VBA?

Question

Ho iniziato a utilizzare le classi VBA e ho sempre cercato di scrivere il mio codice in modo tale che ogni classe sia "indipendente", cioè abbia tutto ciò di cui ha bisogno - costanti, funzioni, ecc. - all'interno. Ultimamente, però, questo approccio ha portato alla duplicazione del codice poiché, invece di chiamare funzioni pubbliche in diversi moduli, ho copiato alcuni codici dal "mondo esterno" (nello stesso progetto) in una classe solo per mantenere la sua "autosufficienza" .

Sto considerando di cambiare alcune classi in modo che possano accedere a funzioni, costanti, tipi, ecc. Da altri moduli come qualsiasi altro modulo, ma qualcosa in me mi sta dicendo che potrebbe non essere una buona pratica. Qualcuno può dirmi che quello che la piccola voce sta dicendo è sbagliato? C'è un approccio migliore?

Grazie.

Aggiornamenti:

Le mie scuse per non aver fornito i dettagli in precedenza. Ecco un esempio di codice:

'------------------------------------- 
'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 i codici con "< ====" nei commenti; la classe usa tipi, funzioni e costanti definiti al di fuori della classe, e questo è ciò che mi meraviglia se è una buona pratica o se c'è un'opzione migliore. Immagino di non avere completamente il concetto di incapsulamento.

Answer 1

Non ho mai inserito le costanti pubbliche in un modulo di classe. Tutte, e intendo tutte, le mie variabili e costanti pubbliche sono in un modulo standard chiamato MGlobals. Questo ha due vantaggi. Per prima cosa tu e io sappiamo che entrambi sanno dove trovarli, sono un po 'pericolosi e devono essere rintracciabili. In secondo luogo, se quel modulo ottiene sempre più di poche righe, so che sono pigro e ho bisogno di un refactoring.

È buona norma provare a mantenere i moduli di classe modulari. Ma non impazzire. Una buona programmazione non farà mai cadere una selezione di moduli in un progetto e averli solo funzionanti. C'è, e dovrebbe essere, integrazione da fare su qualsiasi progetto di significato.

Answer 2

Questo è proprio così sbagliato. Op ha fatto perfettamente la mia domanda, e la risposta è così piatta.

IME, la risposta che l'OP stava cercando (nel 2012!), Era che dovevano inoltrare i valori necessari attraverso il ClassName.Module (cosa opzionale come var,). Quindi possono inviare i valori specifici per le varianti presumibilmente ripetibili di una richiesta e ricevere una nuova risposta per una richiesta che corrisponde ad altre richieste su altre macchine e può essere utilizzata in un altro progetto senza cambiare la classe. Mentre è vero che l'integrazione richiede un cambiamento, non dovrebbe mai essere sul lato classe. Se distruggi l'integrità della classe diventa un modulo.

file INI di fuori d'altra parte ...