Reflexión permite que un programa inspeccione y manipule tipos, métodos y propiedades en tiempo de ejecución — incluso aquellos desconocidos en tiempo de compilación. Atributos adjuntan metadatos declarativos al código que herramientas y marcos leen (a menudo mediante reflexión) para controlar el comportamiento. Juntos impulsan gran parte de la "magia" del marco .NET (serialización, inyección de dependencias, ORMs, validación).
La reflexión y los atributos son la maquinaria detrás de gran parte de la funcionalidad del marco .NET, por lo que comprenderlos es valioso para entender cómo funcionan los marcos y para escenarios avanzados. Reflexión permite comportamiento genérico y dinámico — inspeccionar y operar sobre tipos en tiempo de ejecución sin conocimiento en tiempo de compilación — que es cómo funcionan la inyección de dependencias, serialización (librerías JSON/XML leyendo propiedades), ORMs (mapeando objetos a tablas de base de datos) y marcos de prueba en tus tipos arbitrarios. Atributos proporcionan los metadatos declarativos que estas herramientas leen (mediante reflexión) para controlar su comportamiento, reemplazando configuración verbosa con anotaciones simples ([Required] para validación, [HttpGet] para enrutamiento, [JsonPropertyName] para serialización, [Authorize] para seguridad).
Comprenderlos desmitifica cómo ASP.NET Core, Entity Framework, validación, serialización y marcos de prueba logran su "magia" declarativa — reconociendo que los atributos marcan código y reflexión lee y actúa sobre esas marcas.
Este conocimiento es valioso para usar estos marcos de manera efectiva, construir tus propias herramientas o librerías tipo marco (atributos personalizados + reflexión) y entender las compensaciones (reflexión es más lenta que llamadas directas y omite algunas verificaciones en tiempo de compilación, por lo que se usa cuidadosamente).
Aunque avanzado y no codificación cotidiana, comprender reflexión y atributos es conocimiento importante de nivel senior para trabajar profundamente en el ecosistema .NET — explica cómo funcionan realmente los marcos que usas a diario, habilita metaprogramación avanzada, y es un tema relevante para entender la arquitectura de .NET y para construir librerías extensibles impulsadas por atributos, haciendo que sea conocimiento valioso que distingue a desarrolladores con comprensión profunda de .NET.
// examine a type's structure at runtime
Type type = typeof(User);
foreach (PropertyInfo prop in type.GetProperties())
Console.WriteLine($"{prop.Name}: {prop.PropertyType}");
foreach (MethodInfo method in type.GetMethods()) { }
// create instances and invoke members dynamically
object instance = Activator.CreateInstance(type); // create without knowing the type at compile time
PropertyInfo p = type.GetProperty("Name");
p.SetValue(instance, "Ann"); // set a property reflectively
La reflexión permite al código descubrir y usar tipos dinámicamente — instanciar por tipo, leer/establecer propiedades, invocar métodos — que es cómo los marcos operan sobre tus tipos sin conocerlos con anticipación.
// built-in and framework attributes attach metadata to code
[Obsolete("Use NewMethod instead")]
[Serializable]
public class OldClass { }
public class User
{
[Required] // validation attribute (ASP.NET)
[StringLength(100)]
public string Name { get; set; }
[JsonPropertyName("email_address")] // serialization attribute
public string Email { get; set; }
}
[HttpGet("/users/{id}")] // ASP.NET routing attribute
public User Get(int id) { }
Los atributos anotan código con metadatos que los marcos leen para controlar el comportamiento — reglas de validación, nombres de serialización, enrutamiento, etc.
public class AuditAttribute : Attribute { public string Action; }
[Audit(Action = "delete")]
public void DeleteUser(int id) { }
// a framework reads the attribute via reflection and acts on it
var attr = method.GetCustomAttribute<AuditAttribute>();
if (attr != null) Log(attr.Action); // wrap/log/intercept based on the metadata
Este es el mecanismo detrás de ASP.NET ([HttpGet], [Authorize]), validación ([Required]), serialización ([JsonPropertyName]), ORMs y marcos de prueba — escanean código atribuido mediante reflexión e implementan el comportamiento.