Membres avec un nombre variable de paramètres

Article
08/21/2008

Mise à jour : novembre 2007

Les tableaux sont utilisés pour passer un nombre variable de paramètres à un membre. Certains langages, tels que C#, fournissent un mot clé qui décore un tableau utilisé pour passer des arguments variables. Pour les langages qui ne fournissent pas de mot clé, c'est l'attribut ParamArrayAttribute qui fournit ces fonctionnalités. Le mot clé et l'attribut affectent le dernier paramètre dans la signature d'un membre. Ce paramètre doit être un tableau à une seule dimension

L'exemple de code suivant illustre la définition et l'appel à une méthode qui prend un nombre variable de paramètres. Notez que, dans la méthode DemonstrateVariableParameters, les arguments ne sont pas placés dans un tableau avant d'appeler UseVariableParameters.

Public Shared Sub UseVariableParameters(ParamArray list() as  Integer) 
     For  i as Integer = 0  to list.Length -1 
        Console.WriteLine(list(i))
     Next i 
     Console.WriteLine()
End Sub

Public Shared Sub DemonstrateVariableParameters()

    Manager.UseVariableParameters(1,2,3,4,5)
End Sub

public static void UseVariableParameters(params int[] list) 
{
     for ( int i = 0 ; i < list.Length ; i++ )
     {
        Console.WriteLine(list[i]);
     }
     Console.WriteLine();
}

public static void DemonstrateVariableParameters()
{
    Manager.UseVariableParameters(1,2,3,4,5);
}

Les instructions suivantes peuvent vous aider à déterminer quand il convient d'utiliser des tableaux de variables en tant que paramètres.

Envisagez d'ajouter le mot clé params aux paramètres de tableau si vous pensez que les utilisateurs finaux passeront un petit nombre d'éléments.

Si le développeur passe de nombreux éléments dans des scénarios classiques, le mot clé params est sans doute moins utile dans la mesure où il est peu probable que le développeur passe un nombre important d'objets inline.

N'utilisez pas de tableaux params s'il existe de fortes probabilités que l'appelant ait placé les entrées dans un tableau.

Par exemple, les données de type Byte sont généralement stockées et manipulées dans des tableaux d'octets. L'ajout du mot clé params à un paramètre de tableau d'octets est peu répandu dans la plupart des scénarios classiques car, en général, les développeurs ne manipulent pas des octets individuels si ceux-ci n'ont pas encore été stockés dans un tableau d'octets.

N'utilisez pas de tableaux params si le tableau est modifié par le membre prenant le paramètre de tableau params.

Il est possible que le Common Language runtime (CLR) ait créé un objet tableau temporaire. Si la méthode modifie un tableau temporaire, les changements ne sont pas disponibles à l'appelant.

Envisagez d'utiliser le mot clé params dans une surcharge simple, même si une surcharge plus complexe ne peut pas l'utiliser.

Il est possible que les développeurs trouvent certains avantages à avoir le tableau params dans une seule surcharge, même s'il ne l'est pas dans toutes.

Essayez de classer les paramètres de telle sorte qu'il soit possible d'utiliser le mot clé params.

En d'autres termes, chaque fois que c'est possible, un paramètre de tableau doit être le dernier paramètre spécifié. L'exemple de code suivant illustre un classement de paramètres incorrect.

Overloads Public Function Add (i as Integer,j as Integer, numberBase as Int16) _
    as Integer

public int Add (int i,int j, short numberBase)

Overloads Public Function Add (i as Integer, j as Integer, k as Integer, _
    numberBase as int16) as Integer

public int Add (int i, int j, int k, short numberBase)

' Can't use params array.
Overloads Public Function Add (numbers() as Integer, numberBase as Int16) _
    as Integer

// Can't use params array.
public int Add (int [] numbers, short numberBase)

Les paramètres doivent être réorganisés comme suit :

Overloads Public Function Add (numberBase as Int16, i as Integer,j as Integer) _
    as Integer

public int Add (short numberBase, int i,int j)

Overloads Public Function Add (numberBase as Int16, i as Integer, _
    j as Integer, k as Integer) as Integer

public int Add (short numberBase, int i, int j, int k)

' Can use params array.
Overloads Public Function Add (numberBase as Int16, _
    ParamArray numbers() as Integer) as Integer

// Can use params array.
public int Add (short numberBase, params int [] numbers)

Envisagez de fournir des surcharges et des chemins de code spéciaux pour les appels comportant un petit nombre d'arguments dans les API très dépendantes des performances.

En respectant cette instruction, vous évitez de créer des tableaux lorsqu'un membre est appelé avec un petit nombre d'arguments. Les noms des paramètres doivent représenter la forme au singulier du paramètre de tableau, suivie d'un suffixe numérique. L'exemple de code suivant illustre une signature de membre conforme à cette instruction.

Public Shared Sub WriteLine( _
     format as String,  _
     arg0 as Object, _
     arg1 as Object, _
     arg2 as Object _
)

public static void WriteLine(
    string format, 
    object arg0, 
    object arg1, 
    object arg2
)

Sachez que la valeur null (Nothing en Visual Basic) peut être passée comme argument du tableau params.

Votre membre doit vérifier la présence d'un tableau null avant de le traiter.

N'utilisez pas de méthodes varargs (points de suspension).

Dans la mesure où la convention d'appel à varargs n'est pas conforme CLS, elle ne doit pas être utilisée dans les membres publics. Elle peut être utilisée en interne.

Pour plus d'informations sur les instructions de conception, consultez le livre « Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries » de Krzysztof Cwalina et Brad Abrams, publié par Addison-Wesley, 2005.

Voir aussi

Concepts

Conception de paramètres

Autres ressources

Instructions de conception des membres

Instructions de conception pour le développement de bibliothèques de classes

Partager via