Comment : modifier la valeur d'un argument de la procédure (Visual Basic)

Article
06/02/2023

Lorsque vous appelez une procédure, chaque argument que vous fournissez correspond à l’un des paramètres définis dans la procédure. Dans certains cas, le code de procédure peut modifier la valeur sous-jacente d’un argument dans le code appelant. Dans d’autres cas, la procédure ne peut modifier que sa copie locale d’un argument.

Lorsque vous appelez la procédure, Visual Basic effectue une copie locale de chaque argument passé par ByVal. Pour chaque argument passé par ByRef, Visual Basic fournit au code de procédure une référence directe à l’élément de programmation sous-jacent à l’argument dans le code appelant.

Si l’élément sous-jacent du code appelant est un élément modifiable et que l’argument est passé par ByRef, le code de procédure peut utiliser la référence directe pour modifier la valeur de l’élément dans le code appelant.

Modification de la valeur sous-jacente

Pour modifier la valeur sous-jacente d’un argument de procédure dans le code appelant

Dans la déclaration de procédure, spécifiez ByRef pour le paramètre correspondant à l’argument.
Dans le code appelant, passez un élément de programmation modifiable en tant qu’argument.
Dans le code appelant, ne placez pas l’argument entre parenthèses dans la liste d’arguments.
Dans le code de procédure, utilisez le nom du paramètre pour attribuer une valeur à l’élément sous-jacent dans le code appelant.

Consultez l’exemple plus bas pour une démonstration.

Modification des copies locales

Si l’élément sous-jacent dans le code appelant est un élément non modifiable ou si l’argument est passé par ByVal, la procédure ne peut pas modifier sa valeur dans le code appelant. Toutefois, la procédure peut modifier sa copie locale d’un tel argument.

Modifier la copie d’un argument de procédure dans le code de procédure

Dans la déclaration de procédure, spécifiez ByVal pour le paramètre correspondant à l’argument.

-ou-

Dans le code appelant, placez l’argument entre parenthèses dans la liste d’arguments. Cela force Visual Basic à passer l’argument par valeur, même si le paramètre correspondant spécifie ByRef.
Dans le code de procédure, utilisez le nom du paramètre pour attribuer une valeur à la copie locale de l’argument. La valeur sous-jacente dans le code appelant n’est pas modifiée.

Exemple

L’exemple suivant montre deux procédures qui prennent une variable de tableau et fonctionnent sur ses éléments. La procédure increase en ajoute simplement une à chaque élément. La procédure replace attribue un nouveau tableau au paramètre a(), puis en ajoute un à chaque élément.

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(ByRef 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 deuxième appel MsgBox affiche « After replace(n): 101, 201, 301 ». Étant donné que n est passé par ByRef, replace peut modifier la variable n dans le code appelant et lui attribuer un nouveau tableau. Étant donné que n est un type de référence, replace peut également modifier ses membres.

Vous pouvez empêcher la procédure de modifier la variable elle-même dans le code appelant. Voir Comment : protéger un argument de procédure contre les modifications de valeur.

Compiler le code

Lorsque vous passez une variable par référence, vous devez utiliser le mot clé ByRef pour spécifier ce mécanisme.

La valeur par défaut dans Visual Basic consiste à passer des arguments par valeur. Toutefois, il est recommandé d’inclure le mot clé ByVal ou ByRef avec chaque paramètre déclaré. Cela facilite la lecture de votre code.

Sécurité du .NET Framework

Il existe toujours un risque lors de l’attribution à une procédure d’une permission de modifier la valeur sous-jacente d’un argument dans le code appelant. Veillez à ce que cette valeur soit modifiée et préparez-vous à vérifier sa validité avant de l’utiliser.

Partager via