📝 Lesson 5.1: Attributes and Reflection

Metadata and Introspection

Compiled .NET code carries rich metadata: the names, types, and structure of everything you wrote. Attributes let you attach your own metadata; reflection lets code read all of it — its own or another assembly's — while running.

This pair is how System.Text.Json (Intermediate) discovers your properties, how xUnit (Intermediate) finds [Fact] methods, and how DI containers wire things up (next lesson).

Attributes

You've already used attributes: [Fact], [Benchmark], [MemoryDiagnoser]. .NET ships many built-in ones too. You apply an attribute by placing it in brackets above the target:

public class LegacyApi
{
    [Obsolete("Use ProcessV2 instead.")]   // compiler warns anyone who calls this
    public void Process() { }

    public void ProcessV2() { }
}

Custom Attributes

You define an attribute as a class deriving from System.Attribute (inheritance from the intro). Constructor parameters become positional arguments; properties become named arguments. [AttributeUsage] restricts where it can be applied:

// Restrict this attribute to properties
[AttributeUsage(AttributeTargets.Property)]
public class RequiredAttribute : Attribute
{
    // no data needed — its presence is the signal
}

[AttributeUsage(AttributeTargets.Property)]
public class RangeAttribute : Attribute
{
    public int Min { get; }
    public int Max { get; }
    public RangeAttribute(int min, int max) => (Min, Max) = (min, max);
}

Now apply them to a model. By convention you can drop the Attribute suffix when applying ([Required] means RequiredAttribute):

public class Product
{
    [Required]
    public string Name { get; set; } = "";

    [Range(1, 1000)]
    public int Quantity { get; set; }
}

Reflection Basics

Reflection starts with a Type object — obtained via typeof(X) (compile-time) or obj.GetType() (runtime). From a Type you can enumerate members:

using System.Reflection;

Type type = typeof(Product);

Console.WriteLine($"Type: {type.Name}");           // Product

foreach (PropertyInfo prop in type.GetProperties())
{
    Console.WriteLine($"  {prop.PropertyType.Name} {prop.Name}");
}
// String Name
// Int32 Quantity

foreach (MethodInfo method in type.GetMethods())
{
    Console.WriteLine($"  method: {method.Name}");
}

You can also read and write property values on an instance dynamically:

var product = new Product { Name = "Widget", Quantity = 5 };

PropertyInfo nameProp = typeof(Product).GetProperty("Name")!;
object? value = nameProp.GetValue(product);        // "Widget"
nameProp.SetValue(product, "Gadget");              // sets Name to "Gadget"

Reading Attributes

Now the two halves combine: reflection reads the attributes you attached. GetCustomAttribute<T>() returns the attribute instance (or null if absent), giving you access to its data:

using System.Reflection;

// A generic validator: reflect over properties, honor Required and Range
static List<string> Validate(object obj)
{
    var errors = new List<string>();
    Type type = obj.GetType();

    foreach (PropertyInfo prop in type.GetProperties())
    {
        object? value = prop.GetValue(obj);

        // [Required] present and value missing?
        if (prop.GetCustomAttribute<RequiredAttribute>() is not null)
        {
            if (value is null || (value is string s && string.IsNullOrWhiteSpace(s)))
                errors.Add($"{prop.Name} is required.");
        }

        // [Range] present and value out of bounds?
        var range = prop.GetCustomAttribute<RangeAttribute>();
        if (range is not null && value is int n && (n < range.Min || n > range.Max))
        {
            errors.Add($"{prop.Name} must be between {range.Min} and {range.Max}.");
        }
    }
    return errors;
}

var product = new Product { Name = "", Quantity = 5000 };

foreach (string error in Validate(product))
{
    Console.WriteLine(error);
}
// Name is required.
// Quantity must be between 1 and 1000.

Creating & Invoking Dynamically

Reflection can also create objects and call methods when you only know the type at runtime — the core trick behind plugin systems and DI containers.

using System.Reflection;

// Create an instance from a Type (must have a matching constructor)
Type t = typeof(Product);
object? instance = Activator.CreateInstance(t);      // new Product()

// Find and invoke a method by name
MethodInfo? method = t.GetMethod("ToString");
object? result = method?.Invoke(instance, null);     // calls instance.ToString()
Console.WriteLine(result);

You can also discover types across an assembly — e.g. "find every class implementing IPlugin" — and instantiate them:

var pluginTypes = Assembly.GetExecutingAssembly()
    .GetTypes()
    .Where(t => typeof(IPlugin).IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract);

foreach (Type pt in pluginTypes)
{
    var plugin = (IPlugin)Activator.CreateInstance(pt)!;
    plugin.Run();
}

The Cost of Reflection

Reflection is powerful but comes with real trade-offs — a fitting bookend to the performance module you just finished.

Exercise & Quiz

using System.Reflection;

var book = new Book { Title = "C# in Depth", Author = "Jon Skeet", Isbn = "12345" };
Describe(book);

[AttributeUsage(AttributeTargets.Property)]
class DisplayNameAttribute : Attribute
{
    public string Name { get; }
    public DisplayNameAttribute(string name) => Name = name;
}

class Book
{
    [DisplayName("Book Title")]
    public string Title { get; set; } = "";
    [DisplayName("Written By")]
    public string Author { get; set; } = "";
    public string Isbn { get; set; } = "";
}

static void Describe(object obj)
{
    // TODO: for each property, use [DisplayName] if present else the property name; print label + value
}

using System.Reflection;

var book = new Book { Title = "C# in Depth", Author = "Jon Skeet", Isbn = "12345" };
Describe(book);

[AttributeUsage(AttributeTargets.Property)]
class DisplayNameAttribute : Attribute
{
    public string Name { get; }
    public DisplayNameAttribute(string name) => Name = name;
}

class Book
{
    [DisplayName("Book Title")]
    public string Title { get; set; } = "";
    [DisplayName("Written By")]
    public string Author { get; set; } = "";
    public string Isbn { get; set; } = "";
}

static void Describe(object obj)
{
    foreach (PropertyInfo prop in obj.GetType().GetProperties())
    {
        var attr = prop.GetCustomAttribute<DisplayNameAttribute>();
        string label = attr?.Name ?? prop.Name;
        Console.WriteLine($"{label}: {prop.GetValue(obj)}");
    }
}

Book Title: C# in Depth
Written By: Jon Skeet
Isbn: 12345

Summary

📚 Additional Resources

• Attributes and reflection — Microsoft Docs
• Creating custom attributes
• Source generators — a compile-time alternative

🚀 What's Next?

You've seen how frameworks inspect and wire up code. Next, we use that to structure applications cleanly. In Lesson 5.2: Dependency Injection, you'll decouple your classes and let a container assemble them.