Curso de C#: Lição 16: Usando Atributos

Esta lição explica como usar C # atributos. Os nossos objectivos são os seguintes: Entenda o que são atributos e por isso eles são usados Aplicar diferentes atributos com vários parâmetros ou não Use montagem, membro tipo, nível e tipo de atributos

Por | @oficinadanet Programação
Esta lição explica como usar C # atributos. Os nossos objectivos são os seguintes:
  • Entenda o que são atributos e por isso eles são usados
  • Aplicar diferentes atributos com vários parâmetros ou não
  • Use montagem, membro tipo, nível e tipo de atributos

Atributos Porquê?


Atributos são elementos que permitem que você adicione declarativa informações para seus programas. Esta informação declarativa é utilizada para vários fins durante o tempo de execução e pode ser usado em tempo de desenvolvimento pela aplicação ferramentas de desenvolvimento. Por exemplo, existem atributos como DllImportAttribute que permitem que um programa para se comunicar com o Win32 bibliotecas. Outro atributo, ObsoleteAttribute, causas compilar um aviso a tempo para aparecer, deixando o dono da obra sabemos que um método deve deixar de ser utilizados. Ao construir aplicativos Windows formas, existem vários atributos que permitem visual componentes a arrastar-n-caiu para uma forma visual construtor e têm as suas propriedades informações aparecem na grade. Atributos também são usados extensivamente para garantia. NET assembléias, forçando chamando código para ser avaliado contra o pré-definidas de segurança constrangimentos.Estas são apenas algumas descrições de como os atributos são utilizados em programas C #.

A razão é porque os atributos são necessários muitos dos serviços que prestam seria muito difícil de realizar com o código normal. Você vê, os atributos acrescentar o que é chamado metadados para seus programas. Quando o seu programa é compilado, ele cria um arquivo chamado uma assembléia, que é normalmente um executável ou DLL biblioteca. Assembleias são auto-descrever metadados porque têm escrito para eles quando eles estão compilados. Através de um processo conhecido como reflexão, um programa de atributos podem ser recuperadas a partir de sua montagem metadados. Atributos são classes que pode ser escrito em C # e usadas para decorar o seu código com informações declarativas.Este é um conceito muito poderoso, pois significa que o seu pode aumentar a sua língua, criando personalizado com atributos sintaxe declarativa.

Este tutorial irá mostrar como a utilização de pré-existente atributos programas em C #. Compreender os conceitos e como utilizar alguns atributos, irá ajudar a encontrar a infinidade de outros pré-existentes nos atributos. NET classe bibliotecas e utilizá-las também.

Atributo Básico


Atributos são geralmente aplicadas fisicamente na frente do tipo e modelo membro declarações. Eles são declaradas com colchetes, "[" e "]", envolvendo a atribuir tais como as seguintes ObsoleteAttribute atributo:

[ObsoleteAttribute]

O "atributo" parte do nome do atributo é facultativo. Portanto, a seguir é equivalente ao atributo acima:

[Obsolete] [Obsoleto]

Você verá que o atributo é declarado apenas com o nome do atributo, cercado por colchetes. Muitos têm atributos parâmetro listas, que permite inclusão de informações adicionais que personaliza um programa ainda mais. A listagem 16,1 mostra várias maneiras de como usar o atributo ObsoleteAttribute.
Listagem 16-1.Como usar o Atributos: BasicAttributeDemo.cs
 using System;

class BasicAttributeDemo
{
    [Obsolete]
    public void MyFirstdeprecatedMethod()
    {
        Console.WriteLine("Called MyFirstdeprecatedMethod().");
    }

    [ObsoleteAttribute]
    public void MySecondDeprecatedMethod()
    {
        Console.WriteLine("Called MySecondDeprecatedMethod().");
    }

    [Obsolete("You shouldn't use this method anymore.")]
    public void MyThirdDeprecatedMethod()
    {
        Console.WriteLine("Called MyThirdDeprecatedMethod().");
    }

    // make the program thread safe for COM
    [STAThread]
    static void Main(string[] args)
    {
        BasicAttributeDemo attrDemo = new BasicAttributeDemo();

        attrDemo.MyFirstdeprecatedMethod();
        attrDemo.MySecondDeprecatedMethod();
        attrDemo.MyThirdDeprecatedMethod();
    }
}


Examinando o código na listagem 16-1 revela que o ObsoleteAttribute atributo foi utilizada algumas maneiras diferentes. O primeiro uso apareceram no MyFirstdeprecatedMethod () e com o segundo método uso apareceu no MySecondDeprecatedMethod () método como segue:

     [Obsolete]
    public void MyFirstdeprecatedMethod()
    ...
    [ObsoleteAttribute]
    public void MySecondDeprecatedMethod()
    ...


A única diferença entre os dois atributos é que MySecondDeprecatedMethod () contém o método "atributo" no atributo declaração. Os resultados de ambos os atributos são exactamente os mesmos. Atributos também podem ter parâmetros, como mostra a seguinte declaração:

     [Obsolete("You shouldn't use this method anymore.")]
    public void MyThirdDeprecatedMethod()
    ...


Isso acrescenta personalizados para o comportamento ObsoleteAttribute atributo que produz resultados diferentes dos outros ObsoleteAttribute atributo declarações. Os resultados de todas as três ObsoleteAttribute atributos são mostrados abaixo. Estas são as advertências que são emitidos pelo compilador C # quando o programa é compilado:

>csc BasicAttributeDemo.cs
Microsoft (R) Visual C# .NET Compiler version 7.10.2292.4
for Microsoft (R) .NET Framework version 1.1.4322
Copyright (C) Microsoft Corporation 2001-2002. All rights reserved.

BasicAttributeDemo.cs(29,3): warning CS0612:
'BasicAttributeDemo.MyFirstdeprecatedMethod()' is obsolete
BasicAttributeDemo.cs(30,3): warning CS0612:
'BasicAttributeDemo.MySecondDeprecatedMethod()' is obsolete
BasicAttributeDemo.cs(31,3): warning CS0618:
'BasicAttributeDemo.MyThirdDeprecatedMethod()' is obsolete: 'You
shouldn't use this method anymore.'


Como você pode ver, o atributo ObsoleteAttribute causou a MyThirdDeprecatedMethod () método de emitir a mensagem de que era um parâmetro para o ObsoleteAttribute atributo desse método no código. The other attributes simply emitted standard warnings. Os outros atributos simplesmente emitidas advertências padrão.

16-1 lista contém também um outro atributo é provável que você vê, o atributo STAThreadAttribute. Você vai ver muitas vezes este atributo aplicada ao método main (), C #, indicando que este programa deverá comunicar com código não gerenciado COM usando o único Filetagem apartamento. É geralmente seguro para usar este atributo o tempo todo, pois nunca se sabe quando um partido 3o biblioteca você estiver usando vai ser a comunicação com COM. O trecho seguinte mostra como usar o atributo STAThreadAttribute:

     [STAThread]
    static void Main(string[] args)
    ...



Parâmetros do Atributo


Atributos muitas vezes têm parâmetros que permitem personalização. Existem dois tipos de parâmetros que pode ser usada em atributos, posicional e nomeada. Parâmetros posicionais são utilizados quando o atributo criador deseja que os parâmetros a serem exigidos. No entanto, esta não é uma dura e rápida, porque o Estado tem um atributo ObsoleteAttribute posicionais segundo parâmetro chamado erro de tipo bool que podemos omitir tal como demonstrado na listagem 16-1. Esse atributo poderia ter sido escrito com o segundo parâmetro posicional para forçar um compilador erro em vez de apenas uma advertência do seguinte modo:

     [Obsolete("You shouldn't use this method anymore.", true)]
    public void MyThirdDeprecatedMethod()
    ...


A diferença entre os parâmetros posicionais e nomeada são os parâmetros que são especificados parâmetros nomeados com o nome do parâmetro e estão sempre facultativa. O DllImportAttribute é um atributo é provável que você veja que tanto tem chamado posicional e atributos (Listing 16-2).

Listagem 16-2. Usando parâmetros posicionais e nomeada atributo: AttributeParamsDemo.cs
 using System;
using System.Runtime.InteropServices;

class AttributeParamsDemo
{
    [DllImport("User32.dll", EntryPoint="MessageBox")]
    static extern int MessageDialog(int hWnd, string msg, string caption, int msgType);

    [STAThread]
    static void Main(string[] args)
    {
        MessageDialog(0, "MessageDialog Called!", "DllImport Demo", 0);
    }
}


O atributo DllImportAttribute em uma listagem 16-2 tem um parâmetro posicional, "User32.dll", e nomeado um parâmetro, EntryPoint = "MessageBox". Parâmetros posicionais são sempre chamado antes de quaisquer parâmetros especificados. Quando há parâmetros nomeados, eles podem aparecer em qualquer ordem. Isto é porque estão marcados com o nome do parâmetro, como é o caso das DllImportAttribute atributo, EntryPoint = "MessageBox". Uma vez que o objectivo desta lição é a de explicar como usar atributos em geral, não vou entrar em pormenores sobre o DllImportAttribute atributo, que tem extra parâmetros que requerem conhecimentos de Win32 e outros detalhes que não são relacionados a esta lição. Muitos outros atributos podem ser usados tanto com parâmetros posicionais e nomeada.

Atributo Metas


Os atributos mostrados até agora têm sido aplicados aos métodos, mas há muitos outros elementos que a linguagem C # você pode usar com atributos. 16-1 tabela descreve a linguagem C # elementos que podem ser aplicadas aos atributos. Eles são formalmente chamado atributo "alvos".

Curso de C#: Lição 16: Usando Atributos

Sempre há ambiguidade na forma como um atributo é aplicado, você pode adicionar uma especificação alvo para garantir o direito língua elemento é decorado adequadamente. O CLS é o conjunto de normas que permitam diferentes. NET línguas para comunicar. Atributo metas são definidas pelo prefixing o nome do atributo com o alvo e separando-a com um dois pontos (:). Listando 16-3 mostra como utilizar o atributo.

Listagem 16-3. Usando parâmetros posicionais e nomeada atributo: AttributeTargetdemo.cs
 using System;

[assembly:CLSCompliant(true)]

public class AttributeTargetdemo
{
    public void NonClsCompliantMethod(uint nclsParam)
    {
        Console.WriteLine("Called NonClsCompliantMethod().");
    }

    [STAThread]
    static void Main(string[] args)
    {
        uint myUint = 0;

        AttributeTargetdemo tgtdemo = new AttributeTargetdemo();

        tgtdemo.NonClsCompliantMethod(myUint);
    }
}


O código na listagem 16-3 compilador irá gerar um aviso por causa do tipo uint parâmetro declarado no NonClsCompliantMethod () método. Se você mudar o atributo para CLSCompliantAttribute falso ou alterar o tipo do NonClsCompliantMethod () para um método CLS compliant tipo, tais como int, o programa irá compilar sem avisos.

O ponto sobre Listing 16-3 é a de que o CLSCompliantAttribute atributo é decorado com um atributo alvo de "montagem". Isso faz todos os membros desta assembleia de ser avaliados de acordo com o atributo CLSCompliantAttribute configuração.Para limitar o âmbito de aplicação da CLSCompliantAttribute, aplicá-la, quer ao AttributeTargetdemo classe ou NonClsCompliantMethod () método directo.

Resumo


Os atributos são elementos que a linguagem C # decorar programa com elementos adicionais metadados que descreve o programa. Este metadados é então avaliado em diferentes locais, tais como tempo de execução ou concepção tempo para vários fins. Os exemplos nesta lição mostrou como a ObsoleteAttribute atributo poderia ser usado para gerar tempo de compilação avisos de código depreciado. Através da aplicação do DllImportAttribute atributo, você poderia ver como se aplica tanto aos parâmetros posicionais e nomeada para um atributo. Atributos também podem ser usadas para decorar diversos tipos diferentes elementos do programa com um descritor alvo. O exemplo a CLSCompliantAttribute atributo aplicado a todo um conjunto. No entanto, ela poderia ter sido igualmente aplicado a programas diferentes elementos aplicáveis a meta descritores de limitar o seu alcance.

Texto automaticamente traduzido de: http://www.csharp-station.com/Tutorials/Lesson16.aspx

Mais sobre: c# curso_c_sharp
Share Tweet
Comentários
Carregar comentários
Destaquesver tudo