Why reflection is needed in C Sharp (C#) - Visual Breakdown

Concept Flow - Why reflection is needed

Start Program

↓

Need to inspect type info?

Yes↓

Use Reflection API

↓

Get type metadata

↓

Access properties, methods dynamically

↓

Perform actions based on metadata

↓

End Program

Reflection lets a program look at its own types and members while running, so it can decide what to do dynamically.

Execution Sample

C Sharp (C#)

Type type = typeof(string);
Console.WriteLine(type.Name);
var methods = type.GetMethods();
Console.WriteLine(methods.Length);

This code uses reflection to get the type info of string and prints its name and number of methods.

Execution Table

Step	Action	Evaluation	Result
1	Get type of string	typeof(string)	System.String type object
2	Print type name	type.Name	"String"
3	Get all methods	type.GetMethods()	Array of MethodInfo objects
4	Print number of methods	methods.Length	Number of methods (e.g., 70)
5	End	-	-

💡 All reflection calls completed, program ends.

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
type	null	System.String type object	System.String type object	System.String type object
methods	null	null	Array of MethodInfo objects	Array of MethodInfo objects

Key Moments - 2 Insights

Why do we need to get the type object first?

Reflection works by inspecting a Type object; without it, we cannot access metadata. See step 1 in execution_table.

Why does methods.Length show many methods?

The string type has many inherited and declared methods. Reflection shows all available methods, not just those we wrote. See step 4.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of type.Name at step 2?

A "System.String"

B "string"

C "String"

D "Type"

💡 Hint

Check the 'Evaluation' and 'Result' columns at step 2 in execution_table.

At which step do we get the array of methods?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look for 'Get all methods' action in execution_table.

If we skip getting the type object, what happens to methods variable?

A It becomes null because no type to inspect

B It contains all methods anyway

C It throws an error at runtime

D It contains only one method

💡 Hint

See variable_tracker and key_moments about the importance of type object.

Concept Snapshot

Reflection lets C# programs inspect types and members at runtime.
Use typeof(TypeName) to get type info.
Access properties, methods dynamically via reflection APIs.
Useful for dynamic behavior, plugins, serialization.
Without reflection, code must know types at compile time.

Full Transcript

Reflection in C# allows a program to look at its own types and members while running. This is done by first getting a Type object using typeof(TypeName). Then, reflection methods like GetMethods() let the program see all methods of that type. This helps when the program needs to work with types it did not know about when it was written. For example, it can load plugins or serialize objects dynamically. The execution trace shows getting the string type, printing its name, getting all its methods, and printing how many methods it has. Variables like 'type' and 'methods' hold the reflection data. Reflection is needed because without it, the program cannot inspect or use types dynamically at runtime.