ParamArrayAttribute Klasa

Definicja

Wskazuje, że metoda będzie zezwalać na zmienną liczbę argumentów w wywołaniu.Indicates that a method will allow a variable number of arguments in its invocation. Klasa ta nie może być dziedziczona.This class cannot be inherited.

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)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ParamArrayAttribute : Attribute
[<System.AttributeUsage(System.AttributeTargets.Parameter, AllowMultiple=false, Inherited=true)>]
type ParamArrayAttribute = class
    inherit Attribute
[<System.AttributeUsage(System.AttributeTargets.Parameter, AllowMultiple=false, Inherited=true)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ParamArrayAttribute = class
    inherit Attribute
Public NotInheritable Class ParamArrayAttribute
Inherits Attribute
Dziedziczenie
ParamArrayAttribute
Atrybuty

Przykłady

W poniższym przykładzie zdefiniowano Temperature klasę, która zawiera Display metodę, która jest przeznaczona do wyświetlania jednej lub więcej sformatowanych wartości temperatury.The following example defines a Temperature class that includes a Display method, which is intended to display one or more formatted temperature values. Metoda ma jeden parametr, formats który jest zdefiniowany jako tablica parametrów.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

Poniższy przykład ilustruje trzy różne wywołania Temperature.Display metody.The following example illustrates three different calls to the Temperature.Display method. W pierwszej metodzie jest przenoszona tablica ciągów formatu.In the first, the method is passed an array of format strings. W drugim Metoda jest przenoszona cztery poszczególne ciągi formatowania jako argumenty.In the second, the method is passed four individual format strings as arguments. W trzecim Metoda jest wywoływana bez argumentów.In the third, the method is called with no arguments. Jak przedstawiono dane wyjściowe z przykładu, kompilatory Visual Basic i C# tłumaczą ten element na wywołanie Display metody z pustą tablicą ciągów.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

Uwagi

ParamArrayAttributeWskazuje, że parametr metody jest tablicą parametrów.The ParamArrayAttribute indicates that a method parameter is a parameter array. Tablica parametrów umożliwia określenie nieznanej liczby argumentów.A parameter array allows the specification of an unknown number of arguments. Tablica parametrów musi być ostatnim parametrem na liście parametrów formalnych i musi być tablicą z jednym wymiarem.A parameter array must be the last parameter in a formal parameter list, and it must be a single-dimension array. Gdy metoda jest wywoływana, tablica parametrów zezwala na określenie argumentów metody na jeden z dwóch sposobów:When the method is called, a parameter array permits arguments to a method to be specified in either of two ways:

  • Jako pojedyncze wyrażenie typu, który jest niejawnie konwertowany do typu tablicy parametrów.As a single expression of a type that is implicitly convertible to the parameter array type. Tablica parametrów działa jako parametr wartości.The parameter array functions as a value parameter.

  • Jako zero lub więcej argumentów, gdzie każdy argument jest wyrażeniem typu, który jest niejawnie konwertowany na typ elementu tablicy parametrów.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.

W przykładzie w następnej sekcji przedstawiono obie konwencje wywoływania.The example in the next section illustrates both calling conventions.

Uwaga

Zazwyczaj ParamArrayAttribute nie jest używana bezpośrednio w kodzie.Typically, the ParamArrayAttribute is not used directly in code. Zamiast tego poszczególne słowa kluczowe języka, takie jak ParamArray w Visual Basic i params w języku C#, są używane jako otoki dla ParamArrayAttribute klasy.Instead, individual language keywords, such as ParamArray in Visual Basic and params in C#, are used as wrappers for the ParamArrayAttribute class. W niektórych językach, takich jak C#, może być nawet wymagane użycie słowa kluczowego language i Zabroń używania programu ParamArrayAttribute .Some languages, such as C#, may even require the use of the language keyword and prohibit the use of ParamArrayAttribute.

Podczas rozpoznawania przeciążenia, gdy kompilatory obsługujące tablice parametrów napotykają Przeciążenie metody, które nie istnieje, ale ma jeden mniej parametrów niż Przeciążenie zawierające tablicę parametrów, zastąpią metodę przeciążeniem, który zawiera tablicę parametrów.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. Na przykład wywołanie String.Split() metody wystąpienia (która nie istnieje w String klasie) jest rozpoznawane jako wywołanie String.Split(Char[]) metody.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. Kompilator przekaże także pustą tablicę wymaganego typu do metody.The compiler will also pass an empty array of the required type to the method. Oznacza to, że metoda musi zawsze być przygotowana do obsługi tablicy, której długość wynosi zero, gdy przetwarza elementy w tablicy parametrów.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. Przykład stanowi ilustrację.The example provides an illustration.

Aby uzyskać więcej informacji o korzystaniu z atrybutów, zobacz atrybuty.For more information about using attributes, see Attributes.

Konstruktory

ParamArrayAttribute()

Inicjuje nowe wystąpienie ParamArrayAttribute klasy z właściwościami domyślnymi.Initializes a new instance of the ParamArrayAttribute class with default properties.

Właściwości

TypeId

Po zaimplementowaniu w klasie pochodnej pobiera unikatowy identyfikator dla tego elementu Attribute .When implemented in a derived class, gets a unique identifier for this Attribute.

(Odziedziczone po Attribute)

Metody

Equals(Object)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.Returns a value that indicates whether this instance is equal to a specified object.

(Odziedziczone po Attribute)
GetHashCode()

Zwraca wartość skrótu dla tego wystąpienia.Returns the hash code for this instance.

(Odziedziczone po Attribute)
GetType()

Pobiera Type bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
IsDefaultAttribute()

Gdy jest zastępowany w klasie pochodnej, wskazuje, czy wartość tego wystąpienia jest wartością domyślną klasy pochodnej.When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class.

(Odziedziczone po Attribute)
Match(Object)

Gdy jest zastępowany w klasie pochodnej, zwraca wartość wskazującą, czy to wystąpienie jest zgodne z określonym obiektem.When overridden in a derived class, returns a value that indicates whether this instance equals a specified object.

(Odziedziczone po Attribute)
MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu Object .Creates a shallow copy of the current Object.

(Odziedziczone po Object)
ToString()

Zwraca ciąg reprezentujący bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)

Jawne implementacje interfejsu

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

Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania.Maps a set of names to a corresponding set of dispatch identifiers.

(Odziedziczone po Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Pobiera informacje o typie dla obiektu, którego można użyć do uzyskania informacji o typie dla interfejsu.Retrieves the type information for an object, which can be used to get the type information for an interface.

(Odziedziczone po Attribute)
_Attribute.GetTypeInfoCount(UInt32)

Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Odziedziczone po Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt.Provides access to properties and methods exposed by an object.

(Odziedziczone po Attribute)

Dotyczy

Zobacz też