ParamArrayAttribute Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Indique qu’une méthode autorisera un nombre variable d’arguments dans son appel. Cette classe ne peut pas être héritée.
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 AttributePublic NotInheritable Class ParamArrayAttribute
Inherits Attribute- Héritage
- Attributs
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.
Notes
En règle générale, il n’est pas utilisé directement dans le ParamArrayAttribute code. Au lieu de cela, des mots clés de langage individuels, tels que ParamArray dans Visual Basic et params en C#, sont utilisés comme wrappers pour la ParamArrayAttribute classe. Certaines langues, telles que C#, peuvent même nécessiter l’utilisation du mot clé de langue et interdire l’utilisation de ParamArrayAttribute.
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
| ParamArrayAttribute() |
Initialise une nouvelle instance de la classe ParamArrayAttribute avec des propriétés par défaut. |
Propriétés
| TypeId |
Lors de l'implémentation dans une classe dérivée, obtient un identificateur unique pour l'objet Attribute. (Hérité de Attribute) |
Méthodes
| Equals(Object) |
Retourne une valeur qui indique si cette instance est égale à un objet spécifié. (Hérité de Attribute) |
| GetHashCode() |
Retourne le code de hachage de cette instance. (Hérité de Attribute) |
| GetType() |
Obtient le Type de l'instance actuelle. (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. (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é. (Hérité de Attribute) |
| MemberwiseClone() |
Crée une copie superficielle du Object actuel. (Hérité de Object) |
| ToString() |
Retourne une chaîne qui représente l'objet actuel. (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. (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. (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). (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. (Hérité de Attribute) |