ParamArrayAttribute Klasse

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
ParamArrayAttribute
Attribute

Beispiele

Im folgenden Beispiel wird eine Temperature -Klasse definiert, Display die eine-Methode enthält, die einen oder mehrere formatierte Temperaturwerte anzeigen soll.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 formatsParameter,, der als Parameter Array 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

Im folgenden Beispiel werden drei verschiedene Aufrufe der Temperature.Display -Methode veranschaulicht.The following example illustrates three different calls to the Temperature.Display method. Im ersten wird der-Methode ein Array von Format Zeichenfolgen übermittelt.In the first, the method is passed an array of format strings. In der zweiten wird der Methode vier einzelne Format Zeichenfolgen als Argumente übermittelt.In the second, the method is passed four individual format strings as arguments. Im dritten wird die-Methode ohne Argumente aufgerufen.In the third, the method is called with no arguments. Wie die Ausgabe des Beispiels veranschaulicht, übersetzen die Visual Basic C# und Compiler dies in einen Display aufrufungsmethode mit einem leeren Zeichen folgen Array.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

Der ParamArrayAttribute gibt an, dass ein Methoden Parameter ein Parameter Array ist.The ParamArrayAttribute indicates that a method parameter is a parameter array. Ein Parameter Array ermöglicht die Angabe einer unbekannten Anzahl von Argumenten.A parameter array allows the specification of an unknown number of arguments. Ein Parameter Array muss der letzte Parameter in einer formalen 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 Parameter Array das Angeben von Argumenten für eine Methode auf zwei Arten:When the method is called, a parameter array permits arguments to a method to be specified in either of two ways:

  • Als einzelner Ausdruck eines Typs, der implizit in den Typ des Parameter Arrays konvertiert werden kann.As a single expression of a type that is implicitly convertible to the parameter array type. Das Parameter Array fungiert als value-Parameter.The parameter array functions as a value parameter.

  • Als 0 (null) oder mehrere Argumente, wobei jedes Argument ein Ausdruck eines Typs ist, der implizit in den Typ des Parameter Array Elements konvertiert werden kann.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.

Das Beispiel im nächsten Abschnitt veranschaulicht beide Aufruf Konventionen.The example in the next section illustrates both calling conventions.

Hinweis

In der Regel ParamArrayAttribute wird das nicht direkt im Code verwendet.Typically, the ParamArrayAttribute is not used directly in code. Stattdessen werden einzelne sprach Schlüsselwörter, ParamArray wie z. b C#. in Visual Basic und in, als Wrapper ParamArrayAttribute für die- params Klasse verwendet.Instead, individual language keywords, such as ParamArray in Visual Basic and params in C#, are used as wrappers for the ParamArrayAttribute class. Für einige Sprachen, z C#. b., ist möglicherweise sogar die Verwendung des Language-Schlüssel Worts ParamArrayAttributeerforderlich, und die Verwendung von wird untersagt.Some languages, such as C#, may even require the use of the language keyword and prohibit the use of ParamArrayAttribute.

Wenn bei der Überladungs Auflösung Compiler, die Parameter Arrays unterstützen, auf eine nicht vorhandene Methoden Überladung stoßen, aber einen geringeren Parameter als eine Überladung haben, die ein Parameter Array enthält, ersetzen Sie die-Methode durch die-Überladung, die Folgendes enthält: Parameter Array.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. Beispielsweise wird ein Aufrufe String.Split() der-Instanzmethode (die nicht in der String -Klasse vorhanden ist) als ein Aufrufder String.Split(Char[]) -Methode aufgelöst.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 übergibt auch ein leeres Array des erforderlichen Typs an die-Methode.The compiler will also pass an empty array of the required type to the method. Dies bedeutet, dass die Methode immer darauf vorbereitet sein muss, ein Array zu verarbeiten, dessen Länge 0 (null) ist, wenn die Elemente im Parameter Array verarbeitet werden.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()

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

Eigenschaften

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.

(Geerbt von Attribute)

Methoden

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.

(Geerbt von Attribute)
GetHashCode()

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

(Geerbt von Attribute)
GetType()

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

(Geerbt von Object)
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.

(Geerbt von Attribute)
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.

(Geerbt von Attribute)
MemberwiseClone()

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

(Geerbt von Object)
ToString()

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

(Geerbt von Object)

Explizite Schnittstellenimplementierungen

_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.

(Geerbt von Attribute)
_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.

(Geerbt von Attribute)
_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).

(Geerbt von Attribute)
_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.

(Geerbt von Attribute)

Gilt für:

Siehe auch