Aplicar atributos

Use o processo a seguir para aplicar um atributo a um elemento do código.

Defina um novo atributo ou use um atributo .NET existente.
Aplique o atributo ao elemento de código colocando-o imediatamente antes do elemento.

Cada idioma tem sua própria sintaxe de atributo. Em C++ e C#, o atributo é cercado por colchetes e separado do elemento por espaço em branco, o que pode incluir uma quebra de linha. Em Visual Basic, o atributo é cercado por colchetes angulares e deve estar na mesma linha lógica; o caractere de continuação de linha pode ser usado se uma quebra de linha for desejada.
Especifique parâmetros posicionais e parâmetros nomeados para o atributo.

Parâmetros posicionais são necessários e devem vir antes de qualquer parâmetro nomeado; correspondem aos parâmetros de um dos construtores do atributo. Os parâmetros nomeados são opcionais e correspondem às propriedades de leitura/gravação do atributo. Em C++e C#, especifique name=value para cada parâmetro opcional, onde name está o nome da propriedade. Em Visual Basic, especifique name:=value.

O atributo é emitido em metadados quando você compila seu código e está disponível para o tempo de execução de linguagem comum e qualquer ferramenta ou aplicativo personalizado por meio dos serviços de reflexão do tempo de execução.

Por convenção, todos os nomes de atributo terminam com "Attribute". No entanto, vários idiomas direcionados ao runtime, como Visual Basic e C#, não exigem que você especifique o nome completo de um atributo. Por exemplo, se você quiser inicializar System.ObsoleteAttribute, só precisará referenciá-lo como Obsoleto.

Argumentos de atributo válidos

Ao passar argumentos para um atributo, use um dos seguintes tipos de expressões:

Expressões constantes (literais, const/Const valores e valores de enumeração).
Expressões de tipo (typeof em C#, GetType em Visual Basic).
Expressões de nome (nameof em C#, NameOf em Visual Basic), que produzem constantes de cadeia de caracteres em tempo de compilação.
Expressões de criação de matriz de um tipo de parâmetro de atributo que usam apenas as expressões anteriores como valores de elemento.

Os seguintes tipos são válidos como tipos de parâmetro de atributo:

Tipos simples (palavra-chave do C# / palavra-chave do Visual Basic / tipo de tempo de execução do .NET):

C#	Visual Basic	Tipo de .NET Runtime
`bool`	`Boolean`	Boolean
`byte`	`Byte`	Byte
`char`	`Char`	Char
`double`	`Double`	Double
`float`	`Single`	Single
`int`	`Integer`	Int32
`long`	`Long`	Int64
`short`	`Short`	Int16
`string`	`String`	String

object (em C#, quando o valor é um dos tipos de argumento de atributo válidos ou uma matriz unidimensional deles).
Type.
Tipos de enumeração acessíveis no site de uso.
Matrizes unidimensionais de qualquer um dos tipos anteriores.

Observação

Os tipos sbyte, ushort, uint, ulong, , decimal, e nintnuintnão são tipos de parâmetro de atributo válidos, mesmo que eles dão suporte a constantes literais.

Os exemplos a seguir mostram argumentos de atributo válidos:

[MyAttr(true)]                            // bool literal
[MyAttr(42)]                              // int literal
[MyAttr("hello")]                         // string literal
[MyAttr(MyEnum.Value)]                    // enum value
[MyAttr(typeof(string))]                  // typeof expression
[MyAttr(nameof(MyClass))]                 // nameof expression (string constant)
[MyAttr(new int[] { 1, 2, 3 })]          // array of constants
[MyAttr(new string[] { "a", "b" })]      // array of strings

<MyAttr(True)>                            ' Boolean literal
<MyAttr(42)>                              ' Integer literal
<MyAttr("hello")>                         ' String literal
<MyAttr(MyEnum.Value)>                    ' Enum value
<MyAttr(GetType(String))>                 ' GetType expression
<MyAttr(NameOf(MyClass))>                 ' NameOf expression (string constant)
<MyAttr(New Integer() {1, 2, 3})>         ' Array of constants

Os exemplos a seguir mostram argumentos que causam um erro do compilador:

string value = "test";
[MyAttr(value)]        // Error CS0182: not a constant expression
[MyAttr(GetValue())]   // Error CS0182: method calls aren't allowed

Aplicar um atributo a um método

O exemplo de código a seguir mostra como usar System.ObsoleteAttribute, que marca o código como obsoleto. A cadeia de caracteres "Will be removed in next version" é passada para o atributo. Esse atributo causa um aviso do compilador que exibe a cadeia de caracteres passada quando o código que o atributo descreve é chamado.

public class Example
{
    // Specify attributes between square brackets in C#.
    // This attribute is applied only to the Add method.
    [Obsolete("Will be removed in next version.")]
    public static int Add(int a, int b)
    {
        return (a + b);
    }
}

class Test
{
    public static void Main()
    {
        // This generates a compile-time warning.
        int i = Example.Add(2, 2);
    }
}

Public Class Example
    ' Specify attributes between square brackets in C#.
    ' This attribute is applied only to the Add method.
    <Obsolete("Will be removed in next version.")>
    Public Shared Function Add(a As Integer, b As Integer) As Integer
        Return a + b
    End Function
End Class

Class Test
    Public Shared Sub Main()
        ' This generates a compile-time warning.
        Dim i As Integer = Example.Add(2, 2)
    End Sub
End Class