Exporter (0) Imprimer
Développer tout

Accès aux valeurs par défaut des arguments

Mise à jour : novembre 2007

Certains langages (par exemple, Visual C++ et Microsoft Visual Basic 2005) prennent en charge l'assignation de valeurs par défaut aux arguments. Ainsi, l'exemple suivant représente une déclaration Visual Basic 2005 légitime contenant les valeurs par défaut de deux des arguments.

Public Sub MyMethod (a as Integer, _
                     Optional b as Double = 1.2, _
                     Optional c as Integer = 1)

Vous pouvez utiliser un attribut de paramètre pour assigner une valeur de paramètre par défaut.

En Visual Basic et C++, les paramètres optionnels peuvent être omis lors de l'appel à la méthode. En C#, les valeurs doivent être spécifiées pour les arguments facultatifs.

Par exemple, tous les exemples Visual Basic et C++ suivants sont des appels valides pour MyMethod.

MyMethod(10, 55.3, 12);
MyMethod(10, 1.3);   // c == 1
MyMethod(11);        // b == 1.2, c == 1

Si vous voulez récupérer la valeur par défaut d'un argument par réflexion, vous devez obtenir un objet ParameterInfo pour le paramètre, puis extraire la valeur par défaut à l'aide de la propriété ParameterInfo.DefaultValue. En l'absence de valeur par défaut, la propriété retourne Value.DBNull.

L'exemple suivant affiche les valeurs par défaut pour MyMethod dans la console.

MethodInfo m = t.GetMethod("MyMethod");
ParameterInfo[] ps = m.GetParameters();
for (int i = 0; i < ps.Length; i++) 
{
    Console.WriteLine("Default Value == {0}", ps[i].DefaultValue);
}

Pour appeler des méthodes dont les arguments possèdent des valeurs par défaut, utilisez Type.Missing en tant que valeur de paramètre de la méthode InvokeMember. Cela permet au service de liaison tardive d'utiliser la valeur par défaut du paramètre indiqué. Si Type.Missing est passé pour un paramètre qui ne possède pas de valeur par défaut, ArgumentException est levé. Il est important de noter que les mécanismes de liaison de certains compilateurs ne respectent pas toujours ces règles pour Type.Missing. Certains binders peuvent ne pas prendre en charge ces fonctionnalités ou traiter Type.Missing différemment. Lors de l'utilisation de Type.Missing, les valeurs par défaut n'ont pas besoin d'être placées en position finale.

Le langage C# ne prend pas en charge les arguments par défaut.

L'exemple Visual Basic 2005 suivant montre comment utiliser la réflexion pour appeler des méthodes qui possèdent des arguments par défaut.

Option Strict Off
Imports System
Imports System.Reflection
Public Class OptionalArg
    Public Sub MyMethod (a As Integer, Optional b As Double = 1.2, Optional c As Integer=1)
        Console.WriteLine("a = " & a & " b = " & b & " c = " & c)
    End Sub
End Class
Module Module1
    Sub Main()
        Dim o As New OptionalArg
        Dim t As Type
        t = GetType(OptionalArg)
        Dim Param As Object()= {10, 20, 30}
        t.InvokeMember("MyMethod", _
                        BindingFlags.Public Or _
                        BindingFlags.Instance Or _
                        BindingFlags.InvokeMethod Or _
                        BindingFlags.OptionalParamBinding, _
                        Nothing, _
                        o, _
                        New Object() {10, 55.3, 12})
        t.InvokeMember("MyMethod", _
                        BindingFlags.Public Or _
                        BindingFlags.Instance Or _
                        BindingFlags.InvokeMethod Or _
                        BindingFlags.OptionalParamBinding, _
                        Nothing, _
                        o, _
                        New Object() {10, 1.3, Type.Missing})
        t.InvokeMember("MyMethod", _
                        BindingFlags.Public Or _
                        BindingFlags.Instance Or _
                        BindingFlags.InvokeMethod Or _
                        BindingFlags.OptionalParamBinding, _
                        Nothing, _
                        o, _
                        New Object() {10, Type.Missing, Type.Missing})
    End Sub
End Module

Lors de l'utilisation de la technique précédente, les arguments par défaut finaux sont pris en compte même lorsque l'appelant ne spécifie aucune valeur. Il s'agit du procédé le plus courant pour appeler des méthodes possédant des arguments par défaut.

Si vous utilisez MethodBase.Invoke pour appeler la méthode, vous devez spécifier explicitement les arguments par défaut en passant un tableau d'objets qui contient Type.Missing pour tous les paramètres qui ne possèdent pas de valeurs.

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft