Aplicar atributos

Use o processo a seguir para aplicar um atributo a um elemento do seu 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, que pode incluir uma quebra de linha. No Visual Basic, o atributo é rodeado por parênteses angulares e deve estar na mesma linha lógica; o carácter de continuação de linha pode ser usado se se desejar uma quebra de linha.
Especifique parâmetros posicionais e parâmetros nomeados para o atributo.

Parâmetros posicionais são necessários e devem ser anteriores a quaisquer parâmetros nomeados; correspondem aos parâmetros de um dos construtores do atributo. Parâmetros nomeados são opcionais e correspondem às propriedades de leitura/escrita do atributo. Em C++ e C#, especifiquem name=value para cada parâmetro opcional, onde name é o nome da propriedade. No Visual Basic, especifique name:=value.

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

Por convenção, todos os nomes de atributos terminam com "Atributo". No entanto, várias linguagens que visam o tempo de execução, como Visual Basic e C#, não exigem que especifique o nome completo de um atributo. Por exemplo, se quiser inicializar System.ObsoleteAttribute, só precisa de o referenciar como Obsoleto.

Argumentos válidos de atributos

Quando passar argumentos a 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 nomes (nameof em C#, NameOf em Visual Basic), que produzem constantes de cadeia em tempo de compilação.
Expressões de criação de array 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âmetros de atributo:

Tipos simples (palavra-chave C# / palavra-chave Visual Basic / tipo de runtime .NET):

C#	Visual Basic	Tipo de execução .NET
`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 válidos de argumento de atributos ou um array unidimensional destes).
Type.
Tipos de enum que estão acessíveis no site de utilização.
Arrays unidimensionais de qualquer um dos tipos anteriores.

Observação

Os tipos sbyte, ushort, uint, ulong, decimal, nint, , e nuint não são tipos válidos de parâmetros de atributo, embora suportem constantes literais.

Os seguintes exemplos mostram argumentos válidos de atributos:

[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 seguintes mostram argumentos que causam um erro no 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 seguinte exemplo de código mostra como usar System.ObsoleteAttribute, que marca o código como obsoleto. A cadeia "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 descrito pelo atributo é 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