Reading attributes with reflection in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Reading attributes with reflection

Start: Define class with attribute

↓

Create instance or get type

↓

Use reflection to get Type info

↓

Check for attribute presence

↓

Read attribute properties

↓

Use attribute data as needed

↓

End

This flow shows how to define a class with an attribute, then use reflection to find and read that attribute's data at runtime.

Execution Sample

C Sharp (C#)

using System;

[Obsolete("Use NewClass instead")]
class OldClass {}

class Program {
    static void Main() {
        var type = typeof(OldClass);
        var attr = (ObsoleteAttribute)Attribute.GetCustomAttribute(type, typeof(ObsoleteAttribute));
        Console.WriteLine(attr.Message);
    }
}

This code reads the Obsolete attribute message from OldClass using reflection and prints it.

Execution Table

Step	Action	Evaluation	Result
1	Define class OldClass with Obsolete attribute	Class OldClass has Obsolete attribute with message 'Use NewClass instead'	Class ready with attribute
2	Get Type object for OldClass	typeof(OldClass)	Type object representing OldClass
3	Call Attribute.GetCustomAttribute(type, ObsoleteAttribute)	Search attributes on OldClass for ObsoleteAttribute	ObsoleteAttribute instance found
4	Cast returned attribute to ObsoleteAttribute	Cast success	ObsoleteAttribute instance with Message property
5	Access attr.Message	attr.Message	"Use NewClass instead"
6	Print attr.Message	Console.WriteLine output	Use NewClass instead

💡 All steps completed, attribute message printed

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
type	null	Type(OldClass)	Type(OldClass)	Type(OldClass)	Type(OldClass)	Type(OldClass)
attr	null	null	ObsoleteAttribute instance	ObsoleteAttribute instance	ObsoleteAttribute instance	ObsoleteAttribute instance
attr.Message	N/A	N/A	N/A	N/A	"Use NewClass instead"	"Use NewClass instead"

Key Moments - 3 Insights

Why do we cast the result of GetCustomAttribute to ObsoleteAttribute?

GetCustomAttribute returns a general Attribute object, so we cast it to ObsoleteAttribute to access its specific properties like Message, as shown in step 4 of the execution_table.

What happens if the attribute is not present on the class?

GetCustomAttribute returns null if the attribute is missing. This means attr would be null and accessing attr.Message would cause an error. This is why checking for null before use is important.

Why do we use typeof(OldClass) instead of creating an instance?

Reflection can get attribute info from the Type itself without needing an instance. This is shown in step 2 where typeof(OldClass) gets the Type object.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of attr.Message at step 5?

A "OldClass is obsolete"

B null

C "Use NewClass instead"

D An exception is thrown

💡 Hint

Check the 'Evaluation' column in row for step 5 in execution_table

At which step does the program find the ObsoleteAttribute on OldClass?

A Step 3

B Step 2

C Step 4

D Step 6

💡 Hint

Look at the 'Action' and 'Result' columns in execution_table rows

If OldClass had no Obsolete attribute, what would attr be after step 3?

A An ObsoleteAttribute instance

B null

C A Type object

D An exception is thrown

💡 Hint

Refer to key_moments explanation about missing attributes and GetCustomAttribute behavior

Concept Snapshot

Reading attributes with reflection in C#:
- Use typeof(ClassName) to get Type
- Use Attribute.GetCustomAttribute(Type, AttributeType) to get attribute
- Cast to specific attribute type to access properties
- Check for null to avoid errors if attribute missing
- Use attribute data as needed at runtime

Full Transcript

This example shows how to read attributes from a class using reflection in C#. First, a class OldClass is defined with the Obsolete attribute that has a message. Then, the program gets the Type object for OldClass using typeof. Next, it calls Attribute.GetCustomAttribute to find the Obsolete attribute on that class. The returned attribute is cast to ObsoleteAttribute so its Message property can be accessed. Finally, the message is printed to the console. The execution table traces each step, showing how variables change and what actions happen. Key moments clarify why casting is needed, what happens if the attribute is missing, and why typeof is used instead of creating an instance. The visual quiz tests understanding of attribute reading steps and results. This method allows programs to read metadata about classes at runtime and use it for various purposes.