ParamArrayAttribute Classe

Definizione

Indica che un metodo consentirà di utilizzare un numero variabile di argomenti nella relativa chiamata.Indicates that a method will allow a variable number of arguments in its invocation. Questa classe non può essere ereditata.This class cannot be inherited.

public ref class ParamArrayAttribute sealed : 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
Ereditarietà
ParamArrayAttribute
Attributi

Esempi

Nell'esempio seguente viene definita Temperature una classe che include Display un metodo, progettato per visualizzare uno o più valori di temperatura formattati.The following example defines a Temperature class that includes a Display method, which is intended to display one or more formatted temperature values. Il metodo ha un solo parametro, formats, che è definito come una matrice di parametri.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

Nell'esempio seguente vengono illustrate tre diverse chiamate al Temperature.Display metodo.The following example illustrates three different calls to the Temperature.Display method. Nel primo, al metodo viene passata una matrice di stringhe di formato.In the first, the method is passed an array of format strings. Nel secondo, il metodo viene passato quattro singole stringhe di formato come argomenti.In the second, the method is passed four individual format strings as arguments. Nel terzo, il metodo viene chiamato senza argomenti.In the third, the method is called with no arguments. Come illustrato nell'output dell'esempio, il Visual Basic e C# i compilatori traducono questa operazione in una chiamata Display al metodo con una matrice di stringhe vuota.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

Commenti

Indica ParamArrayAttribute che un parametro del metodo è una matrice di parametri.The ParamArrayAttribute indicates that a method parameter is a parameter array. Una matrice di parametri consente la specifica di un numero sconosciuto di argomenti.A parameter array allows the specification of an unknown number of arguments. Una matrice di parametri deve essere l'ultimo parametro in un elenco di parametri formali e deve essere una matrice unidimensionale.A parameter array must be the last parameter in a formal parameter list, and it must be a single-dimension array. Quando viene chiamato il metodo, una matrice di parametri consente di specificare argomenti per un metodo in uno dei due modi seguenti:When the method is called, a parameter array permits arguments to a method to be specified in either of two ways:

  • Come singola espressione di un tipo convertibile in modo implicito nel tipo di matrice di parametri.As a single expression of a type that is implicitly convertible to the parameter array type. La matrice di parametri funge da parametro di valore.The parameter array functions as a value parameter.

  • Come zero o più argomenti, in cui ogni argomento è un'espressione di un tipo convertibile in modo implicito nel tipo dell'elemento della matrice di parametri.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.

Nell'esempio riportato nella sezione successiva vengono illustrate entrambe le convenzioni di chiamata.The example in the next section illustrates both calling conventions.

Nota

In genere, ParamArrayAttribute non viene usato direttamente nel codice.Typically, the ParamArrayAttribute is not used directly in code. Al contrario, le parole chiave del linguaggio ParamArray singolo, ad params esempio C#in Visual Basic e in, vengono usate come ParamArrayAttribute wrapper per la classe.Instead, individual language keywords, such as ParamArray in Visual Basic and params in C#, are used as wrappers for the ParamArrayAttribute class. Alcuni linguaggi, ad esempio C#, possono anche richiedere l'uso della parola chiave del linguaggio e proibire l' ParamArrayAttributeuso di.Some languages, such as C#, may even require the use of the language keyword and prohibit the use of ParamArrayAttribute.

Durante la risoluzione dell'overload, quando i compilatori che supportano le matrici di parametri incontrano un overload del metodo che non esiste ma con un parametro inferiore rispetto a un overload che include una matrice di parametri, sostituiranno il metodo con l'overload che include matrice di parametri.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. Ad esempio, una chiamata al metodo String.Split() di istanza (che non esiste String nella classe) viene risolta String.Split(Char[]) come una chiamata al metodo.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. Il compilatore passa anche una matrice vuota del tipo richiesto al metodo.The compiler will also pass an empty array of the required type to the method. Questo significa che il metodo deve essere sempre preparato per gestire una matrice la cui lunghezza è zero quando elabora gli elementi nella matrice di parametri.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. Nell'esempio viene illustrata una situazione di questo tipo.The example provides an illustration.

Per ulteriori informazioni sull'utilizzo degli attributi, vedere attributi.For more information about using attributes, see Attributes.

Costruttori

ParamArrayAttribute()

Inizializza una nuova istanza della classe ParamArrayAttribute con le proprietà predefinite.Initializes a new instance of the ParamArrayAttribute class with default properties.

Proprietà

TypeId

Quando è implementata in una classe derivata, ottiene un identificatore univoco della classe Attribute.When implemented in a derived class, gets a unique identifier for this Attribute.

(Ereditato da Attribute)

Metodi

Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.Returns a value that indicates whether this instance is equal to a specified object.

(Ereditato da Attribute)
GetHashCode()

Restituisce il codice hash per l'istanza.Returns the hash code for this instance.

(Ereditato da Attribute)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
IsDefaultAttribute()

In caso di override in una classe derivata, indica se il valore di questa istanza è il valore predefinito per la classe derivata.When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class.

(Ereditato da Attribute)
Match(Object)

Quando è sottoposto a override in una classe derivata, restituisce un valore che indica se questa istanza equivale a un oggetto specificato.When overridden in a derived class, returns a value that indicates whether this instance equals a specified object.

(Ereditato da Attribute)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Implementazioni dell'interfaccia esplicita

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

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Ereditato da Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto, che possono essere usate per ottenere informazioni sul tipo relative a un'interfaccia.Retrieves the type information for an object, which can be used to get the type information for an interface.

(Ereditato da Attribute)
_Attribute.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Ereditato da Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.Provides access to properties and methods exposed by an object.

(Ereditato da Attribute)

Si applica a

Vedi anche