.NET Framework
Reflexión

¿Qué es una asamblea?

Los ensamblajes son el bloque de construcción de cualquier aplicación de Common Language Runtime (CLR) . Cada tipo que defina, junto con sus métodos, propiedades y su código de bytes, se compila y empaqueta dentro de un ensamblaje.

using System.Reflection;

Assembly assembly = this.GetType().Assembly;   

Los ensamblajes se autodocumentan: no solo contienen tipos, métodos y su código IL, sino también los metadatos necesarios para inspeccionarlos y consumirlos, tanto en la compilación como en el tiempo de ejecución:

Assembly assembly = Assembly.GetExecutingAssembly();

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

Las asambleas tienen nombres que describen su identidad única y completa:

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

Si este nombre incluye un PublicKeyToken , se llama un nombre PublicKeyToken . Nombrar un ensamblaje en firme es el proceso de crear una firma mediante el uso de la clave privada que corresponde a la clave pública distribuida con el ensamblaje. Esta firma se agrega al manifiesto de ensamblaje, que contiene los nombres y los hashes de todos los archivos que forman el ensamblaje, y su PublicKeyToken convierte en parte del nombre. Las asambleas que tienen el mismo nombre seguro deben ser idénticas; Los nombres fuertes se utilizan en las versiones y para evitar conflictos de montaje.

Cómo crear un objeto de T utilizando la reflexión.

Usando el constructor por defecto

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

Usando constructor parametrizado

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

Creación de objetos y configuración de propiedades utilizando la reflexión.

Digamos que tenemos una clase con Classy que tiene propiedad Propertua

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

Para establecer Propertua utilizando la reflexión:

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

Obtención de un atributo de una enumeración con reflexión (y almacenamiento en caché)

Los atributos pueden ser útiles para denotar metadatos en enumeraciones. Obtener el valor de esto puede ser lento, por lo que es importante almacenar en caché los resultados.

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

Compara dos objetos con la reflexión.

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

Nota: este ejemplo realiza una comparación basada en campos (ignora los campos estáticos y las propiedades) para simplificar