.NET Framework
Reflexion

Was ist eine Versammlung?

Baugruppen sind der Baustein für jede CLR- Anwendung (Common Language Runtime) . Jeder von Ihnen definierte Typ wird zusammen mit seinen Methoden, Eigenschaften und seinem Bytecode innerhalb einer Assembly kompiliert und verpackt.

using System.Reflection;

Assembly assembly = this.GetType().Assembly;   

Assemblies sind selbstdokumentierend: Sie enthalten nicht nur Typen, Methoden und ihren IL-Code, sondern auch die Metadaten, die für die Prüfung und den Verbrauch erforderlich sind, sowohl beim Kompilieren als auch zur Laufzeit:

Assembly assembly = Assembly.GetExecutingAssembly();

foreach (var type in assembly.GetTypes())
{
    Console.WriteLine(type.FullName);
}

Assemblies haben Namen, die ihre vollständige, eindeutige Identität beschreiben:

Console.WriteLine(typeof(int).Assembly.FullName);
// Will print: "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"

Wenn dieser Name ein PublicKeyToken , wird es als starker Name bezeichnet . Eine Assembly mit starker Benennung bezeichnet das Erstellen einer Signatur mithilfe des privaten Schlüssels, der dem mit der Assembly verteilten öffentlichen Schlüssel entspricht. Diese Signatur wird dem Assemblymanifest hinzugefügt, das die Namen und Hashes aller Dateien enthält, aus denen die Assembly besteht, und ihr PublicKeyToken wird Teil des Namens. Baugruppen mit demselben starken Namen sollten identisch sein. Starke Namen werden bei der Versionierung und zur Vermeidung von Assemblykonflikten verwendet.

So erstellen Sie ein Objekt aus T mit Reflection

Verwenden des Standardkonstruktors

T variable = Activator.CreateInstance(typeof(T));

Verwendung eines parametrisierten Konstruktors

T variable = Activator.CreateInstance(typeof(T), arg1, arg2);

Erstellen von Objekten und Festlegen von Eigenschaften mithilfe von Reflektionen

Nehmen wir an, wir haben eine Klasse Classy , die die Eigenschaft Properties besitzt

public class Classy
{
    public string Propertua {get; set;}
}

Propertua mit Reflektion Propertua :

var typeOfClassy = typeof (Classy);
var classy = new Classy();
var prop = typeOfClassy.GetProperty("Propertua");
prop.SetValue(classy, "Value");

Ein Attribut einer Aufzählung mit Reflektion erhalten (und zwischenspeichern)

Attribute können nützlich sein, um Metadaten in Enums zu kennzeichnen. Der Wert dieses Wertes kann langsam sein, daher müssen die Ergebnisse zwischengespeichert werden.

    private static Dictionary<object, object> attributeCache = new Dictionary<object, object>();

    public static T GetAttribute<T, V>(this V value)
        where T : Attribute
        where V : struct
    {
        object temp;

        // Try to get the value from the static cache.
        if (attributeCache.TryGetValue(value, out temp))
        {
            return (T) temp;
        }
        else
        {
            // Get the type of the struct passed in.
            Type type = value.GetType();   
            FieldInfo fieldInfo = type.GetField(value.ToString());

            // Get the custom attributes of the type desired found on the struct.
            T[] attribs = (T[])fieldInfo.GetCustomAttributes(typeof(T), false);

            // Return the first if there was a match.
            var result = attribs.Length > 0 ? attribs[0] : null;

            // Cache the result so future checks won't need reflection.
            attributeCache.Add(value, result);

            return result;
        }
    }

Vergleichen Sie zwei Objekte mit Reflexion

public class Equatable
{
    public string field1;

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj)) return false;
        if (ReferenceEquals(this, obj)) return true;

        var type = obj.GetType();
        if (GetType() != type)
            return false;

        var fields = type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
        foreach (var field in fields)
            if (field.GetValue(this) != field.GetValue(obj))
                return false;

        return true;
    }

    public override int GetHashCode()
    {
        var accumulator = 0;
        var fields = GetType().GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
        foreach (var field in fields)
            accumulator = unchecked ((accumulator * 937) ^ field.GetValue(this).GetHashCode());

        return accumulator;
    }
}

Hinweis: In diesem Beispiel wird zur Vereinfachung ein Vergleich zwischen Feldern (statische Felder und Eigenschaften werden ignoriert) durchgeführt