ParamArrayAttribute Clase

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Indica que un método permitirá a un número variable de argumentos en la invocación. Esta clase no puede heredarse.

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

Herencia: Object

Attribute
ParamArrayAttribute

Atributos: AttributeUsageAttribute ComVisibleAttribute

Ejemplos

En el ejemplo siguiente se define una Temperature clase que incluye un Display método , que está pensado para mostrar uno o varios 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 { }
         }
      }
   }
}

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

En el ejemplo siguiente se muestran tres llamadas diferentes al Temperature.Display método . En el primero, el método se pasa una matriz de cadenas de formato. En el segundo, el método se pasa cuatro cadenas de formato individual como argumentos. En el tercero, se llama al método sin argumentos. Como se muestra en la salida del ejemplo, los compiladores de Visual Basic y C# lo traducen en una llamada al Display método 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

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

Comentarios

ParamArrayAttribute indica que un parámetro de método es una matriz de parámetros. Una matriz de parámetros permite la especificación de un número desconocido de argumentos. Una matriz de parámetros debe ser el último parámetro de una lista de parámetros formal y debe ser una matriz de una sola dimensión. Cuando se llama al método , una matriz de parámetros permite especificar argumentos a un método de dos maneras:

Como expresión única de un tipo que se puede convertir implícitamente en el tipo de matriz de parámetros. La matriz de parámetros funciona como un parámetro de valor.
Como cero o más argumentos, donde cada argumento es una expresión de un tipo que se puede convertir implícitamente al tipo del elemento de matriz de parámetros.

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

Nota

Normalmente, ParamArrayAttribute no se usa directamente en el código. 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 . Algunos lenguajes, como C#, pueden incluso requerir el uso de la palabra clave del lenguaje y prohibir el uso de ParamArrayAttribute.

Durante la resolución de sobrecargas, cuando los compiladores que admiten matrices de parámetros encuentran una sobrecarga de método que no existe, pero tienen un parámetro menor que una sobrecarga que incluye una matriz de parámetros, reemplazarán el método por la sobrecarga que incluye la matriz de parámetros. Por ejemplo, una llamada al String.Split() método de instancia (que no existe en la String clase) se resuelve como una llamada al String.Split(Char[]) método . El compilador también pasará una matriz vacía del tipo necesario al método . Esto significa que el método siempre debe estar preparado para controlar una matriz cuya longitud es cero cuando procesa los elementos de la matriz de parámetros. En este ejemplo se ilustra.

Para obtener más información sobre el uso de atributos, vea Atributos.

Constructores

ParamArrayAttribute()

Inicializa una nueva instancia de la clase ParamArrayAttribute con propiedades predeterminadas.

Propiedades

TypeId

Cuando se implementa en una clase derivada, obtiene un identificador único para este Attribute.

(Heredado de Attribute)

Métodos

Equals(Object)	Devuelve un valor que indica si esta instancia es igual que un objeto especificado. (Heredado de Attribute)
GetHashCode()	Devuelve el código hash de esta instancia. (Heredado de Attribute)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
IsDefaultAttribute()	Si se reemplaza en una clase derivada, indica si el valor de esta instancia es el valor predeterminado de la clase derivada. (Heredado de Attribute)
Match(Object)	Cuando se invalida en una clase derivada, devuelve un valor que indica si esta instancia es igual a un objeto especificado. (Heredado de Attribute)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Implementaciones de interfaz explícitas

_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío. (Heredado de Attribute)
_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. (Heredado de Attribute)
_Attribute.GetTypeInfoCount(UInt32)	Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 1). (Heredado de Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Proporciona acceso a las propiedades y los métodos expuestos por un objeto. (Heredado de Attribute)

Se aplica a

Compartir a través de