CustomReflectionContext Classe

Definizione

Spazio dei nomi:

System.Reflection.Context

Assembly:

System.Reflection.Context.dll

Pacchetto:

System.Reflection.Context v9.0.0-rc.1.24431.7

Origine:

CustomReflectionContext.cs

Rappresenta un contesto di reflection personalizzabile.

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

Ereditarietà

Object

ReflectionContext

CustomReflectionContext

Derivato

System.ComponentModel.Composition.Registration.RegistrationBuilder

Esempio

Nell'esempio seguente viene illustrato come CustomReflectionContext aggiungere un attributo personalizzato a tutti i membri di un determinato tipo i cui nomi iniziano con "To". Per eseguire questo codice, incollarlo in un progetto console vuoto e assicurarsi di includere un riferimento 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();
    }
}

Commenti

CustomReflectionContext fornisce un modo per aggiungere o rimuovere attributi personalizzati dagli oggetti reflection o aggiungere proprietà fittizie a tali oggetti, senza implementare nuovamente il modello di reflection completo. L'impostazione predefinita CustomReflectionContext esegue semplicemente il wrapping di oggetti reflection senza apportare modifiche, ma eseguendo l'override dei metodi pertinenti, è possibile aggiungere, rimuovere o modificare gli attributi che si applicano a qualsiasi parametro o membro riflesso o aggiungere nuove proprietà a un tipo riflesso.

Si supponga, ad esempio, che il codice segue la convenzione di applicare un attributo specifico ai metodi factory, ma è ora necessario usare codice di terze parti che non contiene attributi. È possibile usare CustomReflectionContext per specificare una regola per identificare gli oggetti che devono avere attributi e fornire gli oggetti con tali attributi quando vengono visualizzati dal codice.

Per usare CustomReflectionContext in modo efficace, il codice che usa gli oggetti riflessi deve supportare la nozione di specificare un contesto di reflection, anziché presupponere che tutti gli oggetti riflessi siano associati al contesto di reflection di runtime. Molti metodi di reflection in .NET Framework forniscono un ReflectionContext parametro per questo scopo.

Per modificare gli attributi applicati a un parametro o a un membro riflesso, eseguire l'override del GetCustomAttributes(ParameterInfo, IEnumerable<Object>) metodo o GetCustomAttributes(MemberInfo, IEnumerable<Object>) . Questi metodi accettano l'oggetto riflesso e l'elenco di attributi nel contesto di reflection corrente e restituiscono l'elenco degli attributi che deve avere nel contesto di reflection personalizzato.

Avviso

CustomReflectionContext i metodi non devono accedere all'elenco di attributi di un oggetto o di un metodo riflesso direttamente chiamando il GetCustomAttributes metodo nell'istanza specificata MemberInfo o ParameterInfo , invece, usare l'elenco declaredAttributes , che viene passato come parametro agli overload del GetCustomAttributes metodo.

Per aggiungere proprietà a un tipo riflesso, eseguire l'override del AddProperties metodo. Il metodo accetta un parametro che specifica il tipo riflesso e restituisce un elenco di proprietà aggiuntive. È consigliabile usare il CreateProperty metodo per creare oggetti proprietà da restituire. È possibile specificare delegati durante la creazione della proprietà che fungerà da funzione di accesso alla proprietà e è possibile omettere una delle funzioni di accesso per creare una proprietà di sola lettura o di sola scrittura. Si noti che tali proprietà fittizie non dispongono di metadati o backup di Common Intermediate Language (CIL).

Avviso

Prestare attenzione all'uguaglianza tra gli oggetti riflessi quando si lavora con contesti di reflection, perché gli oggetti possono rappresentare lo stesso oggetto riflesso in più contesti. È possibile usare il MapType metodo per ottenere una determinata versione del contesto di reflection di un oggetto riflesso.

Avviso

Un CustomReflectionContext oggetto modifica gli attributi restituiti da un particolare oggetto reflection, ad esempio quelli ottenuti dal GetCustomAttributes metodo . Non modifica i dati degli attributi personalizzati restituiti dal GetCustomAttributesData metodo e questi due elenchi non corrispondono quando si usa un contesto di reflection personalizzato.

Costruttori

CustomReflectionContext()	Inizializza una nuova istanza della classe CustomReflectionContext.
CustomReflectionContext(ReflectionContext)	Inizializza una nuova istanza della classe CustomReflectionContext con il contesto di reflection come base.

Metodi

AddProperties(Type)	Quando ne viene eseguito l'override in una classe derivata, fornisce una raccolta di proprietà aggiuntive per il tipo specificato, come indicato in questo contesto di reflection.
CreateProperty(Type, String, Func<Object,Object>, Action<Object,Object>)	Crea un oggetto che rappresenta una proprietà da aggiungere a un tipo, da utilizzare con il metodo AddProperties(Type).
CreateProperty(Type, String, Func<Object,Object>, Action<Object,Object>, IEnumerable<Attribute>, IEnumerable<Attribute>, IEnumerable<Attribute>)	Crea un oggetto che rappresenta una proprietà da aggiungere a un tipo, da utilizzare con il metodo AddProperties(Type) e utilizzando gli attributi personalizzati specificati.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetCustomAttributes(MemberInfo, IEnumerable<Object>)	Quando ne viene eseguito l'override in una classe derivata, fornisce un elenco di attributi personalizzati per il membro specificato, come indicato in questo contesto di reflection.
GetCustomAttributes(ParameterInfo, IEnumerable<Object>)	Quando ne viene eseguito l'override in una classe derivata, fornisce un elenco di attributi personalizzati per il parametro specificato, come indicato in questo contesto di reflection.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
GetTypeForObject(Object)	Ottiene la rappresentazione del tipo dell'oggetto specificato nel contesto di reflection. (Ereditato da ReflectionContext)
MapAssembly(Assembly)	Ottiene la rappresentazione, in questo contesto di reflection, di un assembly rappresentato da un oggetto di un altro contesto di reflection.
MapType(TypeInfo)	Ottiene la rappresentazione, in questo contesto di reflection, di un tipo rappresentato da un oggetto di un altro contesto di reflection.
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)