Atributos comuns (C# e Visual Basic)

Este tópico descreve os atributos que são mais comumente usados no C# e programas de Visual Basic.

• Atributos globais

• Atributo obsoleto

• Atributo Conditional

• Atributos de informações do chamador

• Atributos do Visual Basic

Atributos globais

A maioria dos atributos são aplicados a elementos de linguagem específica como, por exemplo, classes ou métodos; No entanto, alguns atributos são globais — elas se aplicam a um módulo ou assembly inteiro.Por exemplo, o AssemblyVersionAttribute atributo pode ser usado para incorporar informações de versão em um assembly, como este:

[assembly: AssemblyVersion("1.0.0.0")]

<Assembly: AssemblyVersion("1.0.0.0")>

Atributos globais aparecem no código fonte após qualquer nível superior using diretivas (Imports em Visual Basic) e antes de qualquer declaração de tipo, módulo ou namespace.Atributos globais podem aparecer em vários arquivos de origem, mas os arquivos devem ser compilados em uma passagem de compilação única.Para projetos de Visual Basic, os atributos globais geralmente são colocados no arquivo AssemblyInfo. vb que é criado automaticamente com Visual Basic projetos.Em projetos de C#, eles são colocados no arquivo AssemblyInfo. cs.

Atributos de Conjunto de Módulos (Assembly) são valores que fornecem informações sobre um conjunto de módulos (assembly).Elas se enquadram nas categorias a seguir:

• Atributos de identidade de Conjunto de Módulos (Assembly)

• Atributos informativos

• Atributos do manifesto do assembly

• Atributos de nome de alta segurança

Atributos de identidade de Conjunto de Módulos (Assembly)

Três atributos (com um nome forte, se aplicável) determinam a identidade de um conjunto de módulos (assembly): nome, versão e cultura.Esses atributos formam o nome completo do conjunto de módulos (assembly) e são necessários quando você referencia a ele em código.Você pode definir uma versão e cultura de um conjunto de módulos (assembly) usando atributos.No entanto, o valor do nome é definido pelo compilador, a IDE do Visual Studio na Caixa de diálogo de informações de assembly, ou o Assembly Linker (AL.exe) quando o conjunto é criado, com base no arquivo que contém o manifesto do assembly.O atributo AssemblyFlagsAttribute especifica se várias cópias do conjunto podem coexistir.

A tabela a seguir mostra os atributos de identidade.

Atributos Informativos

Você pode usar atributos informativos para fornecer informações sobre produtos ou empresas adicionais para um conjunto de módulos (assembly).A tabela a seguir mostra os atributos informativos definidos no espaço para nome System.Reflection.

Atributos do manifesto do assembly

Você pode usar atributos do manifesto do assembly para fornecer informações no manifesto do assembly.Isso inclui Título, Descrição, alias padrão e a configuração.A tabela a seguir mostra os atributos do manifesto do assembly definidos no espaço para nome System.Reflection.

Atributos de nome de alta segurança

Em versões anteriores do Visual Studio, a assinatura a assemblies usando nomes de alta segurança foi executada com esses atributos de nível de conjunto:

• AssemblyKeyFileAttribute

• AssemblyKeyNameAttribute

• AssemblyDelaySignAttribute

Ainda há suporte para isso, mas a maneira preferida para assinar assemblies é usar o Página de assinatura no Project Designer.Consulte Assinatura de página, Designer de projeto e Como: assinar um Assembly (Visual Studio) para mais informações.

Atributo obsoleto

O Obsolete atributo marca uma entidade de programa como um que não é recomendada para uso.Cada uso de uma entidade marcado como obsoleto subseqüentemente irá gerar um aviso ou erro, dependendo de como o atributo está configurado.Por exemplo:

    <System.Obsolete("use class B")> 
    Class A
        Sub Method()
        End Sub
    End Class

    Class B
        <System.Obsolete("use NewMethod", True)> 
        Sub OldMethod()
        End Sub

        Sub NewMethod()
        End Sub
    End Class

[System.Obsolete("use class B")]
class A
{
    public void Method() { }
}
class B
{
    [System.Obsolete("use NewMethod", true)]
    public void OldMethod() { }
    public void NewMethod() { }
}

Neste exemplo o Obsolete atributo é aplicado à classe A e ao método B.OldMethod.Porque o segundo argumento do construtor de atributo aplicado a B.OldMethod for definido como true, este método causará um erro do compilador, enquanto a classe A irá produzir apenas um aviso.Chamando B.NewMethod, no entanto, não produz nenhum aviso ou erro.

A seqüência de caracteres fornecida como o primeiro argumento para o construtor de atributo será exibida como parte do aviso ou erro.Por exemplo, quando você usá-lo com as definições anteriores, o código a seguir gera um erro e dois avisos:

' Generates 2 warnings:
' Dim a As New A
' Generate no errors or warnings:

Dim b As New B
b.NewMethod()

' Generates an error, terminating compilation:
' b.OldMethod()

// Generates 2 warnings:
// A a = new A();

// Generate no errors or warnings:
B b = new B();
b.NewMethod();

// Generates an error, terminating compilation:
// b.OldMethod();

Dois avisos para a classe A são geradas: uma para a declaração de referência da classe e outra para o construtor da classe.

O Obsolete atributo pode ser usado sem argumentos, mas incluindo uma explicação do motivo pelo qual o item é obsoleto e o que usar em vez disso, é recomendável.

O Obsolete atributo é um atributo de uso único e pode ser aplicado a qualquer entidade que permite que os atributos.Obsolete é um alias para ObsoleteAttribute.

Atributo Conditional

O Conditional atributo torna of de execução a um método dependente de um identificador de pré-processamento.O Conditional atributo é um alias de ConditionalAttributee pode ser aplicado a um método ou uma classe de atributo.

Neste exemplo, Conditional é aplicado a um método para ativar ou desativar a exibição de informações de diagnóstico específico do programa:

#Const TRACE_ON = True
Imports System
Imports System.Diagnostics
Module TestConditionalAttribute
    Public Class Trace
        <Conditional("TRACE_ON")> 
        Public Shared Sub Msg(ByVal msg As String)
            Console.WriteLine(msg)
        End Sub

    End Class

    Sub Main()
        Trace.Msg("Now in Main...")
        Console.WriteLine("Done.")
    End Sub
End Module

#define TRACE_ON
using System;
using System.Diagnostics;

public class Trace
{
    [Conditional("TRACE_ON")]
    public static void Msg(string msg)
    {
        Console.WriteLine(msg);
    }
}

public class ProgramClass
{
    static void Main()
    {
        Trace.Msg("Now in Main...");
        Console.WriteLine("Done.");
    }
}

Se a TRACE_ON identificador não está definido, nenhuma saída de rastreamento será exibida.

O Conditional atributo é geralmente usado com o DEBUG identificador para ativar o rastreamento e recursos de log para compilações de depuração, mas não no lançamento aproveita a, como este:

<Conditional("DEBUG")> 
Shared Sub DebugMethod()

End Sub

[Conditional("DEBUG")]
static void DebugMethod()
{
}

Quando um método marcado como condicional é chamado, a presença ou ausência do símbolo de pré-processamento especificado determina se a chamada é incluída ou omitida.Se o símbolo é definido, a chamada é incluída; Caso contrário, a chamada é omitida.Usando Conditional é um cartucho de limpeza, uma alternativa mais elegante e menos propensa colocar métodos dentro #if…#endif blocos, como este:

#If DEBUG Then
    Sub ConditionalMethod()
    End Sub
#End If

#if DEBUG
    void ConditionalMethod()
    {
    }
#endif

Um método condicional deve ser um método em uma declaração de classe ou estrutura e não deve ter um valor de retorno.

Usando vários identificadores

Se um método possui diversas Conditional atributos, uma chamada para o método é incluída se pelo menos um dos símbolos condicionais for definido (em outras palavras, os símbolos são logicamente vinculados juntos usando o operador ou).Neste exemplo, a presença de um A ou B resultará em uma chamada de método:

<Conditional("A"), Conditional("B")> 
Shared Sub DoIfAorB()

End Sub

[Conditional("A"), Conditional("B")]
static void DoIfAorB()
{
    // ...
}

Para obter o efeito de vincular logicamente os símbolos usando o operador AND, você pode definir métodos condicionais seriais.Por exemplo, o segundo método abaixo será executado somente se ambos os A e B são definidos:

<Conditional("A")> 
Shared Sub DoIfA()
    DoIfAandB()
End Sub

<Conditional("B")> 
Shared Sub DoIfAandB()
    ' Code to execute when both A and B are defined...
End Sub

[Conditional("A")]
static void DoIfA()
{
    DoIfAandB();
}

[Conditional("B")]
static void DoIfAandB()
{
    // Code to execute when both A and B are defined...
}

Uso condicional com Classes de atributo

O Conditional atributo também pode ser aplicado a uma definição de classe de atributo.Neste exemplo, o atributo personalizado Documentation apenas adicionará informações para os metadados se DEBUG está definido.

<Conditional("DEBUG")> 
Public Class Documentation
    Inherits System.Attribute
    Private text As String
    Sub New(ByVal doc_text As String)
        text = doc_text
    End Sub
End Class

Class SampleClass
    ' This attribute will only be included if DEBUG is defined.
    <Documentation("This method displays an integer.")> 
    Shared Sub DoWork(ByVal i As Integer)
        System.Console.WriteLine(i)
    End Sub
End Class

[Conditional("DEBUG")]
public class Documentation : System.Attribute
{
    string text;

    public Documentation(string text)
    {
        this.text = text;
    }
}

class SampleClass
{
    // This attribute will only be included if DEBUG is defined.
    [Documentation("This method displays an integer.")]
    static void DoWork(int i)
    {
        System.Console.WriteLine(i.ToString());
    }
}

Atributos de informações do chamador

Usando os atributos de informações do chamador, você pode obter informações sobre o chamador para um método.Você pode obter o caminho do arquivo de código-fonte, o número de linha no código-fonte e o nome do membro do chamador.

Para obter informações do chamador de membro, você pode usar atributos que são aplicados para parâmetros opcionais.Cada parâmetro opcional especifica um valor padrão.A tabela a seguir lista os atributos de informações do chamador que são definidos na System.Runtime.CompilerServices espaço para nome:

Para obter mais informações sobre os atributos de informações do chamador, consulte Informações do chamador (C# e Visual Basic).

Atributos do Visual Basic

A tabela a seguir lista os atributos que são específicos para Visual Basic.

COMClassAttribute

Use COMClassAttribute para simplificar o processo de criação componentes COM do Visual Basic.Objetos COM são consideravelmente diferentes dos conjuntos de módulos (assemblies) .NET Framework , e sem COMClassAttribute, você precisará seguir uma série de etapas para gerar um objeto COM do Visual Basic.Para classes marcadas com COMClassAttribute, o compilador executa muitos desses passos automaticamente.

HideModuleNameAttribute

Use HideModuleNameAttribute para permitir que membros do módulo ser acessado usando-se somente a qualificação necessária para o módulo.

VBFixedStringAttribute

Use VBFixedStringAttribute para forçar Visual Basic a criar uma cadeia de caracteres de comprimento fixo.Cadeias de caracteres são de comprimento variável por padrão, e esse atributo é útil para armazenar cadeias de caracteres em arquivos.O código a seguir demonstra isso:

Structure Worker
    ' The runtime uses VBFixedString to determine 
    ' if the field should be written out as a fixed size.
    <VBFixedString(10)> Public LastName As String
    <VBFixedString(7)> Public Title As String
    <VBFixedString(2)> Public Rank As String
End Structure

VBFixedArrayAttribute

Use VBFixedArrayAttribute para declarar matrizes que foram fixadas em tamanho.Como as cadeias de caracteres Visual Basic , matrizes são de comprimento variável por padrão.Esse atributo é útil para serialização ou gravação de dados em arquivos.

Consulte também

Referência

Reflexão (C# e Visual Basic)

Acesso a atributos usando reflexão (C# e Visual Basic)

System.Reflection

Attribute

Conceitos

Guia de programação do C#

Outros recursos

Guia de programação de Visual Basic

Estendendo metadados usando atributos