Reflection & Dynamic Type Inspection

Lesson 19 • Advanced Track

What You'll Learn

Inspect types, properties, methods, and fields at runtime using System.Reflection
Create instances dynamically with Activator.CreateInstance
Invoke methods and access properties by name at runtime
Define and apply custom attributes to classes, methods, and properties
Read custom attributes via reflection for metadata-driven architectures
Understand when reflection is appropriate and its performance trade-offs

💡 Real-World Analogy

Reflection is like being able to X-ray a machine while it's running. Normally you interact with a car by turning the steering wheel and pressing pedals (public API). With reflection, you can open the hood, see every component, read serial numbers, and even rewire connections — all while the engine is running. Frameworks like ASP.NET use this to discover your controllers, and testing tools use it to access private members.

1. Type Inspection

Every type in .NET has a Type object that describes its structure. Use typeof(T) at compile time or obj.GetType() at runtime to get it. From there, enumerate properties, methods, fields, and constructors — even private ones.

Type Inspection

Inspect properties, methods, and fields of a class using reflection.

Try it Yourself »

using System;
using System.Reflection;

class Person
{
    public string Name { get; set; } = "";
    public int Age { get; set; }
    private string secret = "hidden";

    public void Greet() => Console.WriteLine($"Hi, I'm {Name}!");
    private void Think() => Console.WriteLine("Thinking...");

    public string GetInfo(string prefix) => $"{prefix}: {Name}, age {Age}";
}

class Program
{
    static void Main()
    {
        Type type = typeof(Person);

        Console.WriteLine($"=== Type: {t
...

2. Dynamic Invocation

Create objects and call methods by name without compile-time references. Activator.CreateInstance instantiates types dynamically. MethodInfo.Invoke calls methods with parameters. This powers plugin systems where types are discovered at runtime.

Dynamic Invocation

Create objects and invoke methods dynamically by name.

Try it Yourself »

using System;
using System.Reflection;

class Calculator
{
    public int Add(int a, int b) => a + b;
    public int Multiply(int a, int b) => a * b;
    public string Describe() => "I'm a Calculator!";
}

class Program
{
    static void Main()
    {
        // Create instance dynamically (no 'new Calculator()')
        Type calcType = typeof(Calculator);
        object? calc = Activator.CreateInstance(calcType);

        Console.WriteLine("=== Dynamic Method Invocation ===");

        // Invoke
...

3. Custom Attributes

Attributes are metadata tags you attach to code. Define your own by extending Attribute, then read them via reflection. This is how ASP.NET discovers routes ([HttpGet]), EF maps properties ([Required]), and serializers control output ([JsonIgnore]).

Custom Attributes

Define attributes, apply them, and read them with reflection.

Try it Yourself »

using System;
using System.Reflection;

// Define a custom attribute
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false)]
class ApiEndpointAttribute : Attribute
{
    public string Route { get; }
    public string Method { get; }

    public ApiEndpointAttribute(string route, string method = "GET")
    {
        Route = route;
        Method = method;
    }
}

[AttributeUsage(AttributeTargets.Property)]
class RequiredAttribute : Attribute { }

// Apply attrib
...

Pro Tips

💡 Cache reflection results: typeof(T).GetProperties() is slow. Store the result in a static field if you call it repeatedly.
💡 Use source generators over reflection: In .NET 6+, source generators produce compile-time code that's faster than runtime reflection.
💡 BindingFlags control visibility: Combine Public | NonPublic | Instance | Static to find exactly what you need.
💡 Reflection breaks at refactoring: GetMethod("Add") won't update if you rename the method. Use nameof(Add) where possible.

Common Mistakes

Performance in hot paths: Reflection is 10-100x slower than direct calls. Never use it in tight loops or performance-critical code.
Missing BindingFlags: GetMethod("Think") returns null for private methods unless you include BindingFlags.NonPublic.
Wrong parameter types in Invoke: method.Invoke(obj, new object[] {"5", "3"}) passes strings when the method expects ints — runtime crash.
Trimming breaks reflection: .NET's publish trimmer removes "unused" types. If you only access types via reflection, they get trimmed. Use [DynamicallyAccessedMembers].

🎉 Lesson Complete

✅ typeof(T) and GetType() give you the Type metadata object
✅ Inspect properties, methods, fields — including private members with BindingFlags
✅ Activator.CreateInstance creates objects dynamically without new
✅ MethodInfo.Invoke calls methods by name at runtime
✅ Custom attributes add metadata; read them with GetCustomAttribute
✅ Reflection is powerful but slow — cache results and prefer source generators
✅ Next lesson: Generics — constraints, variance, and advanced patterns

Reflection & Dynamic Type Inspection

What You'll Learn

💡 Real-World Analogy

1. Type Inspection

Type Inspection

2. Dynamic Invocation

Dynamic Invocation

3. Custom Attributes

Custom Attributes

Pro Tips

Common Mistakes

🎉 Lesson Complete

Cookie & Privacy Settings