ParamArrayAttribute ParamArrayAttribute ParamArrayAttribute ParamArrayAttribute Class

Definition

Gibt an, dass eine Methode mit einer variablen Anzahl von Argumenten aufgerufen werden kann.Indicates that a method will allow a variable number of arguments in its invocation. Diese Klasse kann nicht vererbt werden.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
Vererbung
ParamArrayAttributeParamArrayAttributeParamArrayAttributeParamArrayAttribute
Attribute

Beispiele

Das folgende Beispiel definiert eine Temperature -Klasse, enthält eine Display -Methode, die vorgesehen ist, um eine oder mehrere formatierte Temperaturwerte anzuzeigen.The following example defines a Temperature class that includes a Display method, which is intended to display one or more formatted temperature values. Die Methode verfügt über einen einzelnen Parameter, formats, die als ein Parameterarray definiert ist.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

Das folgende Beispiel zeigt drei unterschiedliche Aufrufe der Temperature.Display Methode.The following example illustrates three different calls to the Temperature.Display method. Im ersten wird die Methode ein Array von Zeichenfolgen im Format übergeben.In the first, the method is passed an array of format strings. Im zweiten Fall wird die Methode, vier einzelne Formatzeichenfolgen als Argumente übergeben.In the second, the method is passed four individual format strings as arguments. Im dritten wird die-Methode ohne Argumente aufgerufen werden.In the third, the method is called with no arguments. Wie die Ausgabe im Beispiel wird veranschaulicht, die Visual Basic- und C#-Compiler übersetzt in einen Aufruf der Display Methode ein leeres Zeichenfolgenarray.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

Hinweise

Die ParamArrayAttribute gibt an, dass ein Methodenparameter ein Parameterarray ist.The ParamArrayAttribute indicates that a method parameter is a parameter array. Ein Parameterarray ermöglicht die Angabe eine unbekannte Anzahl von Argumenten.A parameter array allows the specification of an unknown number of arguments. Ein Parameterarray muss der letzte Parameter in einer formellen Parameterliste sein, und es muss ein eindimensionales Array sein.A parameter array must be the last parameter in a formal parameter list, and it must be a single-dimension array. Wenn die Methode aufgerufen wird, ermöglicht ein Parameterarray Argumente an eine Methode in eine von zwei Arten angegeben werden:When the method is called, a parameter array permits arguments to a method to be specified in either of two ways:

  • Als ein einziger Ausdruck eines Typs, der implizit in den Parameter-Arraytyp ist.As a single expression of a type that is implicitly convertible to the parameter array type. Das Parameterarray fungiert als ein Value-Parameter.The parameter array functions as a value parameter.

  • Als 0 (null) oder mehrere Argumente, in dem jedes Argument einen Ausdruck eines Typs ist, der implizit in den Typ von Array Parameter-Element ist.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.

Im Beispiel im nächsten Abschnitt werden beide Aufrufkonventionen veranschaulicht.The example in the next section illustrates both calling conventions.

Hinweis

In der Regel die ParamArrayAttribute nicht direkt in Code verwendet wird.Typically, the ParamArrayAttribute is not used directly in code. Stattdessen Schlüsselwörter, wie z. B. ParamArray in Visual Basic und params in C# geschrieben, dienen als Wrapper für die ParamArrayAttribute Klasse.Instead, individual language keywords, such as ParamArray in Visual Basic and params in C#, are used as wrappers for the ParamArrayAttribute class. Bei einigen Sprachen wie C#, möglicherweise sogar erfordern die Verwendung von dem Programmiersprachen-Schlüsselwort und verbieten die Verwendung von ParamArrayAttribute.Some languages, such as C#, may even require the use of the language keyword and prohibit the use of ParamArrayAttribute.

Bei der überladungsauflösung, wenn Compiler, Parameterarrays unterstützen, eine methodenüberladung auftritt, das ist nicht vorhanden, aber verfügt über einen weniger Parameter als eine Überladung, die ein Parameterarray, enthält sie ersetzt die Methode durch die Überladung, die enthält die Parameterarray.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. Z. B. einen Aufruf der String.Split() Instanzmethode (nicht vorhandene der String Klasse) aufgelöst wird, wie ein Aufruf von der String.Split(Char[]) Methode.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. Der Compiler wird ein leeres Array des erforderlichen Typs auch an die Methode übergeben.The compiler will also pass an empty array of the required type to the method. Dies bedeutet, dass die Methode immer vorbereitet werden muss, um ein Array zu verarbeiten, deren Länge 0 (null) ist, bei der Verarbeitung der Elemente im Parameterarray.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. Dies wird im Beispiel veranschaulicht.The example provides an illustration.

Weitere Informationen zum Verwenden von Attributen finden Sie unter Attribute.For more information about using attributes, see Attributes.

Konstruktoren

ParamArrayAttribute() ParamArrayAttribute() ParamArrayAttribute() ParamArrayAttribute()

Initialisiert eine neue Instanz der ParamArrayAttribute-Klasse mit Standardeigenschaften.Initializes a new instance of the ParamArrayAttribute class with default properties.

Methoden

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.Returns a value that indicates whether this instance is equal to a specified object.

(Inherited from Attribute)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Gibt den Hashcode für diese Instanz zurück.Returns the hash code for this instance.

(Inherited from Attribute)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
IsDefaultAttribute() IsDefaultAttribute() IsDefaultAttribute() IsDefaultAttribute()

Gibt beim Überschreiben in einer abgeleiteten Klasse an, ob der Wert der Instanz der Standardwert für die abgeleitete Klasse ist.When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class.

(Inherited from Attribute)
Match(Object) Match(Object) Match(Object) Match(Object)

Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert zurückgegeben, der angibt, ob diese Instanz einem bestimmten Objekt entspricht.When overridden in a derived class, returns a value that indicates whether this instance equals a specified object.

(Inherited from Attribute)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)

Explizite Schnittstellenimplementierungen

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

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.Maps a set of names to a corresponding set of dispatch identifiers.

(Inherited from Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Ruft die Typinformationen für ein Objekt ab, mit deren Hilfe die Typinformationen für eine Schnittstelle abgerufen werden können.Retrieves the type information for an object, which can be used to get the type information for an interface.

(Inherited from Attribute)
_Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Inherited from Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.Provides access to properties and methods exposed by an object.

(Inherited from Attribute)

Eigenschaften

TypeId TypeId TypeId TypeId

Ruft bei Implementierung in einer abgeleiteten Klasse einen eindeutigen Bezeichner für dieses Attribute ab.When implemented in a derived class, gets a unique identifier for this Attribute.

(Inherited from Attribute)

Gilt für:

Siehe auch