C# Reflection and Attributes: typeof, GetType and Custom Attributes

Reflection lets a program examine types while it runs: which properties a class has, what their values are, which methods exist, which attributes are attached. Attributes are the other half: declarative tags in square brackets, like [Obsolete] or [JsonPropertyName("id")], that mean nothing by themselves until the compiler or some code reads them with reflection. Serializers, ORMs, validation libraries, test frameworks and ASP.NET routing all work this way.

Most application code rarely needs reflection directly, but knowing how it works explains a lot of framework behavior.

Type objects: typeof and GetType

Everything starts from a System.Type. There are two ways to get one:

using System;

class Employee { public string Name { get; set; } }
class Manager : Employee { public int Reports { get; set; } }

class Program
{
    static void Main()
    {
        Type t1 = typeof(Employee);          // from a type name, at compile time
        Employee e = new Manager();
        Type t2 = e.GetType();               // from an object, at run time

        Console.WriteLine(t1.Name);
        Console.WriteLine(t2.Name);          // the real type, not the variable's type
        Console.WriteLine(t2.BaseType.Name);

        Console.WriteLine(e.GetType() == typeof(Employee));   // exact type check
        Console.WriteLine(e is Employee);                     // "is it an Employee or derived?"
        Console.WriteLine(typeof(Employee).IsAssignableFrom(t2));

        Console.WriteLine(typeof(int).FullName);
        Console.WriteLine(typeof(string).IsValueType);
        Console.WriteLine(nameof(Employee.Name));             // compile-time name, no reflection
    }
}

Output:

Employee
Manager
Employee
False
True
True
System.Int32
False
Name

The difference to remember: typeof(X) names a type you know when writing the code, and obj.GetType() asks an object what it really is. Comparing GetType() == typeof(Employee) is an exact match that fails for derived classes, which is usually not what you want; is and IsAssignableFrom respect inheritance. nameof looks similar but is not reflection at all: the compiler replaces it with a string constant.

GetType() on a null reference throws NullReferenceException, since there is no object to ask. On a boxed nullable value type it returns the underlying type: ((int?)5).GetType() is System.Int32.

Reading and setting properties

GetProperties() lists the public properties of a type as PropertyInfo objects, each of which can read and write the value on a given instance:

using System;
using System.Reflection;

class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
    private string supplierCode = "SUP-77";
}

class Program
{
    static void Main()
    {
        var mug = new Product { Name = "Mug", Price = 8.50m, Stock = 12 };
        Type type = mug.GetType();

        foreach (PropertyInfo p in type.GetProperties())
            Console.WriteLine($"{p.Name,-6} {p.PropertyType.Name,-8} = {p.GetValue(mug)}");

        PropertyInfo price = type.GetProperty("Price");
        price.SetValue(mug, 7.90m);
        Console.WriteLine(mug.Price);

        Console.WriteLine(type.GetProperty("Colour") == null);   // no such property

        FieldInfo hidden = type.GetField("supplierCode", BindingFlags.NonPublic | BindingFlags.Instance);
        Console.WriteLine(hidden.GetValue(mug));
    }
}

Output:

Name   String   = Mug
Price  Decimal  = 8.50
Stock  Int32    = 12
7.90
True
SUP-77

Three things this shows:

• GetValue returns object, so value types come back boxed and you cast them to use them.
• GetProperty with a name that does not exist returns null, and the next call on it throws NullReferenceException. Check before use.
• BindingFlags.NonPublic | BindingFlags.Instance reaches private members. That is legitimate in tooling and tests, but it bypasses encapsulation and breaks silently when the class is refactored.

This loop is essentially how a CSV exporter or an object-to-JSON serializer works: walk the properties, read each value, format it.

Calling methods and creating objects by name

GetMethod finds a method, and Invoke calls it with an array of arguments. Activator.CreateInstance creates an object from a Type, which is how plugin systems and DI containers build types chosen at run time:

using System;
using System.Reflection;

class PriceCalculator
{
    public decimal Rate { get; set; } = 0.20m;
    public decimal WithTax(decimal net) => net * (1 + Rate);
    public string Describe() => $"Tax rate {Rate:P0}";
}

class Program
{
    static void Main()
    {
        Type type = typeof(PriceCalculator);
        object calc = Activator.CreateInstance(type);

        MethodInfo withTax = type.GetMethod("WithTax");
        object result = withTax.Invoke(calc, new object[] { 50m });
        Console.WriteLine(result);

        foreach (MethodInfo m in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
        {
            if (m.IsSpecialName) continue;   // skip property getters and setters
            Console.WriteLine($"{m.ReturnType.Name} {m.Name}({m.GetParameters().Length} parameters)");
        }

        Type byName = Type.GetType("PriceCalculator");
        Console.WriteLine(byName == type);
    }
}

Output:

60.00
Decimal WithTax(1 parameters)
String Describe(0 parameters)
True

DeclaredOnly limits the list to members declared in the class itself; without it, GetMethods also returns ToString, Equals, GetHashCode and GetType from object. Type.GetType("Name") needs the namespace-qualified name, and for types in other assemblies the assembly name too ("MyApp.Plugins.Csv, MyApp.Plugins").

If the invoked method throws, Invoke wraps the exception in a TargetInvocationException; the original is in its InnerException.

Attributes: tags the compiler and frameworks read

An attribute is written in square brackets before the thing it describes. The framework defines many; a few that change what the compiler does:

public class OrderService
{
    [Obsolete("Use PlaceOrderAsync instead.")]
    public void PlaceOrder(Order order) { }
    // Every call site: warning CS0618: 'OrderService.PlaceOrder(Order)' is obsolete: 'Use PlaceOrderAsync instead.'
    // [Obsolete("...", true)] makes it error CS0619 instead.

    [Conditional("DEBUG")]
    public void Trace(string message) => Console.WriteLine(message);
    // Calls to Trace are removed entirely from builds without the DEBUG symbol.
}

[Flags] enum Channels { None = 0, Email = 1, Sms = 2 }   // changes how ToString formats combinations
[Serializable] class Snapshot { }                     // marks a type for legacy binary serialization

Others are read by libraries at run time: [JsonPropertyName] and [JsonIgnore] by System.Text.Json, [Required] and [MaxLength] by ASP.NET Core model validation and Entity Framework, [HttpGet("orders/{id}")] by ASP.NET routing, [Fact] and [Test] by test runners. The attribute itself does nothing; the code that looks for it does.

The name ObsoleteAttribute is shortened to [Obsolete] when applied: by convention every attribute class name ends in Attribute, and C# lets you drop the suffix.

Declaring and reading a custom attribute

A custom attribute is a class that derives from Attribute. [AttributeUsage] says what it may be applied to. Constructor parameters become positional arguments, and public settable properties become named arguments:

using System;
using System.Collections.Generic;
using System.Reflection;

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

[AttributeUsage(AttributeTargets.Property)]
class MaxLengthAttribute : Attribute
{
    public int Length { get; }
    public string Message { get; set; }            // optional, set as a named argument
    public MaxLengthAttribute(int length) { Length = length; }
}

class SignupForm
{
    [Required, MaxLength(20)]
    public string Username { get; set; }

    [Required]
    public string Email { get; set; }

    [MaxLength(10, Message = "Keep the city code short")]
    public string CityCode { get; set; }
}

static class Validator
{
    public static List<string> Validate(object model)
    {
        var errors = new List<string>();
        foreach (PropertyInfo p in model.GetType().GetProperties())
        {
            var value = p.GetValue(model) as string;

            if (p.GetCustomAttribute<RequiredAttribute>() != null && string.IsNullOrWhiteSpace(value))
                errors.Add($"{p.Name} is required");

            var max = p.GetCustomAttribute<MaxLengthAttribute>();
            if (max != null && value != null && value.Length > max.Length)
                errors.Add(max.Message ?? $"{p.Name} must be at most {max.Length} characters");
        }
        return errors;
    }
}

class Program
{
    static void Main()
    {
        var form = new SignupForm { Username = "a_very_long_username_indeed", CityCode = "LISBON-CENTRAL" };
        foreach (var error in Validator.Validate(form))
            Console.WriteLine(error);

        var ok = new SignupForm { Username = "ana", Email = "ana@example.com", CityCode = "LIS" };
        Console.WriteLine(Validator.Validate(ok).Count);
    }
}

Output:

Username must be at most 20 characters
Email is required
Keep the city code short
0

That is a miniature version of what ASP.NET Core model validation does with System.ComponentModel.DataAnnotations. Attribute arguments must be compile-time constants (numbers, strings, typeof(...), enum values, or arrays of those), because they are stored in the assembly's metadata. GetCustomAttribute<T>() is an extension method in System.Reflection; there is also IsDefined(typeof(T)) when you only need to know whether an attribute is present.

The cost of reflection

Reflection trades speed and safety for flexibility:

• Speed. Looking up a member by name and calling it through Invoke or GetValue is far slower than a direct call, and boxes value types. For repeated use, look up the PropertyInfo or MethodInfo once and keep it, or turn it into a delegate with Delegate.CreateDelegate or MethodInfo.CreateDelegate and call that.
• Safety. A misspelled name or a changed signature compiles fine and fails at run time. Prefer nameof(Product.Price) over the string "Price" wherever you can, so renames are caught.
• Trimming and AOT. Trimmed and Native AOT apps remove members nothing appears to use, and reflection hides usage from that analysis. Modern libraries (System.Text.Json, GeneratedRegex, logging) are moving to source generators, which do the same work at compile time.

Use reflection for the parts of a program that genuinely do not know their types in advance: plugins, generic tooling, serializers, test helpers. When the types are known, ordinary code, generics or interfaces are faster and checked by the compiler.

Common mistakes

• GetType() == typeof(Base) to test for a base class. It fails for derived types. Use is or IsAssignableFrom.
• Not checking for null. GetProperty, GetMethod and Type.GetType return null when nothing matches.
• Reflection in a hot loop without caching. Cache the MemberInfo or compile a delegate.
• Catching the wrong exception from Invoke. The real exception is the InnerException of TargetInvocationException.
• Magic strings for member names. Use nameof.