CustomReflectionContext Clase

Definición

public ref class CustomReflectionContext abstract : System::Reflection::ReflectionContext

public abstract class CustomReflectionContext : System.Reflection.ReflectionContext

type CustomReflectionContext = class
    inherit ReflectionContext

Public MustInherit Class CustomReflectionContext
Inherits ReflectionContext

Herencia

Object

ReflectionContext

CustomReflectionContext

Derivado

System.ComponentModel.Composition.Registration.RegistrationBuilder

Ejemplos

En el ejemplo siguiente se demuestra cómo crear una subclase de CustomReflectionContext para agregar un atributo personalizado a todos los miembros de un tipo dado cuyos nombres comienzan con "To". Para ejecutar este código, péguelo en un proyecto de consola vacío y asegúrese de incluir una referencia a System.Reflection.Context.dll.

//A blank example attribute.
class myAttribute : Attribute
{
}

//Reflection context with custom rules.
class myCRC : CustomReflectionContext
{
    //Called whenever the reflection context checks for custom attributes.
           protected override IEnumerable<object> GetCustomAttributes(MemberInfo member, IEnumerable<object> declaredAttributes)
           {
               //Add example attribute to "To*" members.
               if (member.Name.StartsWith("To")) {
                   yield return new myAttribute();
               }
               //Keep existing attributes as well.
               foreach (var attr in declaredAttributes) yield return attr;
         }
}

class Program
{
    static void Main(string[] args)
    {
        myCRC mc = new myCRC();
        Type t = typeof(String);

        //A representation of the type in the default reflection context.
        TypeInfo ti = t.GetTypeInfo();

        //A representation of the type in the customized reflection context.
        TypeInfo myTI = mc.MapType(ti);

        //Display all the members of the type and their attributes.
        foreach (MemberInfo m in myTI.DeclaredMembers)
        {
           Console.WriteLine(m.Name + ":");
           foreach (Attribute cd in m.GetCustomAttributes())
           {
                Console.WriteLine(cd.GetType());
           }
        }

        Console.WriteLine();

        //The "ToString" member as represented in the default reflection context.
        MemberInfo mi1 = ti.GetDeclaredMethods("ToString").FirstOrDefault();

        //All the attributes of "ToString" in the default reflection context.
        Console.WriteLine("'ToString' Attributes in Default Reflection Context:");
        foreach (Attribute cd in mi1.GetCustomAttributes())
        {
            Console.WriteLine(cd.GetType());
        }

        Console.WriteLine();

        //The same member in the custom reflection context.
        mi1 = myTI.GetDeclaredMethods("ToString").FirstOrDefault();

        //All its attributes, for comparison.  myAttribute is now included.
        Console.WriteLine("'ToString' Attributes in Custom Reflection Context:");
        foreach (Attribute cd in mi1.GetCustomAttributes())
        {
            Console.WriteLine(cd.GetType());
        }

        Console.ReadLine();
    }
}

Comentarios

CustomReflectionContext proporciona una manera de agregar o quitar atributos personalizados de objetos de reflexión, o agregar propiedades ficticias a esos objetos, sin volver a implementar el modelo de reflexión completo. El valor predeterminado CustomReflectionContext simplemente envuelve los objetos de reflexión sin hacer ningún cambio, pero al crear subclases y sobrescribir los métodos pertinentes, puede añadir, quitar o cambiar los atributos que se aplican a cualquier parámetro o miembro reflejado, o añadir nuevas propiedades a un tipo reflejado.

Por ejemplo, supongamos que el código sigue la convención de aplicar un atributo determinado a los métodos de fábrica, pero ahora es necesario trabajar con código de terceros que carece de atributos. Puede usar CustomReflectionContext para especificar una regla para identificar los objetos que deben tener atributos y proporcionar los objetos con esos atributos cuando se ven desde el código.

Para usar CustomReflectionContext eficazmente, el código que usa los objetos reflejados debe admitir la noción de especificar un contexto de reflexión, en lugar de suponer que todos los objetos reflejados están asociados al contexto de reflexión en tiempo de ejecución. Muchos métodos de reflexión de .NET Framework proporcionan un ReflectionContext parámetro para este propósito.

Para modificar los atributos que se aplican a un parámetro o miembro reflejados, invalide el GetCustomAttributes(ParameterInfo, IEnumerable<Object>) método o GetCustomAttributes(MemberInfo, IEnumerable<Object>) . Estos métodos toman el objeto reflejado y la lista de atributos en su contexto de reflexión actual y devuelven la lista de atributos que debe tener en el contexto de reflexión personalizado.

Para agregar propiedades a un tipo reflejado, invalide el AddProperties método . El método acepta un parámetro que especifica el tipo reflejado y devuelve una lista de propiedades adicionales. Debe usar el método CreateProperty para crear objetos de propiedad que se devolverán. Puede especificar delegados al crear la propiedad que servirá como descriptor de acceso de propiedad y puede omitir uno de los descriptores de acceso para crear una propiedad de solo lectura o de solo escritura. Tenga en cuenta que estas propiedades ficticias no tienen metadatos ni respaldo de lenguaje intermedio común (CIL).