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-classe CustomReflectionContext pour ajouter un attribut personnalisé à tous les membres d’un type donné dont les noms commencent par « À ». 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 vous permet d’ajouter ou de supprimer des attributs personnalisés à partir d’objets de réflexion, ou d’ajouter des propriétés factices à ces objets, sans réapplémenter 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-classant et en remplaçant 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 que vous êtes maintenant tenu d’utiliser du code tiers qui n’a pas d’attributs. Vous pouvez utiliser CustomReflectionContext pour spécifier une règle pour identifier les objets qui doivent avoir des attributs et pour fournir ces attributs lorsqu’ils sont consultés à partir de votre code.

Pour une utilisation CustomReflectionContext efficace, 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 le .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 GetCustomAttributes(ParameterInfo, IEnumerable<Object>) méthode ou GetCustomAttributes(MemberInfo, IEnumerable<Object>) . Ces méthodes prennent l’objet réfléchi et la liste d’attributs sous son contexte de réflexion actuel, et retournent la liste des attributs qu’il doit avoir sous 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 reflété et retourne une liste de propriétés supplémentaires. Vous devez utiliser la CreateProperty méthode 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 support CIL (Common Intermediate Language).

Constructeurs

Méthodes

S’applique à