ParamArrayAttribute Classe

Définition

Indique qu’une méthode autorisera un nombre variable d’arguments dans son appel.Indicates that a method will allow a variable number of arguments in its invocation. Cette classe ne peut pas être héritée.This class cannot be inherited.

public ref class ParamArrayAttribute sealed : Attribute
[System.AttributeUsage(System.AttributeTargets.Parameter, AllowMultiple=false, Inherited=true)]
public sealed class ParamArrayAttribute : Attribute
[System.AttributeUsage(System.AttributeTargets.Parameter, AllowMultiple=false, Inherited=true)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ParamArrayAttribute : Attribute
type ParamArrayAttribute = class
    inherit Attribute
Public NotInheritable Class ParamArrayAttribute
Inherits Attribute
Héritage
ParamArrayAttribute
Attributs

Exemples

L’exemple suivant définit une classe Temperature qui comprend une méthode Display, qui est destinée à afficher une ou plusieurs valeurs de température mises en forme.The following example defines a Temperature class that includes a Display method, which is intended to display one or more formatted temperature values. La méthode a un seul paramètre, formats, qui est défini en tant que tableau de paramètres.The method has a single parameter, formats, which is defined as a parameter array.

using System;

public class Temperature
{
   private decimal temp;

   public Temperature(decimal temperature)
   {
      this.temp = temperature;
   }

   public override string ToString()
   {
      return ToString("C");
   }

   public string ToString(string format)
   {
      if (String.IsNullOrEmpty(format))
         format = "G";

      switch (format.ToUpper())
      {
         case "G":
         case "C":
            return temp.ToString("N") + "  °C";
         case "F":
            return (9 * temp / 5 + 32).ToString("N") + "  °F";
         case "K":
            return (temp + 273.15m).ToString("N") + "  °K";
         default:
            throw new FormatException(String.Format("The '{0}' format specifier is not supported",
                                                    format));
      }
   }

   public void Display(params string []formats)
   {
      if (formats.Length == 0)
      {
         Console.WriteLine(this.ToString("G"));
      }
      else
      {
         foreach (string format in formats)
         {
            try {
               Console.WriteLine(this.ToString(format));
            }
            // If there is an exception, do nothing.
            catch { }
         }
      }
   }
}
Public Class Temperature 
   Private temp As Decimal
   
   Public Sub New(temperature As Decimal)
      Me.temp = temperature
   End Sub
   
   Public Overrides Function ToString() As String
      Return ToString("C")
   End Function
   
   Public Overloads Function ToString(format As String) As String
      If String.IsNullOrEmpty(format) Then format = "G"
      
      Select Case format
         Case "G", "C"
            Return temp.ToString("N") + "  °C"
         Case "F"
            Return (9 * temp / 5 + 32).ToString("N") + "  °F"
         Case "K" 
            Return (temp + 273.15d).ToString("N") + "  °K" 
         Case Else
            Throw New FormatException(String.Format("The '{0}' format specifier is not supported", _
                                                    format))
      End Select                                                         
   End Function         
   
   Public Sub Display(<[ParamArray]()> formats() As String)
      If formats.Length = 0 Then
         Console.WriteLine(Me.ToString("G"))
      Else   
         For Each format As String In formats
            Try
               Console.WriteLine(Me.ToString(format))
            ' If there is an exception, do nothing.
            Catch
            End Try   
         Next
      End If
   End Sub
End Class

L’exemple suivant illustre trois appels différents à la méthode Temperature.Display.The following example illustrates three different calls to the Temperature.Display method. Dans le premier, la méthode reçoit un tableau de chaînes de format.In the first, the method is passed an array of format strings. Dans le deuxième cas, la méthode reçoit quatre chaînes de format individuelles comme arguments.In the second, the method is passed four individual format strings as arguments. Dans le troisième, la méthode est appelée sans argument.In the third, the method is called with no arguments. Comme l’illustre la sortie de l’exemple, les Visual Basic et C# les compilateurs traduisent cela en un appel à la méthode Display avec un tableau de chaînes vide.As the output from the example illustrates, the Visual Basic and C# compilers translate this into a call to the Display method with an empty string array.

public class Class1
{
   public static void Main()
   {
      Temperature temp1 = new Temperature(100);
      string[] formats = { "C", "G", "F", "K" };

      // Call Display method with a string array.
      Console.WriteLine("Calling Display with a string array:");
      temp1.Display(formats);
      Console.WriteLine();

      // Call Display method with individual string arguments.
      Console.WriteLine("Calling Display with individual arguments:");
      temp1.Display("C", "F", "K", "G");
      Console.WriteLine();

      // Call parameterless Display method.
      Console.WriteLine("Calling Display with an implicit parameter array:");
      temp1.Display();
   }
}
// The example displays the following output:
//       Calling Display with a string array:
//       100.00  °C
//       100.00  °C
//       212.00  °F
//       373.15  °K
//
//       Calling Display with individual arguments:
//       100.00  °C
//       212.00  °F
//       373.15  °K
//       100.00  °C
//
//       Calling Display with an implicit parameter array:
//       100.00  °C
Public Module Example
   Public Sub Main()
      Dim temp1 As New Temperature(100)
      Dim formats() As String = { "C", "G", "F", "K" } 

      ' Call Display method with a string array.
      Console.WriteLine("Calling Display with a string array:")
      temp1.Display(formats)
      Console.WriteLine()
      
      ' Call Display method with individual string arguments.
      Console.WriteLine("Calling Display with individual arguments:")
      temp1.Display("C", "F", "K", "G")
      Console.WriteLine()
      
      ' Call parameterless Display method.
      Console.WriteLine("Calling Display with an implicit parameter array:")
      temp1.Display()
   End Sub
End Module
' The example displays the following output:
'       Calling Display with a string array:
'       100.00  °C
'       100.00  °C
'       212.00  °F
'       373.15  °K
'       
'       Calling Display with individual arguments:
'       100.00  °C
'       212.00  °F
'       373.15  °K
'       100.00  °C
'       
'       Calling Display with an implicit parameter array:
'       100.00  °C

Remarques

Le ParamArrayAttribute indique qu’un paramètre de méthode est un tableau de paramètres.The ParamArrayAttribute indicates that a method parameter is a parameter array. Un tableau de paramètres autorise la spécification d’un nombre inconnu d’arguments.A parameter array allows the specification of an unknown number of arguments. Un tableau de paramètres doit être le dernier paramètre d’une liste de paramètres formels, et il doit s’agir d’un tableau à une seule dimension.A parameter array must be the last parameter in a formal parameter list, and it must be a single-dimension array. Quand la méthode est appelée, un tableau de paramètres permet de spécifier les arguments d’une méthode de deux manières :When the method is called, a parameter array permits arguments to a method to be specified in either of two ways:

  • En tant qu’expression unique d’un type qui est implicitement convertible en type de tableau de paramètres.As a single expression of a type that is implicitly convertible to the parameter array type. Le tableau de paramètres fonctionne comme un paramètre de valeur.The parameter array functions as a value parameter.

  • Comme zéro, un ou plusieurs arguments, où chaque argument est une expression d’un type qui est implicitement convertible en type de l’élément de tableau de paramètres.As zero or more arguments, where each argument is an expression of a type that is implicitly convertible to the type of the parameter array element.

L’exemple de la section suivante illustre les deux conventions d’appel.The example in the next section illustrates both calling conventions.

Notes

En règle générale, le ParamArrayAttribute n’est pas utilisé directement dans le code.Typically, the ParamArrayAttribute is not used directly in code. Au lieu de cela, les mots clés de langage individuels, tels que C#ParamArray dans Visual Basic et params dans, sont utilisés comme wrappers pour la classe ParamArrayAttribute.Instead, individual language keywords, such as ParamArray in Visual Basic and params in C#, are used as wrappers for the ParamArrayAttribute class. Certains langages, tels C#que, peuvent même exiger l’utilisation du mot clé de langage et interdire l’utilisation de ParamArrayAttribute.Some languages, such as C#, may even require the use of the language keyword and prohibit the use of ParamArrayAttribute.

Pendant la résolution de la surcharge, lorsque les compilateurs qui prennent en charge des tableaux de paramètres rencontrent une surcharge de méthode qui n’existe pas mais possède un paramètre moins important qu’une surcharge qui inclut un tableau de paramètres, ils remplacent la méthode par la surcharge qui inclut le tableau de paramètres.During overload resolution, when compilers that support parameter arrays encounter a method overload that does not exist but has one fewer parameter than an overload that includes a parameter array, they will replace the method with the overload that includes the parameter array. Par exemple, un appel à la méthode d’instance String.Split() (qui n’existe pas dans la classe String) est résolu comme un appel à la méthode String.Split(Char[]).For example, a call to the String.Split() instance method (which does not exist in the String class) is resolved as a call to the String.Split(Char[]) method. Le compilateur passera également un tableau vide du type requis à la méthode.The compiler will also pass an empty array of the required type to the method. Cela signifie que la méthode doit toujours être préparée à gérer un tableau dont la longueur est égale à zéro lors du traitement des éléments dans le tableau de paramètres.This means that the method must always be prepared to handle an array whose length is zero when it processes the elements in the parameter array. Cet exemple en fournit une illustration.The example provides an illustration.

Pour plus d’informations sur l’utilisation d’attributs, consultez attributs.For more information about using attributes, see Attributes.

Constructeurs

ParamArrayAttribute()

Initialise une nouvelle instance de la classe ParamArrayAttribute avec des propriétés par défaut.Initializes a new instance of the ParamArrayAttribute class with default properties.

Propriétés

TypeId

Lors de l'implémentation dans une classe dérivée, obtient un identificateur unique pour l'objet Attribute.When implemented in a derived class, gets a unique identifier for this Attribute.

(Hérité de Attribute)

Méthodes

Equals(Object)

Retourne une valeur qui indique si cette instance est égale à un objet spécifié.Returns a value that indicates whether this instance is equal to a specified object.

(Hérité de Attribute)
GetHashCode()

Retourne le code de hachage de cette instance.Returns the hash code for this instance.

(Hérité de Attribute)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
IsDefaultAttribute()

En cas de substitution dans une classe dérivée, indique si la valeur de cette instance est la valeur par défaut pour la classe dérivée.When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class.

(Hérité de Attribute)
Match(Object)

En cas de substitution dans une classe dérivée, retourne une valeur indiquant si cette instance équivaut à un objet spécifié.When overridden in a derived class, returns a value that indicates whether this instance equals a specified object.

(Hérité de Attribute)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)

Implémentations d’interfaces explicites

_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Hérité de Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Récupère les informations de type pour un objet, qui peuvent être utilisées pour obtenir les informations de type d'une interface.Retrieves the type information for an object, which can be used to get the type information for an interface.

(Hérité de Attribute)
_Attribute.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Hérité de Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.Provides access to properties and methods exposed by an object.

(Hérité de Attribute)

S’applique à

Voir aussi