Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

ParamArrayAttribute (Clase)

Indica que un método va a permitir un número variable de argumentos cuando se invoque. Esta clase no puede heredarse.

System.Object
  System.Attribute
    System.ParamArrayAttribute

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

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

El tipo ParamArrayAttribute expone los siguientes miembros.

  NombreDescripción
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsParamArrayAttributeInicializa una nueva instancia de la clase ParamArrayAttribute con propiedades predeterminadas.
Arriba

  NombreDescripción
Propiedad públicaTypeIdCuando se implementa en una clase derivada, obtiene un identificador único para este Attribute. (Se hereda de Attribute).
Arriba

  NombreDescripción
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEqualsInfraestructura. Devuelve un valor que indica si esta instancia equivale al objeto especificado. (Se hereda de Attribute).
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetHashCodeDevuelve el código hash de esta instancia. (Se hereda de Attribute).
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoIsDefaultAttributeCuando se invalida en una clase derivada, indica si el valor de esta instancia es el valor predeterminado para la clase derivada. (Se hereda de Attribute).
Método públicoCompatible con XNA FrameworkMatch Cuando se invalida en una clase derivada, devuelve un valor que indica si esta instancia es igual al objeto especificado. (Se hereda de Attribute).
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToString Retorna una cadena que representa al objeto actual. (Se hereda de Object).
Arriba

  NombreDescripción
Implementación explícita de interfacesMétodo privado_Attribute.GetIDsOfNamesAsigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío. (Se hereda de Attribute).
Implementación explícita de interfacesMétodo privado_Attribute.GetTypeInfoObtiene la información de tipos de un objeto, que puede utilizarse para obtener la información de tipos de una interfaz. (Se hereda de Attribute).
Implementación explícita de interfacesMétodo privado_Attribute.GetTypeInfoCount

Recupera el número de interfaces de tipo de información que suministra un objeto (0 ó 1)

(Se hereda de Attribute).
Implementación explícita de interfacesMétodo privado_Attribute.InvokeProporciona acceso a las propiedades y los métodos expuestos por un objeto. (Se hereda de Attribute).
Arriba

ParamArrayAttribute indica que el parámetro de un método es una matriz de parámetros. Una matriz de parámetros permite la especificación de un número desconocido de argumentos. Esta matriz debe ser el último parámetro de una lista de parámetros formales y también debe ser una matriz unidimensional. Cuando se llama al método, una matriz de parámetros permite que los argumentos se especifiquen mediante cualquiera de los dos mecanismos siguientes:

  • Como una única expresión de un tipo que se puede convertir al tipo de la matriz de parámetros de forma implícita. Dicha matriz de parámetros funciona como un parámetro de valor.

  • Como cero o más argumentos, en los que cada uno de ellos es una expresión de un tipo que se puede convertir implícitamente al tipo de elemento de la matriz de parámetros.

En el ejemplo de la sección siguiente se muestran estas dos convenciones de llamada.

NotaNota

Normalmente, ParamArrayAttribute no se utiliza directamente en el código. En su lugar, se utilizan palabras claves específicas del lenguaje, por ejemplo ParamArray en Visual Basic y params de C#, como contenedores de la clase ParamArrayAttribute. En algunos lenguajes, como en C#, puede ser necesario el uso de la palabra clave del lenguaje y estará prohibido el uso de ParamArrayAttribute.

Durante la resolución de sobrecarga, si los compiladores que admiten las matrices de parámetros encuentran una sobrecarga de un método que no existe, pero que tiene un parámetro menos que una sobrecarga que contiene una matriz de parámetros, reemplazarán el método por la sobrecarga que contiene la matriz de parámetros. Por ejemplo, una llamada al método de instancia String.Split() (que no existe en la clase String ) se resuelve como una llamada al método String.Split(Char[]). El compilador también pasará al método una matriz vacía del tipo necesario. 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. El ejemplo lo ilustra.

Para obtener más información sobre cómo utilizar atributos, vea Extender metadatos mediante atributos.

El siguiente ejemplo define una clase Temperature que incluye un método Display, que está pensado para mostrar uno o más valores de temperatura con formato. El método tiene un único parámetro, formats, que se define como una matriz de parámetros.


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 { }
         }
      }
   }
}


En el ejemplo siguiente se muestran tres llamadas diferentes al método Temperature.Display. En la primera, se pasa una matriz de cadenas de formato al método. En la segunda, se pasan cuatro cadenas de formato distintas como argumentos al método. En la tercera, se llama al método sin argumentos. Cuando se muestra el resultado del ejemplo, los compiladores de C# y Visual Basic lo traducen como una llamada al método Display con una matriz de cadenas vacía.


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


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft