Ler em inglês

Compartilhar via


CustomAttributeData Classe

Definição

Fornece acesso aos dados de atributo personalizado para assemblies, módulos, tipos, membros e parâmetros que são carregados no contexto exclusivo de reflexão.

public class CustomAttributeData
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class CustomAttributeData
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class CustomAttributeData
Herança
CustomAttributeData
Atributos

Exemplos

O exemplo a seguir define um atributo personalizado com quatro construtores e quatro propriedades. Duas das propriedades são somente leitura e são definidas usando os parâmetros posicionais dos construtores. As outras duas propriedades são leitura/gravação e só podem ser definidas usando argumentos nomeados. Uma propriedade posicional é uma matriz de cadeias de caracteres e uma propriedade nomeada é uma matriz de inteiros.

O atributo é aplicado ao assembly, a um tipo declarado no assembly, para um método do tipo e a um parâmetro do método. Construtores diferentes são usados para esses casos. Quando executado, o assembly carrega-se no contexto somente reflexão e exibe informações sobre os atributos personalizados que foram aplicados a ele e ao tipo e membros que ele contém.

O atributo aplicado ao tipo demonstra as propriedades da matriz, com argumentos posicionais e nomeados.

using System;
using System.Reflection;
using System.Collections.Generic;
using System.Collections.ObjectModel;

// The example attribute is applied to the assembly.
[assembly:Example(ExampleKind.ThirdKind, Note="This is a note on the assembly.")]

// An enumeration used by the ExampleAttribute class.
public enum ExampleKind
{
    FirstKind,
    SecondKind,
    ThirdKind,
    FourthKind
};

// An example attribute. The attribute can be applied to all
// targets, from assemblies to parameters.
//
[AttributeUsage(AttributeTargets.All)]
public class ExampleAttribute : Attribute
{
    // Data for properties.
    private ExampleKind kindValue;
    private string noteValue;
    private string[] arrayStrings;
    private int[] arrayNumbers;

    // Constructors. The parameterless constructor (.ctor) calls
    // the constructor that specifies ExampleKind and an array of
    // strings, and supplies the default values.
    //
    public ExampleAttribute(ExampleKind initKind, string[] initStrings)
    {
        kindValue = initKind;
        arrayStrings = initStrings;
    }
    public ExampleAttribute(ExampleKind initKind) : this(initKind, null) {}
    public ExampleAttribute() : this(ExampleKind.FirstKind, null) {}

    // Properties. The Note and Numbers properties must be read/write, so they
    // can be used as named parameters.
    //
    public ExampleKind Kind { get { return kindValue; }}
    public string[] Strings { get { return arrayStrings; }}
    public string Note
    {
        get { return noteValue; }
        set { noteValue = value; }
    }
    public int[] Numbers
    {
        get { return arrayNumbers; }
        set { arrayNumbers = value; }
    }
}

// The example attribute is applied to the test class.
//
[Example(ExampleKind.SecondKind,
         new string[] { "String array argument, line 1",
                        "String array argument, line 2",
                        "String array argument, line 3" },
         Note="This is a note on the class.",
         Numbers = new int[] { 53, 57, 59 })]
public class Test
{
    // The example attribute is applied to a method, using the
    // parameterless constructor and supplying a named argument.
    // The attribute is also applied to the method parameter.
    //
    [Example(Note="This is a note on a method.")]
    public void TestMethod([Example] object arg) { }

    // Main() gets objects representing the assembly, the test
    // type, the test method, and the method parameter. Custom
    // attribute data is displayed for each of these.
    //
    public static void Main()
    {
        Assembly asm = Assembly.ReflectionOnlyLoad("Source");
        Type t = asm.GetType("Test");
        MethodInfo m = t.GetMethod("TestMethod");
        ParameterInfo[] p = m.GetParameters();

        Console.WriteLine("\r\nAttributes for assembly: '{0}'", asm);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(asm));
        Console.WriteLine("\r\nAttributes for type: '{0}'", t);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(t));
        Console.WriteLine("\r\nAttributes for member: '{0}'", m);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(m));
        Console.WriteLine("\r\nAttributes for parameter: '{0}'", p);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(p[0]));
    }

    private static void ShowAttributeData(
        IList<CustomAttributeData> attributes)
    {
        foreach( CustomAttributeData cad in attributes )
        {
            Console.WriteLine("   {0}", cad);
            Console.WriteLine("      Constructor: '{0}'", cad.Constructor);

            Console.WriteLine("      Constructor arguments:");
            foreach( CustomAttributeTypedArgument cata
                in cad.ConstructorArguments )
            {
                ShowValueOrArray(cata);
            }

            Console.WriteLine("      Named arguments:");
            foreach( CustomAttributeNamedArgument cana
                in cad.NamedArguments )
            {
                Console.WriteLine("         MemberInfo: '{0}'",
                    cana.MemberInfo);
                ShowValueOrArray(cana.TypedValue);
            }
        }
    }

    private static void ShowValueOrArray(CustomAttributeTypedArgument cata)
    {
        if (cata.Value.GetType() == typeof(ReadOnlyCollection<CustomAttributeTypedArgument>))
        {
            Console.WriteLine("         Array of '{0}':", cata.ArgumentType);

            foreach (CustomAttributeTypedArgument cataElement in
                (ReadOnlyCollection<CustomAttributeTypedArgument>) cata.Value)
            {
                Console.WriteLine("             Type: '{0}'  Value: '{1}'",
                    cataElement.ArgumentType, cataElement.Value);
            }
        }
        else
        {
            Console.WriteLine("         Type: '{0}'  Value: '{1}'",
                cata.ArgumentType, cata.Value);
        }
    }
}

/* This code example produces output similar to the following:

Attributes for assembly: 'source, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'
   [System.Runtime.CompilerServices.CompilationRelaxationsAttribute((Int32)8)]
      Constructor: 'Void .ctor(Int32)'
      Constructor arguments:
         Type: 'System.Int32'  Value: '8'
      Named arguments:
   [System.Runtime.CompilerServices.RuntimeCompatibilityAttribute(WrapNonExceptionThrows = True)]
      Constructor: 'Void .ctor()'
      Constructor arguments:
      Named arguments:
         MemberInfo: 'Boolean WrapNonExceptionThrows'
         Type: 'System.Boolean'  Value: 'True'
   [ExampleAttribute((ExampleKind)2, Note = "This is a note on the assembly.")]
      Constructor: 'Void .ctor(ExampleKind)'
      Constructor arguments:
         Type: 'ExampleKind'  Value: '2'
      Named arguments:
         MemberInfo: 'System.String Note'
         Type: 'System.String'  Value: 'This is a note on the assembly.'

Attributes for type: 'Test'
   [ExampleAttribute((ExampleKind)1, new String[3] { "String array argument, line 1", "String array argument, line 2", "String array argument, line 3" }, Note = "This is a note on the class.", Numbers = new Int32[3] { 53, 57, 59 })]
      Constructor: 'Void .ctor(ExampleKind, System.String[])'
      Constructor arguments:
         Type: 'ExampleKind'  Value: '1'
         Array of 'System.String[]':
             Type: 'System.String'  Value: 'String array argument, line 1'
             Type: 'System.String'  Value: 'String array argument, line 2'
             Type: 'System.String'  Value: 'String array argument, line 3'
      Named arguments:
         MemberInfo: 'System.String Note'
         Type: 'System.String'  Value: 'This is a note on the class.'
         MemberInfo: 'Int32[] Numbers'
         Array of 'System.Int32[]':
             Type: 'System.Int32'  Value: '53'
             Type: 'System.Int32'  Value: '57'
             Type: 'System.Int32'  Value: '59'

Attributes for member: 'Void TestMethod(System.Object)'
   [ExampleAttribute(Note = "This is a note on a method.")]
      Constructor: 'Void .ctor()'
      Constructor arguments:
      Named arguments:
         MemberInfo: 'System.String Note'
         Type: 'System.String'  Value: 'This is a note on a method.'

Attributes for parameter: 'System.Object arg'
   [ExampleAttribute()]
      Constructor: 'Void .ctor()'
      Constructor arguments:
      Named arguments:
*/

Comentários

O código que está sendo examinado no contexto somente reflexão não pode ser executado, portanto, nem sempre é possível examinar atributos personalizados criando instâncias deles e examinando suas propriedades, usando métodos como Attribute.GetCustomAttributes, MemberInfo.GetCustomAttributese assim por diante. Se o código do tipo de atributo em si for carregado no contexto somente reflexão, ele não poderá ser executado.

A CustomAttributeData classe permite o exame de atributos personalizados no contexto somente reflexão fornecendo uma abstração para atributos. Os membros dessa classe podem ser usados para obter os argumentos posicionais e os argumentos nomeados do atributo. Use a ConstructorArguments propriedade para obter uma lista de CustomAttributeTypedArgument estruturas que representam os argumentos posicionais e use a NamedArguments propriedade para obter uma lista de CustomAttributeNamedArgument estruturas que representam os argumentos nomeados.

Observação

A CustomAttributeNamedArgument estrutura fornece apenas informações sobre a propriedade de atributo usada para obter e definir o valor do argumento. Para obter o tipo e o valor do argumento , use a CustomAttributeNamedArgument.TypedValue propriedade para obter uma CustomAttributeTypedArgument estrutura .

Quando você tiver uma CustomAttributeTypedArgument estrutura para um argumento, seja nomeado ou posicional, use a CustomAttributeTypedArgument.ArgumentType propriedade para obter o tipo e a CustomAttributeTypedArgument.Value propriedade para obter o valor.

Observação

Para um argumento de matriz, a CustomAttributeTypedArgument.Value propriedade retorna um genérico ReadOnlyCollection<T> de CustomAttributeTypedArgument objetos . Cada CustomAttributeTypedArgument objeto na coleção representa o elemento correspondente da matriz.

CustomAttributeData pode ser usado no contexto de execução, bem como no contexto somente reflexão. Por exemplo, talvez você queira evitar carregar o assembly que contém o código de um atributo personalizado. Usar a CustomAttributeData classe é diferente de usar métodos como Attribute.GetCustomAttributes:

  • As propriedades e os métodos de CustomAttributeData fornecem apenas os valores especificados para a instância de atributo, não a semântica do construtor. Por exemplo, um argumento de cadeia de caracteres de um atributo pode ser convertido internamente em alguma outra representação e retornado de forma canônica; ou uma propriedade pode ter efeitos colaterais quando o código de atributo real é executado.

  • As propriedades e os métodos de CustomAttributeData não permitem que você recupere os atributos personalizados herdados das classes base.

Para criar instâncias da CustomAttributeData classe , use os static métodos de fábrica (Shared no Visual Basic). GetCustomAttributes

Construtores

CustomAttributeData()

Inicializa uma nova instância da classe CustomAttributeData.

Propriedades

AttributeType

Obtém o tipo do atributo.

Constructor

Obtém um objeto ConstructorInfo que representa o construtor que teria inicializado o atributo personalizado.

ConstructorArguments

Obtém a lista de argumentos posicionais especificados para a instância de atributo representada pelo objeto CustomAttributeData.

NamedArguments

Obtém a lista de argumentos nomeados especificados para a instância de atributo representada pelo objeto CustomAttributeData.

Métodos

Equals(Object)

Retorna um valor que indica se essa instância é igual a um objeto especificado.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
GetCustomAttributes(Assembly)

Retorna uma lista de objetos CustomAttributeData que representam os dados sobre os atributos que foram aplicados ao assembly de destino.

GetCustomAttributes(MemberInfo)

Retorna uma lista de objetos CustomAttributeData que representam dados sobre os atributos que foram aplicados ao membro de destino.

GetCustomAttributes(Module)

Retorna uma lista de objetos CustomAttributeData que representam dados sobre os atributos que foram aplicados ao módulo de destino.

GetCustomAttributes(ParameterInfo)

Retorna uma lista de objetos CustomAttributeData que representam os dados sobre os atributos que foram aplicados ao parâmetro de destino.

GetHashCode()

Serve como uma função hash para um tipo particular.

GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
ToString()

Retorna uma representação de cadeia de caracteres do atributo personalizado.

ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)

Aplica-se a

Produto Versões
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

Confira também