Metadados (CLI) - Metadata (CLI)

Metadados , na Common Language Infrastructure (CLI), referem-se a certas estruturas de dados incorporadas ao código Common Intermediate Language (CIL) que descreve a estrutura de alto nível do código. Os metadados descrevem todas as classes e membros da classe que são definidos no assembly, e as classes e membros da classe que o assembly atual chamará de outro assembly. Os metadados de um método contêm a descrição completa do método, incluindo a classe (e o assembly que contém a classe), o tipo de retorno e todos os parâmetros do método .

Um compilador de linguagem CLI irá gerar os metadados e armazená-los no assembly que contém o CIL . Quando o tempo de execução executa CIL, ele verifica se os metadados do método chamado são iguais aos metadados armazenados no método de chamada. Isso garante que um método só possa ser chamado com o número exato de parâmetros e os tipos de parâmetros corretos.

A plataforma de aplicativo do Windows Runtime , presente no Windows 8 e no Windows Phone 8 , usa o formato de metadados CLI para descrever interfaces de componentes para código escrito em qualquer uma das linguagens de programação com suporte . Uma diferença no uso do Common Language Runtime é que um assembly normalmente não contém nenhuma instrução CIL.

Atributos

Os desenvolvedores podem adicionar metadados a seus códigos por meio de atributos . Existem dois tipos de atributos, atributos personalizados e pseudo-personalizados, e para o desenvolvedor eles têm a mesma sintaxe . Atributos no código são mensagens para o compilador gerar metadados. Em CIL, metadados, como modificadores de herança, modificadores de escopo e quase tudo que não seja opcodes ou streams, também são chamados de atributos.

Um atributo personalizado é uma classe regular que herda da Attribute classe. Um atributo personalizado pode ser usado em qualquer método, propriedade, classe ou conjunto inteiro com a sintaxe: como em: [AttributeName(optional parameter, optional name=value pairs)]

[Custom]
[Custom(1)]
[Custom(1, Comment="yes")]

Os atributos customizados são usados ​​extensivamente pelo CLI. O Windows Communication Framework usa atributos para definir contratos de serviço, ASP.NET os usa para expor métodos como serviços da web , LINQ to SQL os usa para definir o mapeamento de classes para o esquema relacional subjacente , Visual Studio os usa para agrupar propriedades de um objeto , o desenvolvedor da classe indica a categoria para a classe do objeto aplicando o [Category] atributo personalizado. Os atributos personalizados são interpretados pelo código do aplicativo e não pelo CLR. Quando o compilador vê um atributo personalizado, ele gera metadados personalizados que não são reconhecidos pelo CLR. O desenvolvedor deve fornecer código para ler os metadados e agir sobre eles. Como exemplo, o atributo mostrado no exemplo pode ser tratado pelo código:

class CustomAttribute : Attribute
{
   private int paramNumber = 0;
   private string comment = "";

   public CustomAttribute() { }
   public CustomAttribute(int num) { paramNumber = num; }

   public String Comment
   {
      set { comment = value; }
   }
}

O nome da classe é mapeado para o nome do atributo. O compilador Visual C # adiciona automaticamente a string " Attribute " no final de qualquer nome de atributo. Conseqüentemente, todo nome de classe de atributo deve terminar com esta string, mas é legal definir um atributo sem o Attribute -suffix. Ao afixar um atributo a um item, o compilador procurará tanto o nome literal quanto o nome Attribute adicionado ao final, i. e. se você fosse escrever, [Custom] o compilador iria procurar por Custom e CustomAttribute . Se ambos existirem, o compilador falhará. O atributo pode ser prefixado com " @ " se você não quiser correr o risco de ambiguidade, portanto, a escrita [@Custom] não corresponderá CustomAttribute . Usar o atributo invoca o construtor da classe. Construtores sobrecarregados são suportados. Os pares nome-valor são mapeados para propriedades, o nome denota o nome da propriedade e o valor fornecido é definido pela propriedade.

Às vezes, há ambigüidade em relação ao que você está atribuindo ao atributo. Considere o seguinte código:

[Orange]
public int ExampleMethod(string input)
{
    //method body goes here
}

O que foi marcado como laranja? É o ExampleMethod , seu valor de retorno ou talvez a montagem inteira? Nesse caso, o compilador assumirá o padrão e tratará o atributo como afixado ao método. Caso não seja isso o que se pretendia, ou se o autor deseja esclarecer seu código, um alvo de atributo pode ser especificado. A escrita [return: Orange] marcará o valor de retorno como laranja, [assembly: Orange] marcará toda a montagem. Os alvos válidos são assembly , field , event , method , module , param , property , return e type .

Um atributo pseudo-customizado é usado apenas como atributos customizados regulares, mas eles não têm um manipulador customizado; em vez disso, o compilador tem consciência intrínseca dos atributos e lida com o código marcado com tais atributos de maneira diferente. Atributos como Serializable e Obsolete são implementados como atributos pseudo-personalizados. Atributos pseudo-personalizados nunca devem ser usados ​​pelo ILAsm , pois ele tem uma sintaxe adequada para descrever os metadados.

Armazenamento de metadados

Os assemblies contêm tabelas de metadados. Essas tabelas são descritas pela especificação CIL. As tabelas de metadados terão zero ou mais entradas e a posição de uma entrada determina seu índice. Quando o código CIL usa metadados, ele o faz por meio de um token de metadados. Este é um valor de 32 bits em que os 8 bits principais identificam a tabela de metadados apropriada e os 24 bits restantes fornecem o índice dos metadados na tabela. O Framework SDK contém um exemplo chamado metainfo que listará as tabelas de metadados em um assembly; no entanto, essas informações raramente são úteis para um desenvolvedor. Os metadados em um assembly podem ser exibidos usando a ferramenta ILDASM fornecida pelo .NET Framework SDK.

No padrão CIL, os metadados são definidos na forma ILAsm (linguagem assembly), uma forma de representação em disco para armazenamento e uma forma que é embutida em assemblies do formato Portable Executable (PE, .exe ou .dll). O formulário PE é baseado no formulário em disco.

Reflexão

Reflexão é a API usada para ler metadados CLI. A API de reflexão fornece uma visão lógica dos metadados em vez da visão literal fornecida por ferramentas como metainfo. A reflexão na versão 1.1 do .NET framework pode ser usada para inspecionar as descrições das classes e seus membros e invocar métodos. No entanto, ele não permite acesso em tempo de execução ao CIL para um método. A versão 2.0 do framework permite a obtenção do CIL para um método.

Outras ferramentas de metadados

Além do System.Reflection namespace, outras ferramentas também estão disponíveis que podem ser usadas para lidar com metadados. O Microsoft .NET Framework fornece uma biblioteca de manipulação de metadados CLR que é implementada em código nativo . Ferramentas de terceiros para recuperar e manipular metadados incluem PostSharp e Mono Cecil também podem ser usadas.

Veja também

• Anotação Java

Referências