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 seguinte demonstra como fazer uma subclasse CustomReflectionContext para adicionar um atributo personalizado a todos os membros de um dado tipo cujos nomes começam por "To". Para executar este código, cole-o num projeto de consola vazio e certifica-te de incluir 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();
    }
}

Observações

CustomReflectionContext fornece uma forma de adicionar ou remover atributos personalizados de objetos de reflexão, ou adicionar propriedades fictícias a esses objetos, sem ter de reimplementar o modelo completo de reflexão. O padrão CustomReflectionContext simplesmente envolve objetos de reflexão sem fazer quaisquer alterações, mas ao subclassar e sobrescrever os métodos relevantes, 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 o seu código segue a convenção de aplicar um determinado atributo a métodos de fábrica, mas agora é obrigado a trabalhar com código de terceiros que não possui atributos. Pode usar CustomReflectionContext para especificar uma regra para identificar os objetos que devem ter atributos e fornecer esses atributos aos objetos quando são visualizados no seu código.

Para o usar CustomReflectionContext eficazmente, o código que utiliza os objetos refletidos deve suportar a 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 em tempo de execução. Muitos métodos de reflexão no .NET Framework fornecem um ReflectionContext parâmetro para este propósito.

Para modificar os atributos que são aplicados a um parâmetro ou membro de reflexão, substitua o método GetCustomAttributes(ParameterInfo, IEnumerable<Object>) ou o método GetCustomAttributes(MemberInfo, IEnumerable<Object>). Estes métodos consideram o objeto alvo e a lista de atributos dentro do seu contexto atual de reflexão, e retornam a lista de atributos que devem 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 devolve uma lista de propriedades adicionais. Deve-se usar o método CreateProperty para criar objetos de propriedade para devolver. Pode especificar delegados ao criar a propriedade que servirá como acessório de propriedade, e pode omitir um dos acessórios para criar uma propriedade apenas de leitura ou apenas escrita. Note-se que tais propriedades fictícias não têm metadados nem suporte de Common Intermediate Language (CIL).