ParamArrayAttribute Classe

Définition

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

[<System.AttributeUsage(System.AttributeTargets.Parameter, AllowMultiple=false, Inherited=true)>]
type ParamArrayAttribute = class
    inherit Attribute

[<System.AttributeUsage(System.AttributeTargets.Parameter, AllowMultiple=false, Inherited=true)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ParamArrayAttribute = class
    inherit Attribute

Public NotInheritable Class ParamArrayAttribute
Inherits Attribute

Héritage

Object

Attribute

ParamArrayAttribute

Attributs

AttributeUsageAttribute ComVisibleAttribute

Exemples

L’exemple suivant définit une Temperature classe qui inclut une Display méthode, destinée à afficher une ou plusieurs valeurs de température mises en forme. La méthode a un paramètre unique, formatsqui est défini en tant que tableau de paramètres.

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 { }
         }
      }
   }
}

open System

type Temperature(temperature) =
    override this.ToString() =
        this.ToString "C"

    member _.ToString(format) =
        let format = 
            if String.IsNullOrEmpty format then "G"
            else format

        match format.ToUpper() with
        | "G" | "C" ->
            $"{temperature:N}  °C"
        | "F" ->
            $"{9. * temperature / 5. + 32.:N}  °F"
        | "K" ->
            $"{temperature + 273.15:N}  °K"
        | _ ->
            raise (FormatException $"The '{format}' format specifier is not supported")

    member this.Display([<ParamArray>]formats: string[]) =
        if formats.Length = 0 then
            printfn $"""{this.ToString "G"}"""
        else
            for format in formats do
                try
                    printfn $"{this.ToString format}"
                // If there is an exception, do nothing.
                with _ -> ()

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 Temperature.Display méthode. Dans le premier, la méthode est passée à un tableau de chaînes de format. Dans la deuxième, la méthode est passée à quatre chaînes de format individuelles en tant qu’arguments. Dans le troisième, la méthode est appelée sans arguments. Comme le montre la sortie de l’exemple, les compilateurs Visual Basic et C# le traduisent en un appel à la Display méthode avec un tableau de chaînes vide.

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

let temp1 = Temperature 100.
let formats = [| "C"; "G"; "F"; "K" |]

// Call Display method with a string array.
printfn "Calling Display with a string array:"
temp1.Display formats

// Call Display method with individual string arguments.
printfn "\nCalling Display with individual arguments:"
temp1.Display("C", "F", "K", "G")

// Call parameterless Display method.
printfn "\nCalling 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

Indique ParamArrayAttribute qu’un paramètre de méthode est un tableau de paramètres. Un tableau de paramètres permet la spécification d’un nombre inconnu d’arguments. Un tableau de paramètres doit être le dernier paramètre d’une liste de paramètres formel et doit être un tableau à dimension unique. Lorsque la méthode est appelée, un tableau de paramètres autorise les arguments à une méthode à spécifier de deux façons :

• En tant qu’expression unique d’un type implicitement convertible en type de tableau de paramètres. Le tableau de paramètres fonctionne comme paramètre de valeur.

• Comme zéro ou plusieurs arguments, où chaque argument est une expression d’un type implicitement convertible en type de l’élément de tableau de paramètres.

L’exemple de la section suivante illustre les deux conventions d’appel.

Pendant la résolution de surcharge, lorsque les compilateurs qui prennent en charge les tableaux de paramètres rencontrent une surcharge de méthode qui n’existe pas, mais possède un paramètre inférieur à une surcharge qui inclut un tableau de paramètres, ils remplacent la méthode par la surcharge qui inclut le tableau de paramètres. Par exemple, un appel à la String.Split() méthode d’instance (qui n’existe pas dans la String classe) est résolu en tant qu’appel à la String.Split(Char[]) méthode. Le compilateur transmet également un tableau vide du type requis à la méthode. Cela signifie que la méthode doit toujours être préparée pour gérer un tableau dont la longueur est égale à zéro lorsqu’elle traite les éléments du tableau de paramètres. Cet exemple en fournit une illustration.

Pour plus d’informations sur l’utilisation d’attributs, consultez Attributs.

Constructeurs

Propriétés

Méthodes

Implémentations d’interfaces explicites

S’applique à

Voir aussi

• Attribute
• Extension des métadonnées à l'aide des attributs