CustomAttributeTypedArgument Estructura

Definición

Espacio de nombres:

System.Reflection

Ensamblados:

netstandard.dll, System.Runtime.dll

Source:

CustomAttributeTypedArgument.cs

Representa un argumento de un atributo personalizado en el contexto de solo reflexión o un elemento de un argumento de matriz.

C#

public readonly struct CustomAttributeTypedArgument : IEquatable<System.Reflection.CustomAttributeTypedArgument>

Herencia

Object

ValueType

CustomAttributeTypedArgument

Implementaciones

IEquatable<CustomAttributeTypedArgument>

Ejemplos

En el ejemplo siguiente se define un atributo personalizado con cuatro constructores y cuatro propiedades. Dos de las propiedades son de solo lectura y se establecen mediante los parámetros posicionales de los constructores. Las otras dos propiedades son de lectura y escritura y solo se pueden establecer mediante argumentos con nombre. Una propiedad posicional es una matriz de cadenas y una propiedad con nombre es una matriz de enteros.

El atributo se aplica al ensamblado, a un tipo declarado en el ensamblado, a un método del tipo y a un parámetro del método . Se usan constructores diferentes para estos casos. Cuando se ejecuta, el ensamblado se carga en el contexto de solo reflexión y muestra los atributos personalizados.

El atributo que se aplica al tipo muestra las propiedades de la matriz, con argumentos posicionales y con nombre.

C#

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:
*/

Comentarios

No se puede ejecutar el código que se está examinando en el contexto de solo reflexión, por lo que no siempre es posible examinar atributos personalizados mediante la creación de instancias de ellos y, a continuación, examinar sus propiedades, mediante métodos como Attribute.GetCustomAttributes, MemberInfo.GetCustomAttributes, etc. Si el código del propio tipo de atributo se carga en el contexto de solo reflexión, no se puede ejecutar.

La clase CustomAttributeData usa la estructura CustomAttributeNamedArgument para proporcionar acceso al tipo y el valor de un argumento posicional especificado para una instancia de atributo personalizado, sin ejecutar el constructor de atributos. También proporciona acceso al tipo y el valor de un argumento con nombre sin ejecutar el código de la propiedad correspondiente del tipo de atributo personalizado.

Las estructuras de CustomAttributeTypedArgument proporcionan los tipos y valores de todos los argumentos posicionales y con nombre de una instancia de atributo. Los atributos posicionales devueltos por la propiedad CustomAttributeData.ConstructorArguments se representan directamente mediante estructuras CustomAttributeTypedArgument, pero los argumentos con nombre devueltos por la propiedad CustomAttributeData.NamedArguments se representan mediante estructuras CustomAttributeNamedArgument; para obtener la estructura CustomAttributeTypedArgument de un argumento con nombre, use la propiedad CustomAttributeNamedArgument.TypedValue.

Si un argumento es una matriz de valores, la propiedad Value del CustomAttributeTypedArgument que representa el argumento devuelve un ReadOnlyCollection<T> genérico de CustomAttributeTypedArgument objetos. Cada objeto CustomAttributeTypedArgument de la colección representa el elemento correspondiente de la matriz.

Para crear instancias de la clase CustomAttributeData, use el método staticGetCustomAttributes factory.

Constructores

CustomAttributeTypedArgument(Object)	Inicializa una nueva instancia de la clase CustomAttributeTypedArgument con el valor especificado.
CustomAttributeTypedArgument(Type, Object)	Inicializa una nueva instancia de la clase CustomAttributeTypedArgument con el tipo y el valor especificados.

Propiedades

ArgumentType	Obtiene el tipo del argumento o del elemento de argumento de matriz.
Value	Obtiene el valor del argumento para un argumento simple o para un elemento de un argumento de matriz; obtiene una colección de valores para un argumento de matriz.

Métodos

Equals(CustomAttributeTypedArgument)	Indica si la instancia actual es igual a otra instancia del mismo tipo.
Equals(Object)	Indica si esta instancia y un objeto especificado son iguales.
GetHashCode()	Devuelve el código hash de esta instancia.
ToString()	Devuelve una cadena que consta del nombre del argumento, el signo igual y una representación de cadena del valor del argumento.

Operadores

Equality(CustomAttributeTypedArgument, CustomAttributeTypedArgument)	Comprueba si dos estructuras CustomAttributeTypedArgument son equivalentes.
Inequality(CustomAttributeTypedArgument, CustomAttributeTypedArgument)	Comprueba si dos estructuras CustomAttributeTypedArgument son diferentes.

Se aplica a

Consulte también

• CustomAttributeData
• CustomAttributeNamedArgument
• ReflectionOnlyLoad