Comment : protéger un argument de procédure contre les modifications de valeur (Visual Basic)

Article
06/08/2015

Si une procédure déclare un paramètre comme ByRef (Visual Basic), Visual Basic donne au code de procédure une référence directe à l'élément de programmation sous-jacent à l'argument dans le code appelant. Cela permet à la procédure de modifier la valeur sous-jacente à l'argument dans le code appelant. Il peut arriver que le code appelant tente de se protéger contre une telle modification.

Vous pouvez toujours protéger un argument d'une modification en déclarant le paramètre Byval (Visual Basic) correspondant dans la procédure. Si vous voulez avoir la possibilité de modifier un argument donné lorsque vous le souhaitez, vous pouvez le déclarer ByRef et laisser le code appelant déterminer le mécanisme de passage pour chaque appel. Il procède en mettant l'argument correspondant entre parenthèses pour le passer par valeur, ou en ne le mettant pas entre parenthèses pour le passer par référence. Pour plus d'informations, consultez Comment : forcer le passage d'un argument par valeur (Visual Basic).

Exemple

L'exemple suivant illustre deux procédures qui acceptent une variable tableau et opèrent sur ses éléments. La procédure increase ajoute simplement la valeur 1 à chaque élément. La procédure replace assigne un nouveau tableau au paramètre a(), puis ajoute la valeur 1 à chaque élément. Cependant, la réassignation n'affecte pas la variable tableau sous-jacente dans le code appelant.

Public Sub increase(ByVal a() As Long)
    For j As Integer = 0 To UBound(a)
        a(j) = a(j) + 1
    Next j
End Sub

Public Sub replace(ByVal a() As Long)
    Dim k() As Long = {100, 200, 300}
    a = k
    For j As Integer = 0 To UBound(a)
        a(j) = a(j) + 1
    Next j
End Sub

Dim n() As Long = {10, 20, 30, 40}
Call increase(n)
MsgBox("After increase(n): " & CStr(n(0)) & ", " & 
    CStr(n(1)) & ", " & CStr(n(2)) & ", " & CStr(n(3)))
Call replace(n)
MsgBox("After replace(n): " & CStr(n(0)) & ", " & 
    CStr(n(1)) & ", " & CStr(n(2)) & ", " & CStr(n(3)))

Le premier appel MsgBox affiche "After increase(n): 11, 21, 31, 41". Étant donné que le tableau n est un type référence, replace peut modifier ses membres, même si le mécanisme de passage est ByVal.

Le second appel MsgBox affiche "After replace(n): 11, 21, 31, 41". Étant donné que n est passé ByVal, replace ne peut pas modifier la variable n dans le code appelant en lui assignant un nouveau tableau. Lorsque replace crée la nouvelle instance de tableau k et l'assigne à la variable locale a, il perd la référence à n passée par le code appelant. Lorsqu'il modifie les membres de a, seul le tableau local k est affecté. Par conséquent, replace n'incrémente pas les valeurs du tableau n dans le code appelant.

Compilation du code

Le comportement par défaut en Visual Basic consiste à passer les arguments par valeur. En programmation, il est toutefois conseillé d'ajouter le mot clé Byval (Visual Basic) ou ByRef (Visual Basic) avec chaque argument déclaré. Cela rend votre code plus lisible.