Atributos (C# e Visual Basic)
Os atributos fornecem um método eficiente de associar metadadosou informações declarativas, código (conjuntos de módulos, tipos, métodos, propriedades e assim por diante).Depois que um atributo estiver associado umaentidadedo programa, o atributo pode ser consultado em tempo de execução usando uma técnica chamada reflexão. Para mais informações, consulte Reflexão (C# e Visual Basic).
Atributos têm as seguintes propriedades:
Atributos adicionar metadados para o seu programa.Metadados informações sobre os tipos definidos em um programa.Todos os.NET contêm um conjunto de metadados que descreve os tipos e membros de tipo definidos no assemblyespecificado.Você pode adicionar atributos personalizados para especificar qualquer informação adicional necessária.Para obter mais informações, consulte, Criando atributos personalizados (C# e Visual Basic).
Você pode aplicar um ou mais atributos para assemblies, módulos ou elementos pequenos programas como classes e propriedades.
Atributos podem aceitar argumentos da mesma forma que métodos e propriedades.
Seu programa pode examinar os metadados em outros programas ou seus próprios metadados por meio de reflexão.Para mais informações, consulte Acesso a atributos usando reflexão (C# e Visual Basic).
Usando atributos
Atributos podem ser colocados em praticamente qualquer declaração, embora um determinado atributo pode restringir os tipos de declarações no qual ele é válido.Para especificar um atributo colocando o nome do atributo, entre colchetes ([]), em C#, acima da declaração da entidade à qual ele se aplica.No Visual Basic, um atributo está entre colchetes angulares (< >).Ele deve aparecer imediatamente antes do elemento ao qual ele é aplicado, na mesma linha.
Neste exemplo, o SerializableAttribute atributo é usado para aplicar uma característica específica a uma classe:
<System.Serializable()> Public Class SampleClass
' Objects of this type can be serialized.
End Class
[System.Serializable]
public class SampleClass
{
// Objects of this type can be serialized.
}
Um método com o atributo DllImportAttribute é declarada como este:
Imports System.Runtime.InteropServices
...
<System.Runtime.InteropServices.DllImport("user32.dll")>
Sub SampleMethod()
End Sub
using System.Runtime.InteropServices;
...
[System.Runtime.InteropServices.DllImport("user32.dll")]
extern static void SampleMethod();
Mais de um atributo pode ser colocado em uma declaração:
Imports System.Runtime.InteropServices
...
Sub MethodA(<[In](), Out()> ByVal x As Double)
End Sub
Sub MethodB(<Out(), [In]()> ByVal x As Double)
End Sub
using System.Runtime.InteropServices;
...
void MethodA([In][Out] ref double x) { }
void MethodB([Out][In] ref double x) { }
void MethodC([In, Out] ref double x) { }
Alguns atributos podem ser especificados mais de uma vez para uma determinada entidade.Um exemplo de tal um multiuse atributo é ConditionalAttribute:
<Conditional("DEBUG"), Conditional("TEST1")>
Sub TraceMethod()
End Sub
[Conditional("DEBUG"), Conditional("TEST1")]
void TraceMethod()
{
// ...
}
.gif "Observação") Observação |
|---|
Por convenção, todos os nomes de atributo terminam com a palavra "Atributo" para diferenciá-los de outros itens na.NET Framework.No entanto, você não precisará especificar o sufixo de atributo ao usar os atributos no código.Por exemplo, [DllImport] é equivalente a [DllImportAttribute], mas DllImportAttribute é do atributode nome real na.NET Framework. |
.gif "z0w1kczw.collapse_all(pt-br,VS.110).gif")
Parâmetros do atributo
Muitos atributos têm parâmetros, o que podem ser sem nome, posicional ou nomeado.Todos os parâmetros posicionais devem ser especificados em uma determinada ordem e não podem ser omitidos; parâmetros nomeados são opcionais e podem ser especificados em qualquer ordem.Parâmetros de posição é especificada pela primeira vez.Por exemplo, esses três atributos são equivalentes:
[DllImport("user32.dll")]
[DllImport("user32.dll", SetLastError=false, ExactSpelling=false)]
[DllImport("user32.dll", ExactSpelling=false, SetLastError=false)]
<DllImport("user32.dll")>
<DllImport("user32.dll", SetLastError:=False, ExactSpelling:=False)>
<DllImport("user32.dll", ExactSpelling:=False, SetLastError:=False)>
O primeiro parâmetro, o nome da DLL é posicional e sempre vem em primeiro lugar; os outros são nomeados.Neste maiúsculas e minúsculas, ambos chamados padrão de parâmetros como false, portanto, pode ser omitidos.Consulte a documentação individual atributodo para obter informações sobre valores de parâmetro padrão.
Destinos de atributo
O destino de um atributo é a entidade à qual o atributo se aplica.Por exemplo, um atributo pode aplicar uma classe, um determinado métodoou um assemblyde inteiro.Por padrão, um atributo se aplica ao elemento que ela precede.Mas você pode também identificar explicitamente, por exemplo, se um atributo é aplicado a um método, ou ao seu parâmetroou seu valor retornado.
Para identificar explicitamente um atributodedestino, use a seguinte sintaxe:
[target : attribute-list]
<target : attribute-list>
A lista de possíveis target valores é mostrado na tabela a seguir.
C# |
Visual Basic |
Se aplica a |
|---|---|---|
assembly |
Assembly |
assembly de inteiro |
module |
Module |
De assemblyatualmódulo (que é diferente de um módulo Visual Basic ) |
field |
Sem suporte |
Campo em uma classe ou uma struct |
event |
Sem suporte |
Evento |
method |
Sem suporte |
Método ou get e setos assessores da propriedade |
param |
Sem suporte |
Parâmetros do método ou setparâmetros de assessor de propriedade |
property |
Sem suporte |
Propriedade |
return |
Sem suporte |
Retornar o valor de um método, propriedadeindexador, ou getacessador de propriedade |
type |
Sem suporte |
Struct, classe, interface, enum ou delegado |
A exemplo a seguir mostra como aplicar atributos para os módulos e assemblies.Para mais informações, consulte Atributos comuns (C# e Visual Basic).
Imports System.Reflection
<Assembly: AssemblyTitleAttribute("Production assembly 4"),
Module: CLSCompliant(True)>
using System;
using System.Reflection;
[assembly: AssemblyTitleAttribute("Production assembly 4")]
[module: CLSCompliant(true)]
O exemplo a seguir mostra como aplicar atributos para métodos, parâmetros de método e método retornam valores em C#.
// default: applies to method
[SomeAttr]
int Method1() { return 0; }
// applies to method
[method: SomeAttr]
int Method2() { return 0; }
// applies to return value
[return: SomeAttr]
int Method3() { return 0; }
| Observação |
|---|
Independentemente dos destinos no qual SomeAttr é definido para ser válido, o return destino deve ser especificado, mesmo que SomeAttr foram definidos para aplicar somente para retornar valores. Em outras palavras, o compilador não usará AttributeUsage informações para resolver destinos de atributo de ambíguo.Para mais informações, consulte AttributeUsage (C# e Visual Basic). |
Usos comuns para atributos
A lista a seguir inclui alguns dos usos comuns de atributos no código:
A marcação de métodos usando a WebMethod atributo nos serviços Web para indicar que o método deve ser acessível através do protocolo SOAP . Para mais informações, consulte WebMethodAttribute.
Descrever como os parâmetros dométodo realizar marshalingquando interoperar com código nativo . Para mais informações, consulte MarshalAsAttribute.
Descrever as propriedades COM classes, métodos e interfaces.
Chamada de código não gerenciado com o DllImportAttribute classe.
Descrever o seu assembly em termos de versão, título, descrição ou marca registrada.
Descrever quais membros de uma classe para serializar para persistência.
Descrevendo como mapa entre membros de classe e nós XML paraserializaçãode XML.
Descrever os requisitos de segurança para métodos.
Especificando as características usado para reforçar a segurança.
Controlando otimizações pelo compilador Just-In-Time (JIT) para que o código permanece fácil de depurar.
Obtendo informações sobre o chamador para um método.
Seções relacionadas
Para obter mais informações, consulte: