ParamArrayAttribute ParamArrayAttribute ParamArrayAttribute ParamArrayAttribute Class

Definición

Indica que un método va a permitir un número variable de argumentos cuando se invoque.Indicates that a method will allow a variable number of arguments in its invocation. Esta clase no puede heredarse.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
Herencia
ParamArrayAttributeParamArrayAttributeParamArrayAttributeParamArrayAttribute
Atributos

Ejemplos

En el ejemplo siguiente se define un Temperature clase que incluya un Display método, que está pensada para mostrar uno o más valores de temperatura con formato.The following example defines a Temperature class that includes a Display method, which is intended to display one or more formatted temperature values. El método tiene un único parámetro, formats, que se define como una matriz de parámetros.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

En el ejemplo siguiente se muestra tres llamadas diferentes a los Temperature.Display método.The following example illustrates three different calls to the Temperature.Display method. En la primera, el método se pasa una matriz de cadenas de formato.In the first, the method is passed an array of format strings. En el segundo, se pasa al método cuatro cadenas de formato individuales como argumentos.In the second, the method is passed four individual format strings as arguments. En la tercera, se llama al método sin argumentos.In the third, the method is called with no arguments. Como se muestra el resultado del ejemplo, los compiladores de Visual Basic y C# esto traducen en una llamada a la Display método con una matriz de cadena vacía.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

Comentarios

El ParamArrayAttribute indica que un parámetro de método es una matriz de parámetros.The ParamArrayAttribute indicates that a method parameter is a parameter array. Una matriz de parámetros permite la especificación de un número desconocido de argumentos.A parameter array allows the specification of an unknown number of arguments. Una matriz de parámetros debe ser el último parámetro en una lista de parámetros formales y debe ser una matriz unidimensional.A parameter array must be the last parameter in a formal parameter list, and it must be a single-dimension array. Cuando se llama al método, una matriz de parámetros permite argumentos a un método que se especifique en cualquiera de estas dos maneras:When the method is called, a parameter array permits arguments to a method to be specified in either of two ways:

  • Como una única expresión de un tipo que sea implícitamente convertible al tipo de matriz de parámetros.As a single expression of a type that is implicitly convertible to the parameter array type. La matriz de parámetros funciona como un parámetro de valor.The parameter array functions as a value parameter.

  • Como cero o más argumentos, donde cada argumento es una expresión de un tipo que es implícitamente convertible al tipo de elemento de la matriz de parámetros.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.

El ejemplo en la sección siguiente muestra ambas convenciones de llamada.The example in the next section illustrates both calling conventions.

Nota

Normalmente, el ParamArrayAttribute no se usa directamente en el código.Typically, the ParamArrayAttribute is not used directly in code. En su lugar, las palabras clave de lenguaje individuales, como ParamArray en Visual Basic y params en C#, se usan como contenedores para la ParamArrayAttribute clase.Instead, individual language keywords, such as ParamArray in Visual Basic and params in C#, are used as wrappers for the ParamArrayAttribute class. Algunos lenguajes, como C#, incluso pueden requerir el uso de la palabra clave del lenguaje y prohibir el uso de ParamArrayAttribute.Some languages, such as C#, may even require the use of the language keyword and prohibit the use of ParamArrayAttribute.

Durante la resolución de sobrecarga, cuando los compiladores que admiten las matrices de parámetros se encuentran con una sobrecarga del método que no existe, pero tiene un parámetro menos que una sobrecarga que contiene una matriz de parámetros, reemplazará el método con la sobrecarga que incluye el matriz de parámetros.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. Por ejemplo, una llamada a la String.Split() método de instancia (que no existe en el String clase) se resuelve como una llamada a la String.Split(Char[]) método.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. El compilador también pasará una matriz vacía del tipo necesario para el método.The compiler will also pass an empty array of the required type to the method. Esto significa que el método siempre debe estar preparado para administrar una matriz cuya longitud es cero cuando procesa los elementos de la matriz de parámetros.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. En este ejemplo se ilustra.The example provides an illustration.

Para obtener más información sobre el uso de atributos, vea atributos.For more information about using attributes, see Attributes.

Constructores

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

Inicializa una nueva instancia de la clase ParamArrayAttribute con propiedades predeterminadas.Initializes a new instance of the ParamArrayAttribute class with default properties.

Métodos

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

Devuelve un valor que indica si esta instancia es igual que un objeto especificado.Returns a value that indicates whether this instance is equal to a specified object.

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

Devuelve el código hash de esta instancia.Returns the hash code for this instance.

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

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

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

Si se reemplaza en una clase derivada, indica si el valor de esta instancia es el valor predeterminado de la clase derivada.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)

Cuando se invalida en una clase derivada, devuelve un valor que indica si esta instancia es igual a un objeto especificado.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()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

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

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)

Implementaciones de interfaz explícitas

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

Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.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)

Obtiene la información de tipos de un objeto, que puede utilizarse para obtener la información de tipos de una interfaz.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)

Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 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)

Proporciona acceso a las propiedades y los métodos expuestos por un objeto.Provides access to properties and methods exposed by an object.

(Inherited from Attribute)

Propiedades

TypeId TypeId TypeId TypeId

Cuando se implementa en una clase derivada, obtiene un identificador único para este Attribute.When implemented in a derived class, gets a unique identifier for this Attribute.

(Inherited from Attribute)

Se aplica a

Consulte también: