Reflection permite que um programa inspecione e manipule tipos, métodos e propriedades em tempo de execução — inclusive aqueles desconhecidos em tempo de compilação. Attributes anexam metadados declarativos ao código, que ferramentas e frameworks leem (muitas vezes via reflection) para conduzir o comportamento. Juntos, eles dão suporte a grande parte da "mágica" dos frameworks do .NET (serialização, DI, ORMs, validação).
// 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
Reflection permite que o código descubra e use tipos dinamicamente — instanciar por tipo, ler/definir propriedades, invocar métodos — que é como os frameworks operam sobre os seus tipos sem conhecê-los previamente.
// 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) { }
Attributes anotam o código com metadados que os frameworks leem para conduzir o comportamento — regras de validação, nomes de serialização, roteamento 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
Esse é o mecanismo por trás do ASP.NET ([HttpGet], [Authorize]), validação ([Required]), serialização ([JsonPropertyName]), ORMs e frameworks de teste — eles examinam o código anotado via reflection e conectam o comportamento.
Reflection e attributes são a maquinaria por trás de grande parte da funcionalidade dos frameworks do .NET, então entendê-los é valioso para compreender como os frameworks funcionam e para cenários avançados. Reflection habilita comportamento genérico e dinâmico — inspecionar e operar sobre tipos em tempo de execução sem conhecimento em tempo de compilação — que é como funcionam injeção de dependência, serialização (bibliotecas JSON/XML lendo propriedades), ORMs (mapeando objetos para tabelas de banco de dados) e frameworks de teste sobre seus tipos arbitrários. Attributes fornecem os metadados declarativos que essas ferramentas leem (via reflection) para conduzir seu comportamento, substituindo configuração verbosa por anotações simples ([Required] para validação, [HttpGet] para roteamento, [JsonPropertyName] para serialização, [Authorize] para segurança).
Entendê-los desmistifica como ASP.NET Core, Entity Framework, validação, serialização e frameworks de teste alcançam sua "mágica" declarativa — reconhecendo que attributes marcam o código e reflection lê e age sobre essas marcas.
Esse conhecimento é valioso para usar esses frameworks de forma eficaz, construir suas próprias ferramentas ou bibliotecas semelhantes a frameworks (custom attributes + reflection) e entender os trade-offs (reflection é mais lento que chamadas diretas e ignora parte da verificação em tempo de compilação, por isso é usado com critério).
Embora seja avançado e não faça parte do código do dia a dia, entender reflection e attributes é um conhecimento importante de nível sênior para trabalhar profundamente no ecossistema .NET — explica como os frameworks que você usa diariamente realmente funcionam, habilita metaprogramação avançada e é um tópico relevante para compreender a arquitetura do .NET e para construir bibliotecas extensíveis e orientadas a attributes, tornando-se um conhecimento valioso que distingue desenvolvedores com profundo entendimento de .NET.