ParamArrayAttribute Klasse

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Quelle:

ParamArrayAttribute.cs

Gibt an, dass eine Methode mit einer variablen Anzahl von Argumenten aufgerufen werden kann. Diese Klasse kann nicht vererbt werden.

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)>]
type ParamArrayAttribute = class
    inherit Attribute

Public NotInheritable Class ParamArrayAttribute
Inherits Attribute

Vererbung

Object

Attribute

ParamArrayAttribute

Attribute

AttributeUsageAttribute

Beispiele

Im folgenden Beispiel wird eine Temperature Klasse definiert, die eine Display -Methode enthält, die einen oder mehrere formatierte Temperaturwerte anzeigen soll. Die -Methode verfügt über einen einzelnen Parameter, formats, der als Parameterarray definiert ist.

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

Im folgenden Beispiel werden drei verschiedene Aufrufe der Temperature.Display -Methode veranschaulicht. In der ersten wird der -Methode ein Array von Formatzeichenfolgen übergeben. In der zweiten werden der -Methode vier einzelne Formatzeichenfolgen als Argumente übergeben. Im dritten wird die -Methode ohne Argumente aufgerufen. Wie die Ausgabe des Beispiels veranschaulicht, übersetzen die Visual Basic- und C#-Compiler dies in einen Aufruf der Display -Methode mit einem leeren Zeichenfolgenarray.

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

Hinweise

Gibt ParamArrayAttribute an, dass ein Methodenparameter ein Parameterarray ist. Ein Parameterarray ermöglicht die Angabe einer unbekannten Anzahl von Argumenten. Ein Parameterarray muss der letzte Parameter in einer formalen Parameterliste und ein Eindimensionsarray sein. Wenn die -Methode aufgerufen wird, lässt ein Parameterarray zu, dass Argumente für eine Methode auf zwei Arten angegeben werden:

• Als einzelner Ausdruck eines Typs, der implizit in den Parameterarraytyp konvertiert werden kann. Das Parameterarray fungiert als Wertparameter.

• Als null oder mehr Argumente, wobei jedes Argument ein Ausdruck eines Typs ist, der implizit in den Typ des Parameterarrayelements konvertiert wird.

Das Beispiel im nächsten Abschnitt veranschaulicht beide Aufrufkonventionen.

Hinweis

In der Regel wird der ParamArrayAttribute nicht direkt im Code verwendet. Stattdessen werden einzelne Sprachschlüsselwörter, z ParamArray . B. in Visual Basic und params in C#, als Wrapper für die ParamArrayAttribute Klasse verwendet. Einige Sprachen, z. B. C#, erfordern möglicherweise sogar die Verwendung des Language-Schlüsselworts und verbieten die Verwendung von ParamArrayAttribute.

Wenn Compiler, die Parameterarrays unterstützen, während der Überladung auf eine Methodenüberladung stoßen, die nicht vorhanden ist, aber einen Parameter weniger aufweist als eine Überladung, die ein Parameterarray enthält, ersetzen sie die -Methode durch die -Überladung, die das Parameterarray enthält. Beispielsweise wird ein Aufruf der String.Split() Instanzmethode (die in der String -Klasse nicht vorhanden ist) als Aufruf der String.Split(Char[]) -Methode aufgelöst. Der Compiler übergibt auch ein leeres Array des erforderlichen Typs an die -Methode. Dies bedeutet, dass die -Methode immer bereit sein muss, ein Array zu verarbeiten, dessen Länge null ist, wenn sie die Elemente im Parameterarray verarbeitet. Dies wird im Beispiel veranschaulicht.

Weitere Informationen zur Verwendung von Attributen finden Sie unter Attribute.

Konstruktoren

ParamArrayAttribute()

Initialisiert eine neue Instanz der ParamArrayAttribute-Klasse mit Standardeigenschaften.

Eigenschaften

TypeId

Ruft bei Implementierung in einer abgeleiteten Klasse einen eindeutigen Bezeichner für dieses Attribute ab. (Geerbt von Attribute)

Methoden

Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist. (Geerbt von Attribute)
GetHashCode()	Gibt den Hashcode für diese Instanz zurück. (Geerbt von Attribute)
GetType()	Ruft den Type der aktuellen Instanz ab. (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. (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. (Geerbt von Attribute)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Weitere Informationen

• Attribute
• Erweitern von Metadaten mithilfe von Attributen