.NET Framework
Reflectie

Wat is een vergadering?

Assemblies zijn de bouwsteen van elke Common Language Runtime (CLR) -applicatie. Elk type dat u definieert, samen met zijn methoden, eigenschappen en hun bytecode, wordt gecompileerd en verpakt in een assembly.

using System.Reflection;

Assembly assembly = this.GetType().Assembly;   

Assemblages zijn zelfdocumenterend: ze bevatten niet alleen types, methoden en hun IL-code, maar ook de metagegevens die nodig zijn om ze te inspecteren en te consumeren, zowel tijdens het compileren als tijdens de uitvoering:

Assembly assembly = Assembly.GetExecutingAssembly();

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

Assemblies hebben namen die hun volledige, unieke identiteit beschrijven:

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

Als deze naam een PublicKeyToken , wordt dit een sterke naam genoemd . Het krachtig benoemen van een merk is het proces van het maken van een handtekening met behulp van de persoonlijke sleutel die overeenkomt met de openbare sleutel die bij het merk wordt gedistribueerd. Deze handtekening wordt toegevoegd aan het manifest, dat de namen en hashes bevat van alle bestanden waaruit de assembly bestaat, en de PublicKeyToken wordt onderdeel van de naam. Assemblies met dezelfde sterke naam moeten identiek zijn; sterke namen worden gebruikt in versiebeheer en om assemblageconflicten te voorkomen.

Hoe maak je een object van T met behulp van Reflectie

De standaardconstructor gebruiken

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

Met behulp van geparametriseerde constructor

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

Objecten maken en eigenschappen instellen met behulp van reflectie

Laten we zeggen dat we een klasse Classy die eigendom Propertua heeft

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

Propertua instellen Propertua behulp van reflectie:

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

Een attribuut van een opsomming krijgen met reflectie (en cachen)

Attributen kunnen nuttig zijn voor het aangeven van metadata op enums. Het verkrijgen van de waarde hiervan kan traag zijn, dus het is belangrijk om resultaten in de cache te bewaren.

    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;
        }
    }

Vergelijk twee objecten met reflectie

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;
    }
}

Opmerking: dit voorbeeld doet een veldgebaseerde vergelijking (negeer statische velden en eigenschappen) voor de eenvoud