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.

Practice

1. What does reading attributes with reflection in C# allow you to do?

easy

A. Access extra information added to classes or methods at runtime

B. Change the source code of a program while it runs

C. Compile code faster by skipping attribute checks

D. Automatically generate user interfaces without coding

Solution

1. Step 1: Understand what attributes are

   Attributes are extra notes or metadata added to code elements like classes or methods.

2. Step 2: Understand reflection's role

   Reflection lets you look at these attributes while the program runs, to read their information.

3. Final Answer:

   Access extra information added to classes or methods at runtime -> Option A

4. Quick Check:

   Reflection reads attributes = Access extra info [OK]

Hint: Reflection reads metadata added to code elements [OK]

Common Mistakes:

• Thinking reflection changes code instead of reading it
• Confusing attributes with variables or methods
• Believing attributes speed up compilation

2. Which of the following is the correct way to get custom attributes of a class using reflection in C#?

easy

A. GetAttributes(typeof(MyClass))

B. typeof(MyClass).GetCustomAttributes()

C. MyClass.GetAttributes()

D. MyClass.Attributes()

Solution

1. Step 1: Recall the reflection syntax for attributes

   In C#, to get attributes of a class, use typeof(ClassName).GetCustomAttributes().

2. Step 2: Check each option

   Only typeof(MyClass).GetCustomAttributes() uses the correct syntax with typeof and GetCustomAttributes method.

3. Final Answer:

   typeof(MyClass).GetCustomAttributes() -> Option B

4. Quick Check:

   Correct syntax uses typeof and GetCustomAttributes() [OK]

Hint: Use typeof(Class).GetCustomAttributes() to read attributes [OK]

Common Mistakes:

• Calling GetAttributes() directly on class name
• Using instance methods instead of typeof
• Confusing method names like Attributes()

3. Given this code snippet, what will be the output?

[System.Obsolete("Use NewMethod instead")]
class OldClass {}

var attrs = typeof(OldClass).GetCustomAttributes(typeof(System.ObsoleteAttribute), false);
Console.WriteLine(attrs.Length);

medium

A. 0

B. null

C. Throws an exception

D. 1

Solution

1. Step 1: Identify the attribute applied

   The class OldClass has the Obsolete attribute applied once.

2. Step 2: Check GetCustomAttributes call

   GetCustomAttributes is called with ObsoleteAttribute type, so it returns an array with that attribute instance.

3. Final Answer:

   1 -> Option D

4. Quick Check:

   One Obsolete attribute found = 1 [OK]

Hint: Count attributes returned by GetCustomAttributes to find output length [OK]

Common Mistakes:

• Assuming zero because attribute is ignored
• Expecting null instead of empty array
• Thinking it throws exception without reason

4. What is wrong with this code snippet that tries to read attributes?

class MyClass {}

var attrs = MyClass.GetCustomAttributes();
Console.WriteLine(attrs.Length);

medium

A. MyClass does not have any attributes

B. Console.WriteLine cannot print Length property

C. GetCustomAttributes is not a method of the class itself

D. Missing semicolon after class declaration

Solution

1. Step 1: Check method call on class

   GetCustomAttributes is a method of Type, not the class itself, so calling MyClass.GetCustomAttributes() is invalid.

2. Step 2: Correct usage

   You must use typeof(MyClass).GetCustomAttributes() to get attributes via reflection.

3. Final Answer:

   GetCustomAttributes is not a method of the class itself -> Option C

4. Quick Check:

   Use typeof(Class).GetCustomAttributes() not Class.GetCustomAttributes() [OK]

Hint: Call GetCustomAttributes on typeof(Class), not class name [OK]

Common Mistakes:

• Calling GetCustomAttributes directly on class name
• Ignoring that GetCustomAttributes is a Type method
• Assuming attributes exist without checking

5. You want to read a custom attribute InfoAttribute applied to multiple methods in a class and print their descriptions. Which approach correctly reads and prints these descriptions?

hard

A. Use reflection to get MethodInfo array, then for each method call GetCustomAttributes(typeof(InfoAttribute), false) and print the Description property

B. Call GetCustomAttributes on the class type directly and print Description from the first attribute found

C. Use a foreach loop on class fields and call GetCustomAttributes on each field

D. Use reflection to get properties of the class and print their names

Solution

1. Step 1: Identify target elements

   The attribute InfoAttribute is applied to methods, so we must get methods via reflection.

2. Step 2: Read attributes per method

   For each MethodInfo, call GetCustomAttributes with InfoAttribute type to get the attribute instance and access its Description property.

3. Step 3: Print descriptions

   Print the Description property for each method's attribute found.

4. Final Answer:

   Use reflection to get MethodInfo array, then for each method call GetCustomAttributes(typeof(InfoAttribute), false) and print the Description property -> Option A

5. Quick Check:

   Read attributes per method, not class or fields [OK]

Hint: Get methods, then read attributes on each method [OK]

Common Mistakes:

• Reading attributes only on class instead of methods
• Checking fields instead of methods
• Assuming one attribute for whole class