Hasta ahora, todo el código de BiblioTech ha conocido en tiempo de compilación qué propiedades y métodos tiene cada clase: al escribir libro1.Titulo, el compilador comprueba que Libro tiene una propiedad Titulo antes de generar el programa. La reflexión (System.Reflection) invierte esa idea: permite que un programa inspeccione y manipule sus propios tipos en tiempo de ejecución, sin conocerlos de antemano. Es, literalmente, el mecanismo que hace posible que JsonSerializer (Módulo 5) sepa qué propiedades tiene un Libro sin que nadie haya escrito código específico de mapeo para esa clase: por debajo, recorre sus propiedades por reflexión. Esta lección abre el Módulo 6 explicando cómo funciona ese mecanismo y cómo usarlo directamente.

1. Qué es la reflexión y para qué sirve
2. Obtener un Type: typeof y GetType()
3. Inspeccionar propiedades y métodos: GetProperties() y GetMethods()
4. Leer y escribir valores de propiedades por reflexión
5. Crear instancias dinámicamente con Activator.CreateInstance
6. MostrarPropiedades: un inspector genérico para el dominio de BiblioTech
7. Coste de la reflexión y casos de uso reales

La reflexión es la capacidad de un programa de examinar su propia estructura —clases, propiedades, métodos, atributos— como si fueran datos, y de actuar sobre ella sin que el código que la usa conozca de antemano el tipo concreto con el que trabaja. Todo el namespace System.Reflection gira en torno a un tipo central: System.Type, que representa, en tiempo de ejecución, "la descripción completa de una clase" (sus propiedades, sus métodos, su clase base, sus interfaces...).

La reflexión no es una herramienta que se use a diario en el código de dominio de una aplicación como BiblioTech (Libro.Titulo se sigue escribiendo directamente, sin reflexión, en el 99% del código). Su valor aparece en código genérico e infraestructural: frameworks que necesitan trabajar con "cualquier tipo" sin conocerlo por adelantado. Ya has usado varias piezas construidas así sin saberlo:

Hay dos formas de obtener el Type que representa una clase, según se conozca el tipo en tiempo de compilación o solo se tenga una instancia en tiempo de ejecución:

El segundo matiz es importante: si MaterialBibliotecario material = libro1; (recordando el Polimorfismo del Módulo 3), material.GetType() devuelve Libro, no MaterialBibliotecario —GetType() siempre revela el tipo concreto del objeto en memoria, sin importar el tipo de la variable que lo referencia.

Un Type expone, entre muchos otros, los métodos GetProperties() y GetMethods(), que devuelven arrays de PropertyInfo y MethodInfo respectivamente: objetos que describen, uno por uno, cada propiedad o método público del tipo.

GetProperties() sobre typeof(Libro) incluye tanto las propiedades declaradas directamente en Libro (Isbn) como las heredadas de MaterialBibliotecario (Titulo, Autor, Disponible): la reflexión respeta la jerarquía de herencia igual que el propio lenguaje. GetMethods(), por defecto, también incluye métodos heredados de object (ToString(), GetType(), Equals()...), lo cual conviene tener presente al recorrer el resultado.

Un PropertyInfo no es solo una descripción: también permite leer (GetValue) o escribir (SetValue) el valor de esa propiedad sobre una instancia concreta, pasada como argumento:

GetProperty("Titulo") busca, por su nombre como cadena de texto, la propiedad concreta Titulo; devuelve null si no existe ninguna con ese nombre exacto, de ahí el ? en GetValue. Esto es justamente lo que distingue a la reflexión de acceder a libro1.Titulo directamente: el nombre de la propiedad puede ser un dato (una cadena que llega desde configuración, desde un fichero, o que se calcula en un bucle), no un identificador fijo escrito en el código.

Disponible, con su private set (Módulo 3), sigue respetando su encapsulamiento frente a SetValue por defecto: GetProperty("Disponible")?.SetValue(libro1, false) lanza una excepción, salvo que se pida explícitamente acceso a miembros no públicos con BindingFlags.NonPublic, una posibilidad que existe pero que conviene evitar —saltarse un private set por reflexión rompe precisamente la garantía que ese private set pretendía dar.

Además de inspeccionar tipos ya instanciados, la reflexión permite crear instancias nuevas de un tipo que solo se conoce en tiempo de ejecución (por ejemplo, a partir de su nombre como cadena de texto), con Activator.CreateInstance:

Activator.CreateInstance(tipo, argumentos...) busca, entre los constructores públicos de tipo, uno cuya firma coincida con los argumentos indicados, y lo invoca; el resultado se devuelve como object, por lo que hace falta un is/as (Módulo 3) para volver a tratarlo como Socio con todos sus miembros. Este mecanismo es la base de muchos frameworks: un contenedor de inyección de dependencias (mencionado de pasada aquí; se retoma en el Módulo 8) recibe, en tiempo de ejecución, una lista de tipos a instanciar sin conocerlos en tiempo de compilación, y usa Activator.CreateInstance (o mecanismos equivalentes más optimizados) para construir cada uno.

Uniendo GetType(), GetProperties() y GetValue(), se puede escribir una única función que imprime el nombre y el valor de cada propiedad pública de cualquier objeto, sin necesidad de un método MostrarFicha() distinto para cada clase del dominio:

MostrarPropiedades recibe object obj (el tipo más general posible, Módulo 3) precisamente porque no necesita saber de antemano si recibirá un Libro, una Revista o un Socio: usa obj.GetType() para descubrirlo en tiempo de ejecución, y a partir de ahí recorre sus propiedades de forma genérica. Es una herramienta de depuración muy práctica: un único método sirve para inspeccionar el estado interno de cualquier objeto del dominio, sin escribir ni mantener un MostrarFicha() a medida por cada clase nueva que se añada a BiblioTech.

La reflexión tiene un coste de rendimiento notable frente al acceso directo (libro1.Titulo): localizar un miembro por su nombre, comprobar tipos y firmas en tiempo de ejecución es sensiblemente más lento que una llamada resuelta en tiempo de compilación. Esto no significa que deba evitarse siempre, sino que hay que reservarla para donde de verdad aporta valor:

• Usar reflexión donde el acceso directo ya funciona: si el tipo se conoce en tiempo de compilación (el caso habitual en el código de dominio de BiblioTech), acceder directamente a libro1.Titulo es más rápido, más seguro y más legible que buscarlo por reflexión con una cadena de texto.
• Olvidar comprobar null en GetProperty/GetMethod: si el nombre buscado no existe (por ejemplo, por una errata en la cadena de texto), estos métodos devuelven null en vez de lanzar una excepción; acceder a .GetValue(...) sobre ese null sin comprobarlo lanza una NullReferenceException.
• Saltarse el encapsulamiento con BindingFlags.NonPublic sin necesidad real: es técnicamente posible leer o escribir miembros private por reflexión, pero hacerlo rutinariamente rompe las garantías de diseño (como el private set de Disponible) que el propio código estableció a propósito.
• No medir el impacto en rendimiento antes de usar reflexión en un camino crítico: en un bucle que se ejecuta millones de veces, la diferencia entre acceso directo y reflexión puede ser significativa; para código de infraestructura muy sensible al rendimiento existen alternativas más avanzadas (compilación de expresiones, Source Generators) fuera del alcance de este curso.
• Consejo: antes de escribir código con reflexión, pregúntate si el problema se puede resolver con las herramientas ya vistas (interfaces, genéricos, polimorfismo); la reflexión es la herramienta correcta cuando el tipo concreto no se conoce hasta tiempo de ejecución, no un sustituto general de un buen diseño orientado a objetos.

1. Usando typeof y GetType(), comprueba que typeof(Revista) y new Revista("Muy Interesante", "Redaccion", 350).GetType() representan el mismo Type. Imprime también tipo.Name y tipo.BaseType?.Name para Revista (pista: BaseType devuelve el Type de la clase base, aquí MaterialBibliotecario).

2. Escribe la función MostrarPropiedades(object obj) de esta lección y utilízala para mostrar las propiedades de un Libro, una Revista y un Socio distintos.

3. Escribe una función bool TienePropiedad(object obj, string nombrePropiedad) que devuelva true si el tipo de obj tiene una propiedad pública con ese nombre exacto (usando GetProperty y comprobando si el resultado es distinto de null), y false en caso contrario. Pruébala con "Titulo" (debe dar true sobre un Libro) y con "Precio" (debe dar false).

Type tipoPorTypeof = typeof(Revista);
Revista revista1 = new Revista("Muy Interesante", "Redaccion", 350);
Type tipoPorInstancia = revista1.GetType();

Console.WriteLine(tipoPorTypeof == tipoPorInstancia); // True
Console.WriteLine(tipoPorTypeof.Name);                 // "Revista"
Console.WriteLine(tipoPorTypeof.BaseType?.Name);        // "MaterialBibliotecario"

static void MostrarPropiedades(object obj)
{
    Type tipo = obj.GetType();
    Console.WriteLine($"--- {tipo.Name} ---");

    foreach (PropertyInfo propiedad in tipo.GetProperties())
    {
        Console.WriteLine($"{propiedad.Name}: {propiedad.GetValue(obj)}");
    }
}

Libro libro1 = new Libro("Rayuela", "Julio Cortazar", "978-84-376-0495-4");
Revista revista1 = new Revista("Muy Interesante", "Redaccion", 350);
Socio socio1 = new Socio(1, "Ana Martinez");

MostrarPropiedades(libro1);
MostrarPropiedades(revista1);
MostrarPropiedades(socio1);

static bool TienePropiedad(object obj, string nombrePropiedad)
{
    return obj.GetType().GetProperty(nombrePropiedad) != null;
}

Libro libro1 = new Libro("Rayuela", "Julio Cortazar", "978-84-376-0495-4");

Console.WriteLine(TienePropiedad(libro1, "Titulo")); // True
Console.WriteLine(TienePropiedad(libro1, "Precio"));  // False

En esta lección has conocido la reflexión: cómo obtener el Type de una clase con typeof o GetType(), cómo inspeccionar sus propiedades y métodos con GetProperties()/GetMethods(), cómo leer y escribir valores por reflexión con GetValue()/SetValue(), y cómo crear instancias dinámicamente con Activator.CreateInstance. También has visto que la reflexión es precisamente el mecanismo que hace posible herramientas ya usadas en el curso, como JsonSerializer o Entity Framework Core, y por qué conviene reservarla para código genérico de infraestructura en vez de para el día a día del dominio.

La siguiente lección, Atributos, retoma algo que ya has visto de pasada sin detenerte en ello: [JsonPropertyName] y [JsonPolymorphic] de la lección de Serialización son, en realidad, atributos, una forma de anotar código con metadatos adicionales. Y la reflexión que acabas de aprender es exactamente la herramienta que permite leer esos atributos en tiempo de ejecución para tomar decisiones —la pieza que faltaba para entender cómo funcionan de verdad por debajo.