Reflexión e introspección en C#: cómo mirar dentro de tu propio código

Introducción: la magia de la reflexión

Imagina que escribes código que puede "mirarse" a sí mismo. No como en un espejo deformante, sino como en un aparato de rayos X: ver la estructura, propiedades, métodos, e incluso ejecutarlos sin conocer el nombre de la clase en tiempo de compilación. Esto no es magia, es la reflexión en C# y su "hermana menor" — la introspección en C#.

¿Para qué sirve esto? Imagina que estás escribiendo un sistema de plugins, un deserializador JSON o una invocación dinámica de métodos. Sin reflexión tendrías que escribir un montón de if-else. Con ella, bastan un par de líneas. ¿Suena intrigante? Vamos a descubrirlo.

En este artículo no solo repasaremos la teoría. Escribiremos ejemplos de código reales que puedes usar de inmediato en tus proyectos. Aprenderás cómo obtener información sobre cualquier tipo, crear un objeto "de la nada", invocar un método privado e incluso leer atributos. Y todo esto, en el lenguaje C#, tan querido por su rigor y potencia.

¿Qué son la reflexión y la introspección en C#? Diferencia de conceptos

A menudo estos términos se usan como sinónimos, pero hay una sutil diferencia:

• Introspección en C# — es la capacidad del programa de observar su propia estructura. Puedes saber qué campos tiene una clase, qué métodos contiene, qué atributos están presentes. Pero no cambias nada.
• Reflexión en C# — es un concepto más amplio. Incluye la introspección, más la capacidad de interactuar con el código: invocar métodos, crear objetos, modificar valores de campos.

En pocas palabras: la introspección es "mirar", la reflexión es "mirar y tocar". En C#, ambas funciones son responsabilidad del espacio de nombres System.Reflection. Es tu herramienta principal.

Ejemplo práctico: obteniendo información sobre un tipo (Type)

Todo comienza con la clase Type. Es el fundamento de la reflexión. Se puede obtener de tres maneras:

// Forma 1: mediante typeof()Type typeFromKeyword = typeof(string);

// Forma 2: mediante una instancia .GetType()string example = "¡Hola, mundo!";Type typeFromInstance = example.GetType();

// Forma 3: mediante un ensamblado (Assembly)Type typeFromAssembly = Assembly.GetExecutingAssembly().GetType("System.String");

Ahora, teniendo un objeto Type, podemos saberlo todo sobre la clase. Escribamos un método útil para la introspección:

using System;using System.Reflection;

public class Inspector{    public static void ShowTypeInfo(Type type)    {        Console.WriteLine($"=== Información del tipo: {type.Name} ===");        Console.WriteLine($"Nombre completo: {type.FullName}");        Console.WriteLine($"¿Es una clase? {type.IsClass}");        Console.WriteLine($"¿Es abstracto? {type.IsAbstract}");        Console.WriteLine($"Clase base: {type.BaseType?.Name}");                Console.WriteLine("Propiedades públicas:");        foreach (PropertyInfo prop in type.GetProperties())        {            Console.WriteLine($" - {prop.PropertyType.Name} {prop.Name}");        }                Console.WriteLine("Métodos públicos:");        foreach (MethodInfo method in type.GetMethods())        {            Console.WriteLine($" - {method.ReturnType.Name} {method.Name}({string.Join(", ", method.GetParameters().Select(p => $"{p.ParameterType.Name} {p.Name}"))})");        }    }}

// UsoInspector.ShowTypeInfo(typeof(List<int>));/* Salida:=== Información del tipo: List`1 ===Nombre completo: System.Collections.Generic.List`1[[System.Int32, System.Private.CoreLib, Version=8.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]]¿Es una clase? True¿Es abstracto? FalseClase base: Object

Propiedades públicas: - Int32 Capacity - Int32 Count

Métodos públicos: - Void Add(Int32 obj) - Void Clear() - Boolean Contains(Int32 item) ... y muchos más*/

Esto es pura introspección.