What are reflection and attributes used for?

Question

Accepted Answer

**Reflection** lets a program **inspect and manipulate types, methods, and properties at runtime** — even ones unknown at compile time. **Attributes** attach declarative **metadata** to code that tools and frameworks read (often via reflection) to drive behavior. Together they power much of .NET's framework "magic" (serialization, DI, ORMs, validation).

## Reflection — runtime inspection and invocation

```csharp
// 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 lets code discover and use types dynamically — instantiate by type, read/set properties, invoke methods — which is how frameworks operate on *your* types without knowing them in advance.

## Attributes — declarative metadata

```csharp
// 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 annotate code with metadata that frameworks read to drive behavior — validation rules, serialization names, routing, etc.

## Custom attributes + reflection (how frameworks work)

```csharp
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
```

This is the mechanism behind ASP.NET (`[HttpGet]`, `[Authorize]`), validation (`[Required]`), serialization (`[JsonPropertyName]`), ORMs, and testing frameworks — they scan attributed code via reflection and wire up behavior.

## Why it matters

Reflection and attributes are the **machinery behind much of .NET's framework functionality**, so understanding them is valuable for comprehending how frameworks work and for advanced scenarios. **Reflection** enables generic, dynamic behavior — inspecting and operating on types at runtime without compile-time knowledge — which is how dependency injection, serialization (JSON/XML libraries reading properties), ORMs (mapping objects to database tables), and testing frameworks work on your arbitrary types. **Attributes** provide the declarative metadata these tools read (via reflection) to drive their behavior, replacing verbose configuration with simple annotations (`[Required]` for validation, `[HttpGet]` for routing, `[JsonPropertyName]` for serialization, `[Authorize]` for security).

Understanding them **demystifies how ASP.NET Core, Entity Framework, validation, serialization, and testing frameworks achieve their declarative "magic"** — recognizing that attributes mark code and reflection reads and acts on those marks.

This knowledge is valuable for using these frameworks effectively, building your own framework-like tools or libraries (custom attributes + reflection), and understanding the trade-offs (reflection is slower than direct calls and bypasses some compile-time checking, so it's used judiciously).

While advanced and not everyday coding, understanding reflection and attributes is important senior-level knowledge for working deeply in the .NET ecosystem — it explains how the frameworks you use daily actually work, enables advanced metaprogramming, and is a relevant topic for understanding .NET's architecture and for building extensible, attribute-driven libraries, making it worthwhile knowledge that distinguishes developers with deep .NET understanding.