Atributos comuns (C# e Visual Basic)

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

• Atributos globais

• Atributo obsoleto

• Atributo Conditional

• Atributos do Visual Basic

Atributos globais

A maioria dos atributos são aplicados a elementos de idioma específico, como 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 quaisquer declarações 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 assembly são valores que fornecem informações sobre um 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 Assembly

Três atributos (com um nome forte, se aplicável) determinam a identidade de um 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 Assembly Information, 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 adicionais da empresa ou do produto para um assembly. A tabela a seguir mostra os atributos informativos definidos no namespace 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 namespace 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 assembly:

• AssemblyKeyFileAttribute

• AssemblyKeyNameAttribute

• AssemblyDelaySignAttribute

Isso ainda é suportado, mas a maneira preferida para assinar assemblies é usar o Página assinatura no Project Designer. Consulte Assinatura de Página, o criador do 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 é recomendado para uso. Cada uso de uma entidade marcado como obsoleto subseqüentemente 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 para o método B.OldMethod. Porque o segundo argumento do construtor de atributo é aplicado a B.OldMethod é definida como true, este método causará um erro do compilador, enquanto a classe A apenas produzirá 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 de um aviso ou erro. Por exemplo, quando você usá-lo com as definições anteriores, o seguinte código gera dois avisos e um erro:

' 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: um 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 está obsoleto e usar em vez disso, o que é recomendado.

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

Atributo Conditional

O Conditional atributo torna a execução de um método dependente de um identificador de pré-processamento. O Conditional atributo é um alias para 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, não será exibida nenhuma saída de rastreamento.

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 cria, assim:

<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 class ou struct e não deve ter um valor de retorno.

Usando vários identificadores

Se um método tem várias Conditional atributos, uma chamada ao 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 E, você pode definir os 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...
}

Usando condicional com as 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 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 sequência de comprimento fixo. Sequências de caracteres são de comprimento variável por padrão, e esse atributo é útil para armazenar sequências 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 sequências 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)

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

System.Reflection

Attribute

Conceitos

Guia de Programação C#

Estendendo metadados usando atributos

Outros recursos

Guia de programação Visual Basic