CustomAttributeNamedArgument Estructura

Definición

Espacio de nombres:

System.Reflection

Ensamblados:

netstandard.dll, System.Runtime.dll

Source:

CustomAttributeNamedArgument.cs

Representa un argumento con nombre de un atributo personalizado en el contexto de solo reflexión.

C#

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

Herencia

Object

ValueType

CustomAttributeNamedArgument

Implementaciones

IEquatable<CustomAttributeNamedArgument>

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 información sobre los atributos personalizados que se aplicaron a él y al tipo y a los miembros que contiene.

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 CustomAttributeNamedArgumentCustomAttributeData para proporcionar acceso a un argumento con nombre especificado para una instancia de atributo personalizado, sin ejecutar el código de la propiedad correspondiente del tipo de atributo personalizado. La propiedad TypedValue devuelve una estructura CustomAttributeTypedArgument que contiene el tipo y el valor del argumento con nombre.

Importante

Si un argumento se denomina o posicional, debe tener acceso a su tipo y valor mediante la estructura CustomAttributeTypedArgument.

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

Constructores

CustomAttributeNamedArgument(MemberInfo, CustomAttributeTypedArgument)	Inicializa una nueva instancia de la clase CustomAttributeNamedArgument, que representa el campo o la propiedad especificados del atributo personalizado y especifica un objeto CustomAttributeTypedArgument que describe el tipo y el valor del campo o la propiedad.
CustomAttributeNamedArgument(MemberInfo, Object)	Inicializa una nueva instancia de la clase CustomAttributeNamedArgument, que representa el campo o la propiedad especificados del atributo personalizado y especifica el valor del campo o la propiedad.

Propiedades

IsField	Obtiene un valor que indica si el argumento con nombre es un campo.
MemberInfo	Obtiene el miembro de atributo que se usaría para establecer el argumento con nombre.
MemberName	Obtiene el nombre del miembro de atributo que se usaría para establecer el argumento con nombre.
TypedValue	Obtiene una estructura CustomAttributeTypedArgument que se puede usar para obtener el tipo y el valor del argumento con nombre actual.

Métodos

Equals(CustomAttributeNamedArgument)	Indica si la instancia actual es igual a otra instancia del mismo tipo.
Equals(Object)	Devuelve un valor que indica si esta instancia es igual a un objeto especificado.
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(CustomAttributeNamedArgument, CustomAttributeNamedArgument)	Comprueba si dos estructuras CustomAttributeNamedArgument son equivalentes.
Inequality(CustomAttributeNamedArgument, CustomAttributeNamedArgument)	Comprueba si dos estructuras CustomAttributeNamedArgument son diferentes.

Se aplica a

Consulte también

• CustomAttributeData
• CustomAttributeTypedArgument
• ReflectionOnlyLoad