CustomReflectionContext Klasse

Definition

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

Vererbung

Object

ReflectionContext

CustomReflectionContext

Abgeleitet

System.ComponentModel.Composition.Registration.RegistrationBuilder

Hinweise

CustomReflectionContext bietet eine Möglichkeit zum Hinzufügen oder Entfernen von benutzerdefinierten Attributen aus Spiegelungsobjekten oder zum Hinzufügen von Dummy-Eigenschaften zu diesen Objekten, ohne das vollständige Spiegelungsmodell erneut zu implementieren. Standardmäßig werden Reflexionsobjekte direkt umhüllt, ohne Änderungen vorzunehmen. Über die Bildung von Unterklassen und das Überschreiben der relevanten Methoden können Sie jedoch Attribute hinzufügen, entfernen oder ändern, die auf sämtliche reflektierten Parameter oder Mitglieder angewendet werden, oder neue Eigenschaften zu einem reflektierten Typ hinzufügen.

Angenommen, Ihr Code folgt der Konvention, ein bestimmtes Attribut auf Factorymethoden anzuwenden, aber Sie müssen jetzt mit Drittanbietercode arbeiten, der keine Attribute aufweist. Sie können CustomReflectionContext verwenden, um eine Regel zum Identifizieren der Objekte zu definieren, die Attribute aufweisen sollen, und um den Objekten diese Attribute zuzuweisen, wenn diese in Ihrem Code angezeigt werden.

Um effektiv zu verwenden CustomReflectionContext , muss der Code, der die reflektierten Objekte verwendet, das Konzept der Angabe eines Spiegelungskontexts unterstützen, anstatt davon auszugehen, dass alle reflektierten Objekte dem Laufzeitreflektionskontext zugeordnet sind. Viele Spiegelungsmethoden in .NET stellen zu diesem Zweck einen ReflectionContext Parameter bereit.

Um die Attribute zu ändern, die auf einen reflektierten Parameter oder ein Mitglied angewendet werden, überschreiben Sie die Methode GetCustomAttributes(ParameterInfo, IEnumerable<Object>) oder GetCustomAttributes(MemberInfo, IEnumerable<Object>). Diese Methoden übernehmen das reflektierte Objekt und die Liste der Attribute unter dem aktuellen Spiegelungskontext und geben die Liste der Attribute zurück, die sie im benutzerdefinierten Spiegelungskontext aufweisen sollen.

Wenn Sie einem reflektierten Typ Eigenschaften hinzufügen möchten, setzen Sie die AddProperties Methode außer Kraft. Die Methode akzeptiert einen Parameter, der den reflektierten Typ angibt, und gibt eine Liste mit zusätzlichen Eigenschaften zurück. Verwenden Sie die CreateProperty-Methode, um Eigenschaftsobjekte zu erstellen und zurückzugeben. Sie können Stellvertretungen angeben, wenn Sie die Eigenschaft erstellen, die als Eigenschaftsaccessor dient, und Sie können einen der Accessoren weglassen, um eine schreibgeschützte oder schreibgeschützte Eigenschaft zu erstellen. Beachten Sie, dass solche Dummy-Eigenschaften keine Metadaten oder CIL -Unterstützung (Common Intermediate Language) aufweisen.

Das folgende Beispiel demonstriert, wie man CustomReflectionContext unterklassen kann, um allen Mitgliedern eines bestimmten Typs, deren Namen mit "To" beginnen, ein benutzerdefiniertes Attribut hinzuzufügen.

// A blank example attribute.
class MyAttribute : Attribute
{
}

// Reflection context with custom rules.
class MyCustomReflectionContext : 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", StringComparison.Ordinal))
        {
            yield return new MyAttribute();
        }
        // Keep existing attributes as well.
        foreach (object attr in declaredAttributes)
        {
            yield return attr;
        }
    }
}

MyCustomReflectionContext mc = new();
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 affected members of the type ("To*") and their attributes.
foreach (MemberInfo m in myTI.DeclaredMembers.Where(static m => m.Name.StartsWith("To", StringComparison.Ordinal)))
{
    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();

Attribute[] defaultAttributes = mi1.GetCustomAttributes().ToArray();

// All the attributes of "ToString" in the default reflection context.
Console.WriteLine("'ToString' Attributes in Default Reflection Context:");
foreach (Attribute cd in defaultAttributes)
{
    Console.WriteLine(cd.GetType());
}

Console.WriteLine();

// The same member in the custom reflection context.
mi1 = myTI.GetDeclaredMethods("ToString").FirstOrDefault();

Attribute[] customAttributes = mi1.GetCustomAttributes().ToArray();

// All its attributes, for comparison. MyAttribute is now included.
Console.WriteLine("'ToString' Attributes in Custom Reflection Context:");
foreach (Attribute cd in customAttributes)
{
    Console.WriteLine(cd.GetType());
}