CustomReflectionContext Classe

Définition

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

Héritage

Object

ReflectionContext

CustomReflectionContext

Dérivé

System.ComponentModel.Composition.Registration.RegistrationBuilder

Exemples

L’exemple suivant montre comment sous-classer CustomReflectionContext pour ajouter un attribut personnalisé à tous les membres d’un type donné dont les noms commencent par « To ». Pour exécuter ce code, collez-le dans un projet de console vide et veillez à inclure une référence à 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();
    }
}

Remarques

CustomReflectionContext permet d’ajouter ou de supprimer des attributs personnalisés des objets de réflexion, ou d’ajouter des propriétés factices à ces objets, sans réinscrire le modèle de réflexion complet. La valeur par défaut CustomReflectionContext encapsule simplement les objets de réflexion sans apporter de modifications, mais en sous-classe et en substituant les méthodes appropriées, vous pouvez ajouter, supprimer ou modifier les attributs qui s’appliquent à n’importe quel paramètre ou membre réfléchi, ou ajouter de nouvelles propriétés à un type réfléchi.

Par exemple, supposons que votre code suit la convention d’application d’un attribut particulier aux méthodes de fabrique, mais vous êtes maintenant obligé d’utiliser du code tiers qui n’a pas d’attributs. Vous pouvez utiliser CustomReflectionContext pour spécifier une règle permettant d’identifier les objets qui doivent avoir des attributs et de fournir les objets avec ces attributs lorsqu’ils sont consultés à partir de votre code.

Pour utiliser CustomReflectionContext efficacement, le code qui utilise les objets réfléchis doit prendre en charge la notion de spécification d’un contexte de réflexion, au lieu de supposer que tous les objets réfléchis sont associés au contexte de réflexion du runtime. De nombreuses méthodes de réflexion dans .NET Framework fournissent un ReflectionContext paramètre à cet effet.

Pour modifier les attributs appliqués à un paramètre ou à un membre réfléchi, remplacez la méthode GetCustomAttributes(ParameterInfo, IEnumerable<Object>) ou GetCustomAttributes(MemberInfo, IEnumerable<Object>). Ces méthodes prennent l’objet réfléchi et la liste des attributs dans le contexte de réflexion actuel, puis retournent la liste des attributs qu'il doit avoir dans le contexte de réflexion personnalisé.

Pour ajouter des propriétés à un type réfléchi, remplacez la AddProperties méthode. La méthode accepte un paramètre qui spécifie le type réfléchi et retourne une liste de propriétés supplémentaires. Vous devez utiliser la méthode CreateProperty pour créer des objets de propriété à retourner. Vous pouvez spécifier des délégués lors de la création de la propriété qui servira d’accesseur de propriété, et vous pouvez omettre l’un des accesseurs pour créer une propriété en lecture seule ou en écriture seule. Notez que ces propriétés factices n’ont pas de métadonnées ni de sauvegarde CIL (Common Intermediate Language).