CustomReflectionContext Classe

Definição

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

Herança

Object

ReflectionContext

CustomReflectionContext

Derivado

System.ComponentModel.Composition.Registration.RegistrationBuilder

Exemplos

O exemplo a seguir demonstra como adicionar CustomReflectionContext um atributo personalizado a todos os membros de um determinado tipo cujos nomes começam com "To". Para executar esse código, cole-o em um projeto de console vazio e inclua uma referência 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();
    }
}

Comentários

CustomReflectionContext fornece uma maneira de adicionar ou remover atributos personalizados de objetos de reflexão ou adicionar propriedades fictícias a esses objetos, sem implementar novamente o modelo de reflexão completo. O padrão CustomReflectionContext simplesmente encapsula objetos de reflexão sem fazer nenhuma alteração, mas ao subclasse e substituindo os métodos relevantes, você pode adicionar, remover ou alterar os atributos que se aplicam a qualquer parâmetro ou membro refletido ou adicionar novas propriedades a um tipo refletido.

Por exemplo, suponha que seu código siga a convenção de aplicação de um atributo específico aos métodos de fábrica, mas agora você precisa trabalhar com código de terceiros que não tem atributos. Você pode usar CustomReflectionContext para especificar uma regra para identificar os objetos que devem ter atributos e fornecer os objetos com esses atributos quando eles forem exibidos do seu código.

Para usar CustomReflectionContext efetivamente, o código que usa os objetos refletidos deve dar suporte à noção de especificar um contexto de reflexão, em vez de assumir que todos os objetos refletidos estão associados ao contexto de reflexão de runtime. Muitos métodos de reflexão no .NET Framework fornecem um ReflectionContext parâmetro para essa finalidade.

Para modificar os atributos que são aplicados a um parâmetro ou membro refletido, substitua o GetCustomAttributes(ParameterInfo, IEnumerable<Object>) método ou GetCustomAttributes(MemberInfo, IEnumerable<Object>) . Esses métodos pegam o objeto refletido e a lista de atributos em seu contexto de reflexão atual e retornam a lista de atributos que ele deve ter no contexto de reflexão personalizado.

Para adicionar propriedades a um tipo refletido, substitua o AddProperties método . O método aceita um parâmetro que especifica o tipo refletido e retorna uma lista de propriedades adicionais. Você deve usar o CreateProperty método para criar objetos de propriedade a serem retornados. Você pode especificar delegados ao criar a propriedade que servirá como o acessador de propriedade e pode omitir um dos acessadores para criar uma propriedade somente leitura ou somente gravação. Observe que essas propriedades fictícias não têm nenhum suporte a metadados ou CIL (Common Intermediate Language).

Construtores

Métodos

Aplica-se a