How reflection bypasses compile-time safety in C Sharp (C#) - Practice Exercises

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of modifying private field using reflection

What is the output of this C# code that uses reflection to change a private field value?

C Sharp (C#)

using System;
using System.Reflection;

class Person {
    private string name = "Alice";
    public void PrintName() {
        Console.WriteLine(name);
    }
}

class Program {
    static void Main() {
        Person p = new Person();
        p.PrintName();
        FieldInfo fi = typeof(Person).GetField("name", BindingFlags.NonPublic | BindingFlags.Instance);
        fi.SetValue(p, "Bob");
        p.PrintName();
    }
}

A Alice\nBob

B Alice\nAlice

C Compilation error due to private field access

D Runtime exception: FieldInfo is null

💡 Hint

Reflection can access private members at runtime, bypassing compile-time restrictions.

The code first prints the original private field value 'Alice'. Then reflection accesses the private field 'name' and sets it to 'Bob'. The second print shows 'Bob'. No compile error or exception occurs because reflection bypasses compile-time safety.

🧠 Conceptual

intermediate

Why reflection bypasses compile-time safety

Why does using reflection in C# allow code to bypass compile-time safety checks?

A Because reflection modifies the source code before compilation

B Because reflection only works with public members, so safety is not bypassed

C Because reflection disables the compiler's type checking permanently

D Because reflection works at runtime and can access metadata and members regardless of access modifiers

💡 Hint

Think about when reflection operates and what it can access.

Reflection operates at runtime and uses metadata to access members, including private ones, ignoring compile-time access restrictions. It does not modify source code or disable compiler checks.

🔧 Debug

advanced

Identify the runtime error caused by reflection misuse

What runtime error will this code produce when trying to set a non-existent field using reflection?

C Sharp (C#)

using System;
using System.Reflection;

class Sample {
    private int value = 10;
}

class Program {
    static void Main() {
        Sample s = new Sample();
        FieldInfo fi = typeof(Sample).GetField("nonExistentField", BindingFlags.NonPublic | BindingFlags.Instance);
        fi.SetValue(s, 20);
    }
}

A ArgumentException

B NullReferenceException

C FieldAccessException

D No exception, sets value to 20

💡 Hint

What happens if GetField returns null and you call SetValue on it?

GetField returns null if the field does not exist. Calling SetValue on null causes a NullReferenceException at runtime.

❓ Predict Output

advanced

Output of invoking private method via reflection

What will this C# program print when it invokes a private method using reflection?

C Sharp (C#)

using System;
using System.Reflection;

class Calculator {
    private int Double(int x) {
        return x * 2;
    }
}

class Program {
    static void Main() {
        Calculator calc = new Calculator();
        MethodInfo mi = typeof(Calculator).GetMethod("Double", BindingFlags.NonPublic | BindingFlags.Instance);
        int result = (int)mi.Invoke(calc, new object[] { 5 });
        Console.WriteLine(result);
    }
}

A 10

B 5

C Runtime exception: MethodInfo is null

D Compilation error due to private method access

💡 Hint

Reflection can invoke private methods at runtime.

The private method Double multiplies input by 2. Reflection finds and invokes it with argument 5, returning 10. No compile error or exception occurs.

🧠 Conceptual

expert

Security risks of reflection bypassing compile-time safety

Which of the following is a major security risk caused by reflection bypassing compile-time safety in C#?

A Slower compilation times due to reflection metadata processing

B Compile-time errors that prevent program execution

C Unauthorized access to private data or methods leading to data leaks or manipulation

D Inability to use inheritance and polymorphism

💡 Hint

Think about what private means and what happens if reflection ignores it.

Reflection can access private members, which can expose sensitive data or allow unauthorized changes, creating security vulnerabilities. It does not cause compile errors or affect inheritance.

Practice

1. What does reflection in C# allow a program to do that bypasses compile-time safety?

easy

A. Generate compile-time warnings for unsafe code

B. Automatically optimize code for better performance

C. Inspect and modify types and members at runtime, ignoring compile-time checks

D. Prevent runtime errors by enforcing strict type checks

Solution

1. Step 1: Understand reflection capabilities and identify how compile-time safety is bypassed

   Reflection allows a program to look at its own structure and change it while running, which is not checked at compile time. Because reflection works at runtime, it can access private members and change types without compile-time type checking.

2. Final Answer:

   Inspect and modify types and members at runtime, ignoring compile-time checks -> Option C

3. Quick Check:

   Reflection bypasses compile-time safety = D [OK]

Hint: Reflection works at runtime, ignoring compile-time checks [OK]

Common Mistakes:

• Thinking reflection improves compile-time safety
• Confusing reflection with compile-time code generation
• Assuming reflection prevents runtime errors

2. Which of the following C# code snippets correctly uses reflection to get the name of a private field called _secret from a class MyClass?

easy

A. var field = typeof(MyClass).GetMethod("_secret", BindingFlags.NonPublic);

B. var field = typeof(MyClass).GetField("_secret");

C. var field = typeof(MyClass).GetProperty("_secret", BindingFlags.Public);

D. var field = typeof(MyClass).GetField("_secret", BindingFlags.NonPublic | BindingFlags.Instance);

Solution

1. Step 1: Identify correct reflection method for fields and use correct BindingFlags for private instance fields

   To get a field, use GetField, not GetProperty or GetMethod. Private fields require BindingFlags.NonPublic and BindingFlags.Instance to be accessed.

2. Final Answer:

   var field = typeof(MyClass).GetField("_secret", BindingFlags.NonPublic | BindingFlags.Instance); -> Option D

3. Quick Check:

   Correct BindingFlags for private field = A [OK]

Hint: Use BindingFlags.NonPublic | BindingFlags.Instance for private fields [OK]

Common Mistakes:

• Omitting BindingFlags causing null result
• Using GetProperty instead of GetField
• Using BindingFlags.Public for private members

3. Consider this C# code snippet using reflection:

class Person { private int age = 30; }

var p = new Person();
var field = typeof(Person).GetField("age", BindingFlags.NonPublic | BindingFlags.Instance);
field.SetValue(p, 40);
Console.WriteLine(field.GetValue(p));

What will be the output when this code runs?

medium

A. 40

B. 30

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Understand reflection access to private field and trace the value change and output

   The code uses reflection with correct BindingFlags to access and modify the private field age. The field value is set to 40, then retrieved and printed, so output is 40.

2. Final Answer:

   40 -> Option A

3. Quick Check:

   Reflection sets private field value = 40 [OK]

Hint: Reflection can change private fields at runtime [OK]

Common Mistakes:

• Assuming private fields cannot be changed
• Expecting compile-time error
• Thinking output remains original value

4. This code attempts to use reflection to invoke a private method Calculate in class Calculator. What is the error and how to fix it?

var calc = new Calculator();
var method = typeof(Calculator).GetMethod("Calculate");
method.Invoke(calc, null);

medium

A. GetMethod returns null because it needs BindingFlags.NonPublic; fix by adding BindingFlags.NonPublic | BindingFlags.Instance

B. Invoke requires parameters array; fix by passing new object[] { }

C. Calculator class must be public; fix by making class public

D. Calculate method must be static; fix by declaring static

Solution

1. Step 1: Identify why GetMethod returns null and fix by adding correct BindingFlags

   By default, GetMethod only finds public methods. Private methods require BindingFlags.NonPublic and BindingFlags.Instance. Use GetMethod("Calculate", BindingFlags.NonPublic | BindingFlags.Instance) to find the private method.

2. Final Answer:

   GetMethod returns null because it needs BindingFlags.NonPublic; fix by adding BindingFlags.NonPublic | BindingFlags.Instance -> Option A

3. Quick Check:

   Missing BindingFlags causes null method = A [OK]

Hint: Add BindingFlags.NonPublic to access private methods [OK]

Common Mistakes:

• Not using BindingFlags.NonPublic
• Passing null instead of empty object array to Invoke
• Assuming method must be static

5. You want to use reflection to dynamically create an instance of a class named Plugin and call its private method Initialize. Which sequence of reflection calls correctly bypasses compile-time safety to achieve this?

hard

A. Use typeof(Plugin).GetConstructor(null).Invoke(null) then GetMethod("Initialize") without BindingFlags

B. Use Activator.CreateInstance(typeof(Plugin)) then GetMethod("Initialize", BindingFlags.NonPublic | BindingFlags.Instance) and invoke it

C. Use new Plugin() then call Initialize() directly

D. Use Activator.CreateInstance("Plugin") then GetMethod("Initialize", BindingFlags.Public)

Solution

1. Step 1: Create instance dynamically, access private method with correct BindingFlags, and invoke the private method

   Activator.CreateInstance(typeof(Plugin)) creates an instance at runtime without compile-time type knowledge. GetMethod with BindingFlags.NonPublic | BindingFlags.Instance accesses the private Initialize method. Invoke calls the method on the created instance, bypassing compile-time safety.

2. Final Answer:

   Use Activator.CreateInstance(typeof(Plugin)) then GetMethod("Initialize", BindingFlags.NonPublic | BindingFlags.Instance) and invoke it -> Option B

3. Quick Check:

   Dynamic instance + private method access = C [OK]

Hint: Use Activator + BindingFlags.NonPublic to call private methods [OK]

Common Mistakes:

• Calling private method without BindingFlags.NonPublic
• Using new instead of Activator for dynamic creation
• Wrong BindingFlags causing method not found