How reflection bypasses compile-time safety in C Sharp (C#) - Visual Walkthrough

Concept Flow - How reflection bypasses compile-time safety

Write code with reflection

↓

Compile-time checks skipped

↓

Run-time reflection calls

↓

Access private members or invoke methods

↓

Possible runtime errors if misuse

↓

Program continues or crashes

Reflection lets code inspect and use types at runtime, skipping compile-time safety checks, which can cause runtime errors if used incorrectly.

Execution Sample

C Sharp (C#)

using System;
using System.Reflection;

class Person {
  private string secret = "hidden";
}

class Program {
  static void Main() {
    var p = new Person();
    var secretField = typeof(Person).GetField("secret", BindingFlags.NonPublic | BindingFlags.Instance);
    var value = secretField.GetValue(p);
    Console.WriteLine(value);
  }
}

This code uses reflection to access a private field 'secret' of a Person object and prints its value, bypassing compile-time access restrictions.

Execution Table

Step	Action	Evaluation	Result
1	Create Person instance p	p is new Person()	p created
2	Get FieldInfo for 'secret'	typeof(Person).GetField("secret", BindingFlags.NonPublic | BindingFlags.Instance)	FieldInfo for 'secret' found
3	Get value of 'secret' from p	secretField.GetValue(p)	"hidden"
4	Print value	Console.WriteLine(value)	Output: hidden
5	End	No more code	Program ends

💡 Program ends after printing the private field value, showing reflection bypassed compile-time access rules.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
p	null	Person instance	Person instance	Person instance	Person instance
secretField	null	null	FieldInfo for 'secret'	FieldInfo for 'secret'	FieldInfo for 'secret'
value	null	null	null	"hidden"	"hidden"

Key Moments - 2 Insights

Why can we access a private field 'secret' even though it's private?

Reflection ignores compile-time access modifiers, so at runtime it can access private members, as shown in step 3 of the execution_table.

What happens if the field name is misspelled in GetField?

GetField returns null, so calling GetValue on null causes a runtime error, unlike compile-time errors, shown by missing FieldInfo in step 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'value' after step 3?

A FieldInfo object

B null

C "hidden"

D Person instance

💡 Hint

Check the 'value' variable in variable_tracker after step 3.

At which step does reflection bypass compile-time safety to access private data?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

See execution_table step 3 where GetValue accesses the private field.

If the field name was wrong, what would happen at step 2?

A Program prints null

B FieldInfo would be null, causing runtime error later

C Compile-time error

D Program crashes immediately

💡 Hint

Reflection returns null if field not found, no compile-time error (see key_moments).

Concept Snapshot

Reflection lets you access and modify private members at runtime.
It skips compile-time safety checks.
Use BindingFlags to access non-public members.
Misuse can cause runtime errors.
Always check for null when using reflection.

Full Transcript

This example shows how reflection in C# can access private fields of a class at runtime, bypassing compile-time safety checks. The code creates a Person object, then uses reflection to get the private field 'secret'. It retrieves the value and prints it. The execution table traces each step: creating the object, getting the field info, reading the value, and printing it. Variables change as expected, with 'value' holding the private string after step 3. Key moments clarify why private access is possible and what happens if the field name is wrong. The quiz tests understanding of variable values and reflection behavior. Reflection is powerful but can cause runtime errors if used carelessly.