Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Estrutura CustomAttributeTypedArgument

Representa um argumento de um atributo personalizado no contexto somente de reflexão ou um elemento de um argumento de matriz.

Namespace:  System.Reflection
Assembly:  mscorlib (em mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct CustomAttributeTypedArgument

O tipo CustomAttributeTypedArgument expõe os membros a seguir.

  NomeDescrição
Método públicoCustomAttributeTypedArgument(Object)Inicializa uma nova instância da CustomAttributeTypedArgument a classe com o valor especificado.
Método públicoCustomAttributeTypedArgument(Type, Object)Inicializa uma nova instância da CustomAttributeTypedArgument a classe com o valor e o tipo especificado.
Superior

  NomeDescrição
Propriedade públicaCom suporte em .NET para aplicativos da Windows StoreArgumentTypeObtém o tipo do argumento ou do elemento da matriz de argumento.
Propriedade públicaCom suporte em .NET para aplicativos da Windows StoreValueObtém o valor do argumento para um argumento simple ou de um elemento de um argumento de matriz; Obtém uma coleção de valores para um argumento de matriz.
Superior

  NomeDescrição
Método públicoEqualsIndica se esta instância e oobjeto especificado são iguais. (Substitui ValueType.Equals(Object).)
Método públicoGetHashCode Retorna o hash code para essa instância. (Substitui ValueType.GetHashCode().)
Método públicoCom suporte em .NET para aplicativos da Windows StoreGetType Obtém o Type da instância atual. (Herdado de Object.)
Método públicoToStringRetorna uma seqüência de caracteres consistindo em uma representação de seqüência de caracteres do valor de argumento, o sinal de igual e o nome do argumento. (Substitui ValueType.ToString().)
Superior

  NomeDescrição
Operador públicoMembro estáticoEqualityTesta se dois CustomAttributeTypedArgument estruturas são equivalentes.
Operador públicoMembro estáticoInequalityTesta se dois CustomAttributeTypedArgument estruturas são diferentes.
Superior

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

O CustomAttributeNamedArgument estrutura é usada pelo CustomAttributeData classe para fornecer acesso para o tipo e valor de um argumento posicional especificado para uma instância de atributo personalizado, sem executar o construtor de atributo. Ele também fornece acesso para o tipo e valor de um argumento nomeado sem executar o código da propriedade correspondente do tipo de atributo personalizado.

Os tipos e valores de todos os argumentos posicionais e nomeados de uma instância de atributo são fornecidos por CustomAttributeTypedArgument estruturas. Atributos posicionais retornados pelo CustomAttributeData.ConstructorArguments propriedade diretamente são representados por CustomAttributeTypedArgument estruturas, mas os argumentos nomeados retornados pela CustomAttributeData.NamedArguments propriedade são representados por CustomAttributeNamedArgument estruturas; Para obter o CustomAttributeTypedArgument estrutura para um argumento nomeado, use o CustomAttributeNamedArgument.TypedValue propriedade.

Se um argumento for uma matriz de valores, o Value propriedade da CustomAttributeTypedArgument que representa o argumento retorna um genérico ReadOnlyCollection<T> de CustomAttributeTypedArgument objetos. Cada CustomAttributeTypedArgument objeto da coleção representa o elemento correspondente da matriz.

Para criar instâncias da CustomAttributeData da classe, use o staticGetCustomAttributes o método de fábrica.

O exemplo a seguir define um atributo personalizado com quatro construtores e quatro propriedades. Duas propriedades são somente leitura e são definidas usando os parâmetros de posição dos construtores. As duas propriedades são leitura/gravação e pode ser argumentos nomeado do conjunto usando somente. Uma propriedade posicional é uma matriz de seqüências de caracteres e uma propriedade nomeada é uma matriz de inteiros.

O atributo é aplicado ao assembly, para um tipo declarado no assembly, para um método do tipo e para um parâmetro do método. Construtores diferentes são usados para esses casos. Quando executado, o assembly carrega próprio no contexto somente de reflexão e exibe os atributos personalizados.

O atributo que é 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:
*/


.NET Framework

Com suporte em: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Com suporte em: 4, 3.5 SP1

.NET para aplicativos da Windows Store

Com suporte em: Windows 8

.NET para aplicativos do Windows Phone

Com suporte em: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Função Server Core sem suporte), Windows Server 2008 R2 (Função Server Core com suporte com o SP1 ou posterior, Itanium sem suporte)

O .NET Framework não oferece suporte a todas as versões de cada plataforma. Para obter uma lista das versões com suporte, consulte Requisitos do sistema do .NET Framework.

Quaisquer membros estático (Shared no Visual Basic) públicos deste tipo são thread-safe. Não há garantia de que qualquer membro de instância seja thread-safe.

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft