Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

ParamArrayAttribute-Klasse

 

Veröffentlicht: Oktober 2016

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

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.Attribute
    System.ParamArrayAttribute

[AttributeUsageAttribute(AttributeTargets.Parameter, Inherited = true, 
	AllowMultiple = false)]
[ComVisibleAttribute(true)]
public sealed class ParamArrayAttribute : Attribute

NameBeschreibung
System_CAPS_pubmethodParamArrayAttribute()

Initialisiert eine neue Instanz der ParamArrayAttribute-Klasse mit Standardeigenschaften.

NameBeschreibung
System_CAPS_pubpropertyTypeId

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

NameBeschreibung
System_CAPS_pubmethodEquals(Object)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.(Geerbt von „Attribute“.)

System_CAPS_pubmethodGetHashCode()

Gibt den Hashcode für diese Instanz zurück.(Geerbt von „Attribute“.)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodIsDefaultAttribute()

Gibt beim Überschreiben in einer abgeleiteten Klasse an, ob der Wert der Instanz der Standardwert für die abgeleitete Klasse ist.(Geerbt von „Attribute“.)

System_CAPS_pubmethodMatch(Object)

Ruft beim Überschreiben in einer abgeleiteten Klasse gibt einen Wert, der angibt, ob diese Instanz gleich ein angegebenen Objekt ist.(Geerbt von „Attribute“.)

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

NameBeschreibung
System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.(Geerbt von „Attribute“.)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).(Geerbt von „Attribute“.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.(Geerbt von „Attribute“.)

Die ParamArrayAttribute Gibt 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 formellen Parameterliste sein, und es muss ein eindimensionales Array sein. Wenn die Methode aufgerufen wird, kann ein Parameterarray die Argumente für eine Methode auf zwei Arten angegeben werden:

  • Als ein einziger Ausdruck eines Typs, der implizit in den Array-Parametertyp konvertiert werden. Das Parameterarray fungiert als ein Werteparameter.

  • Als 0 oder mehr Argumente, wobei jedes Argument ein Ausdruck eines Typs ist, der implizit in den Typ des Parameters Arrayelements konvertierbar ist.

Im Beispiel im nächsten Abschnitt werden beide Aufrufkonventionen veranschaulicht.

System_CAPS_noteHinweis

In der Regel die ParamArrayAttribute nicht direkt in Code verwendet wird. Stattdessen Schlüsselwörter, wie z. B. ParamArray in Visual Basic und params in c# wird als Wrapper für die ParamArrayAttribute Klasse. Einige Sprachen, z. B. c#, möglicherweise sogar erfordern die Verwendung des Schlüsselworts und verhindern die Verwendung von ParamArrayAttribute.

Während der Auflösung von funktionsüberladungen bei Compiler, Parameterarrays unterstützen, eine methodenüberladung, die nicht existiert, aber verfügt über einen weniger Parameter als eine Überladung, die ein Parameterarray enthält ersetzt sie die Methode mit der Überladung mit, die das Parameterarray enthält. Z. B. einen Aufruf der String.Split() Instanzmethode (nicht vorhandenen der String Klasse) aufgelöst wird, wie ein Aufruf der String.Split(Char[]) Methode. Der Compiler wird auch ein leeres Array des erforderlichen Typs an die Methode übergeben. Dies bedeutet, dass die Methode immer darauf vorbereitet sein muss, ein Array behandeln, dessen Länge 0 (null) ist, bei der Verarbeitung der Elemente im Parameterarray. Dies wird im Beispiel veranschaulicht.

Weitere Informationen zum Verwenden von Attributen finden Sie unter Erweitern von Metadaten mithilfe von Attributen.

Das folgende Beispiel definiert eine Temperature -Klasse, enthält eine Display -Methode, die eine oder mehrere formatierter Temperaturwerte anzeigen soll. Die Methode verfügt über einen einzelnen Parameter, formats, die als ein 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 { }
         }
      }
   }
}

Im folgende Beispiel werden drei unterschiedliche Aufrufe an die Temperature.Display Methode. In der ersten wird die Methode ein Array von Formatzeichenfolgen übergeben. Im zweiten Fall wird die Methode vier einzelne Formatzeichenfolgen als Argumente übergeben. Im dritten wird die Methode ohne Argumente aufgerufen werden. 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

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: