Utilizando atributos com C# - Revista .net Magazine 89

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (0)

O artigo demonstra os atributos do .NET Framework e suas principais utilizações dentro da linguagem C# e seus projetos.

De que se trata o artigo

O artigo demonstra os atributos do .NET Framework e suas principais utilizações dentro da linguagem C# e seus projetos. Também mostra como criar e ler atributos customizados passando pelas principais formas de se aplicar estes em diversos tipos de aplicações.

Em que situação o tema é útil

Atributos servem para fornecer metadados sobre os elementos do código e, dependendo da maneira como são definidos, alterar o comportamento da aplicação. Os atributos são constantemente usados em conjunto com técnicas de Reflection, para obter dados do aplicativo durante o runtime. Os atributos ajudam em diversas tarefas que vão desde informações adicionais sobre um elemento do programa (classes, propriedades e métodos), alteração do comportamento da serialização XML de uma classe, definição de classes para testes unitários, etc. Os atributos podem diminuir a complexidade do código gerado ou, pelo menos, dar mais flexibilidade ao mesmo.

Utilizando atributos com C#

Atributos acrescentam dados sobre elementos da linguagem de programação quer sejam classes, propriedades, assembly etc. Podem ser usados para documentar ou fornecer metadados para serem recuperados via Reflection e a partir dos dados que forem recuperados, alterar ou não o funcionamento do assembly.

Em muitos casos também podem ser usados para especificar tipos especiais de classes e métodos como os que são usados por Webservices e testes unitários.

Outro exemplo de uso dos atributos para afetar o funcionamento do código é quando atributos são usados para customizar a geração de documentos XML através da serialização de classes no Framework.

Estes e outros conceitos e exemplos serão dados neste artigo que também mostra uma utilização bem particular com o MVC.

Os atributos na linguagem C# e no .NET Framework são uma maneira de se acrescentar dados sobre um assembly (executável ou class library), uma classe, um método e outros elementos da linguagem, de uma maneira declarativa, ou seja, diretamente no código. Entre os muitos dados que podem ser acrescentados estão URLs relacionadas com o projeto, tópicos de documentação. Também são acrescentadas informações auto descritivas de componentes e também dados para serem recuperados via reflection durante a execução.

Entre as utilizações mais tradicionais da utilização dos atributos estão:

· Informações sobre o assembly;

· Informações sobre classes e métodos;

· Serialização;

· Atribuição de permissões de segurança;

· Identificação de tipos especiais de classes e métodos;

· Definição de constraints para propriedades usadas em classes para armazenamento de dados.

Os atributos são de vários tipos. Um uso bem típico é a definição dos dados do assembly. Observe a Listagem 1 que mostra os atributos padrão gerados pelo Visual Studio.

Listagem 1. Atributos de Assembly

      1 using System.Reflection;
      2 using System.Runtime.CompilerServices;
      3 using System.Runtime.InteropServices;
      4 
      5 // General Information about an assembly is controlled through the following 
      6 // set of attributes. Change these attribute values to modify the information
      7 // associated with an assembly.
      8 [assembly: AssemblyTitle("dynamicDemoData")]
      9 [assembly: AssemblyDescription("")]
     10 [assembly: AssemblyConfiguration("")]
     11 [assembly: AssemblyCompany("")]
     12 [assembly: AssemblyProduct("dynamicDemoData")]
     13 [assembly: AssemblyCopyright("Copyright ©  2011")]
     14 [assembly: AssemblyTrademark("")]
     15 [assembly: AssemblyCulture("")]
     16 
     17 // Setting ComVisible to false makes the types in this assembly not visible 
     18 // to COM components.  If you need to access a type in this assembly from 
     19 // COM, set the ComVisible attribute to true on that type.
     20 [assembly: ComVisible(false)]
     21 
     22 // The following GUID is for the ID of the typelib if this project is exposed to COM
     23 [assembly: Guid("c815295a-4ac0-483f-908d-4fb50d2a0856")]
     24 
     25 // Version information for an assembly consists of the following four values:
     26 //
     27 //      Major Version
     28 //      Minor Version 
     29 //      Build Number
     30 //      Revision
     31 //
     32 // You can specify all the values or you can default the Build and Revision Numbers 
     33 // by using the '*' as shown below:
     34 // [assembly: AssemblyVersion("1.0.*")]
     35 [assembly: AssemblyVersion("1.0.0.0")]
     36 [assembly: AssemblyFileVersion("1.0.0.0")]

Essa listagem corresponde ao arquivo AssemblyInfo.cs que pode ser encontrado nos projetos do Visual Studio na pasta Properties. Os dados deste arquivo oferecem informações sobre o executável e tanto podem ser editadas manualmente como também alteradas via editor de propriedades do projeto (menu Project > Properties do Visual Studio).

No C# a sintaxe básica pra os atributos é colocar estes entre colchetes sobre o elemento que se deseja definir os valores. Um atributo pode ser simples, como por exemplo, o atributo que define uma classe como passível de serialização:

 [Serializable]
  public class foo
  {
    ...
  }
"

A exibição deste artigo foi interrompida :(
Este post está disponível para assinantes MVP

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?