Propriétés et modules standards
Il est possible d'inclure dans un module des propriétés comme dans les modules de classe.
Ainsi le code suivant est valide dans un module standard.
Private myVar As Integer
Property Get
Public Property Get foo() As Integer
foo = myVar
End Property
Property Let
Public Property Let foo(byVal argA As Integer)
myVar = argA
End Property
Usage de la propriété
Public Sub UseProperty()
foo = 12
Debug.Print foo
End Sub
Propriétés et arguments multiples
Une propriété peut avoir plus d'un argument qui se déclarent à l'identique que pour une fonction. Dans la propriété, les arguments s'utilisent de façon classique.
Public Property Let foo(byVal argA As Integer, byVal argB As Integer)
varA = argA
varB = argB
End Property
L'appel est un peu particulier en ce sens que c'est le dernier argument qui reçoit une valeur et le premier est passé comme paramètre.
Debug.Print myClass.foo(5) = 8
Dans cet appel, la valeur 5 est affectée au paramètre argA, tandis que la valeur 8 est attribuée à l'argument argB.
Quand une propriété reçoit plus d'un paramètre, c'est toujours le dernier qui reçoit la valeur.
Arguments optionnels
Une propriété Let doit toujours posséder un argument obligatoire.
Elle ne peut donc avoir un seul argument qui serait optionnel même s'il possède une valeur par défaut, ainsi le code suivant est invalide.
Public Property Let foo(Optional byVal argA As Integer = 3)
Déclaration d'un paramètre optionnel
Contrairement à une procédure classique, les paramètres optionnels doivent toujours être déclarés avant l'argument obligatoire.
Public Property Let fooA(Optional ByVal argA As Integer = 2, ByVal argB As Integer)
varA = argA
varB = argB
End Property
Utilisation du paramètre optionnel
Le paramètre optionnel est passé comme paramètre, l'argument obligatoire comme valeur.
Debug.Print myClass.foo(10) = 3
Dans ce cas de figure, le paramètre facultatif prend la valeur 10 et la valeur 3 est transmise à l'argument obligatoire.
Plusieurs paramètres optionnels
C'est la même démarche qu'avec un seul paramètre. Ils sont tous déclarés avant l'argument obligatoire.
Public Property Let fooA(Optional ByVal argA As Integer = 2, Optional ByVal argB As Integer = 10, ByVal argC As Integer)
varA = argA
varB = argB
varC = argC
End Property
De la même manière l'argument obligatoire est passé après l’égal.
Debug.Print myClass.foo(5, 3) = 8
L'argument argA prend la valeur 5, argB prend la valeur 3 et argC la valeur 8.
Utiliser la valeur par défaut
L'appel est classique
Debug.Print myClass.foo(5) = 8 ' Utiliser la valeur par défaut du second argument.
Debug.Print myClass.foo(, 3) = 8 ' Utiliser la valeur par défaut du premier argument.
Mélanger paramètres optionnels et obligatoires
La signature de la propriété est un peu plus complexe.
- On déclare d'abord tous les paramètres obligatoires sauf celui qui sera affecté à la propriété.
- Suivent ensuite les paramètres optionnels.
- Enfin on déclare l'argument transmis à la propriété.
Public Property Let foo(ByVal argA As Byte, ByVal argB As Byte, Optional ByVal argC As Byte = 1, Optional ByVal argD As Byte = 2, ByVal argE As String)
L'appel est des plus classiques :
Debug.Print myClass.foo(5, 2, 10, 7) = "Hello" ' Passage de tous les paramètres.
Debug.Print myClass.foo(5, 2, 10) = "Hello" ' Omission du second argument optionnel.
Debug.Print myClass.foo(5, 2, , 7) = "Hello" ' Omission du premier argument optionnel.
Achetez mon ouvrage !
Mon PDF « Créer un planning perpétuel sur Microsoft Excel sans macro » est disponible à la vente.
Pour plus d’informations, rendez-vous sur la page dédiée.