ParamArrayAttribute ParamArrayAttribute ParamArrayAttribute ParamArrayAttribute Class

Definição

Indica que um método permitirá um número variável de argumentos na sua invocação.Indicates that a method will allow a variable number of arguments in its invocation. Essa classe não pode ser herdada.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
Herança
ParamArrayAttributeParamArrayAttributeParamArrayAttributeParamArrayAttribute
Atributos

Exemplos

O exemplo a seguir define uma Temperature classe inclui um Display método, que destina-se para exibir um ou mais valores de temperatura formatada.The following example defines a Temperature class that includes a Display method, which is intended to display one or more formatted temperature values. O método tem um único parâmetro, formats, que é definida como uma 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

O exemplo a seguir ilustra três chamadas diferentes para o Temperature.Display método.The following example illustrates three different calls to the Temperature.Display method. No primeiro, o método recebe uma matriz de cadeias de caracteres de formato.In the first, the method is passed an array of format strings. Na segunda, o método recebe quatro cadeias de caracteres de formato individuais como argumentos.In the second, the method is passed four individual format strings as arguments. O terceiro, o método é chamado sem argumentos.In the third, the method is called with no arguments. Como ilustra a saída do exemplo, os compiladores do Visual Basic e C# traduzem isso em uma chamada para o Display método com uma matriz de cadeia de caracteres vazia.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

Comentários

O ParamArrayAttribute indica que um parâmetro de método é uma matriz de parâmetros.The ParamArrayAttribute indicates that a method parameter is a parameter array. Uma matriz de parâmetros permite a especificação de um número desconhecido de argumentos.A parameter array allows the specification of an unknown number of arguments. Uma matriz de parâmetros deve ser o último parâmetro em uma lista de parâmetros formais e ele deve ser uma matriz de dimensão única.A parameter array must be the last parameter in a formal parameter list, and it must be a single-dimension array. Quando o método é chamado, uma matriz de parâmetro permite que os argumentos para um método a ser especificado em qualquer uma das duas maneiras:When the method is called, a parameter array permits arguments to a method to be specified in either of two ways:

  • Como uma única expressão de um tipo que é implicitamente conversível para o tipo de matriz de parâmetro.As a single expression of a type that is implicitly convertible to the parameter array type. As funções de matriz de parâmetro como um parâmetro de valor.The parameter array functions as a value parameter.

  • Como zero ou mais argumentos, onde cada argumento é uma expressão de um tipo que é implicitamente conversível para o tipo do elemento da matriz de parâmetro.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.

O exemplo na próxima seção ilustra ambas as convenções de chamada.The example in the next section illustrates both calling conventions.

Observação

Normalmente, o ParamArrayAttribute não é usado diretamente no código.Typically, the ParamArrayAttribute is not used directly in code. Em vez disso, palavras-chave de linguagem individual, como ParamArray no Visual Basic e params em C#, são usados como invólucros para a ParamArrayAttribute classe.Instead, individual language keywords, such as ParamArray in Visual Basic and params in C#, are used as wrappers for the ParamArrayAttribute class. Algumas linguagens, como C#, até mesmo podem exigir o uso da palavra-chave de linguagem e proíbem o uso de ParamArrayAttribute.Some languages, such as C#, may even require the use of the language keyword and prohibit the use of ParamArrayAttribute.

Durante a resolução de sobrecarga, quando os compiladores que dão suporte a matrizes de parâmetros encontram uma sobrecarga de método que não existe, mas tem um parâmetro menos que uma sobrecarga que inclui uma matriz de parâmetros, eles substituirá o método com a sobrecarga que inclui o 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 exemplo, uma chamada para o String.Split() método de instância (que não existe na String classe) é resolvido como uma chamada para o 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. O compilador irá passar uma matriz vazia do tipo necessário para o método.The compiler will also pass an empty array of the required type to the method. Isso significa que o método sempre deve estar preparado para lidar com uma matriz cujo tamanho é zero quando ele processa os elementos na 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. O exemplo fornece uma ilustração.The example provides an illustration.

Para obter mais informações sobre como usar atributos, consulte atributos.For more information about using attributes, see Attributes.

Construtores

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

Inicializa uma nova instância da classe ParamArrayAttribute com propriedades padrão.Initializes a new instance of the ParamArrayAttribute class with default properties.

Métodos

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

Retorna um valor que indica se essa instância é igual a um objeto especificado.Returns a value that indicates whether this instance is equal to a specified object.

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

Retorna o código hash para essa instância.Returns the hash code for this instance.

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

Obtém o Type da instância atual.Gets the Type of the current instance.

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

Quando substituído em uma classe derivada, indica se o valor dessa instância é o valor padrão para a classe 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)

Quando substituído em uma classe derivada, retorna um valor que indica se essa instância é igual a um 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()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

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

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Inherited from Object)

Implantações explícitas de interface

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

Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expediçã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)

Recupera as informações de tipo para um objeto, que pode ser usado para obter as informações de tipo para uma interface.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)

Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 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)

Fornece acesso a propriedades e métodos expostos por um objeto.Provides access to properties and methods exposed by an object.

(Inherited from Attribute)

Propriedades

TypeId TypeId TypeId TypeId

Quando implementado em uma classe derivada, obtém um identificador exclusivo para este Attribute.When implemented in a derived class, gets a unique identifier for this Attribute.

(Inherited from Attribute)

Aplica-se a

Veja também