Reflection

What Is Reflection?

Reflection is a programming capability that allows a program to inspect, analyze, and modify its own structure and behavior at runtime. This includes examining classes, methods, fields, and other metadata — and in many languages, even dynamically invoking or modifying them.

Reflection is like giving a program the ability to “look in a mirror” and act on what it sees.

It is widely used in object-oriented and dynamic languages for:

Dependency injection
Testing
Serialization
Framework development
Metaprogramming

1. Why Use Reflection?

Use Case	Purpose
Debugging Tools	Introspect variables and call stacks
Serialization Libraries	Access private fields, nested structures
Dependency Injection	Load classes and inject objects at runtime
ORM Frameworks	Map object fields to database tables
Test Automation	Discover and invoke test methods dynamically

2. Reflection in Java

Java has a powerful reflection API in the java.lang.reflect package.

Basic Example:

import java.lang.reflect.*;

public class Demo {
    public String greet(String name) {
        return "Hello, " + name;
    }
}

Class clazz = Demo.class;
Method method = clazz.getMethod("greet", String.class);
String result = (String) method.invoke(new Demo(), "Alice");

System.out.println(result);  // Hello, Alice

Reflection Capabilities in Java:

Feature	API Example
Inspect class name	`clazz.getName()`
List fields	`clazz.getDeclaredFields()`
Invoke method	`method.invoke(obj, args)`
Access private field	`field.setAccessible(true)`

3. Reflection in Python

Python offers reflection through its built-in functions and modules like getattr, setattr, and inspect.

Example:

class Person:
    def __init__(self, name):
        self.name = name

    def greet(self):
        return f"Hi, I’m {self.name}"

p = Person("Alice")

# Access attribute dynamically
print(getattr(p, 'name'))      # Alice

# Call method by name
print(getattr(p, 'greet')())   # Hi, I’m Alice

Python also allows:

Checking types (type, isinstance)
Getting class hierarchy (__bases__)
Listing members (dir, vars)
Full introspection via inspect module

4. Reflection in C#

C# provides reflection via the System.Reflection namespace.

Example:

Type type = typeof(MyClass);
MethodInfo method = type.GetMethod("Greet");
object result = method.Invoke(new MyClass(), new object[] { "Alice" });
Console.WriteLine(result);

Reflection in C# allows access to:

Metadata (attributes, names)
Runtime method invocation
Constructor discovery
Assembly loading

5. Reflection in JavaScript

JavaScript has dynamic typing, so many reflection-like capabilities are native.

Examples:

const obj = {
  name: "Alice",
  greet() { return `Hi, ${this.name}` }
};

console.log(obj["name"]);           // Alice
console.log(obj["greet"]());        // Hi, Alice

With ES6+ and Reflect API:

Reflect.set(obj, 'name', 'Bob');
console.log(Reflect.get(obj, 'name'));  // Bob

6. Common Capabilities of Reflection

Operation	Description
Inspect class name	View the name or type of the object
Enumerate methods	List available methods or functions
Read/write fields	Get or set instance variables dynamically
Call methods	Invoke functions with arguments
Check types	Runtime type checking
Create objects	Instantiate a class dynamically
Analyze decorators	Read annotations or attributes

7. Reflection vs Introspection

Concept	Description
Reflection	Ability to inspect and modify code structures at runtime
Introspection	Ability to inspect but not modify structures (read-only)

Languages like Python support both, whereas some like Go or Rust support introspection with limited reflection.

8. Performance Considerations

Reflection can be significantly slower than direct method or field access because:

It bypasses optimizations
It may require extra safety checks
It often works with generic objects (type erasure)

Best Practices:

Avoid reflection in performance-critical paths
Cache reflective lookups if repeated
Consider alternatives like code generation or decorators

9. Security Considerations

Improper use of reflection can lead to:

Security vulnerabilities (e.g., accessing private fields)
Sandbox violations in restricted environments
Code injection if external strings are used as method/field names

Tips:

Never use untrusted input directly in reflection
Validate class and method names carefully
Respect encapsulation rules unless necessary

10. Use Cases in Frameworks

Framework / Library	Use of Reflection
Spring (Java)	Dependency injection, bean discovery
Hibernate	Mapping Java classes to DB schemas
Django (Python)	Model inspection, admin interface
.NET Core	Attribute-based configuration
Angular (JS/TS)	Component metadata parsing
Jest / Pytest	Test discovery and dynamic execution

Reflection is often essential to frameworks that require generic extensibility and configuration by convention.

11. Limitations

Limitation	Impact
Runtime-only	No compile-time safety
Hard to debug	Errors may be raised at runtime only
Performance overhead	Slower than direct access
Complex syntax	Especially in statically typed languages
Limited in some languages	e.g., Go restricts reflective access to private fields

12. Alternatives to Reflection

Technique	When to Use
Code Generation	When performance matters and types are known ahead
Dependency Injection	With pre-wired configurations or registries
Decorator Patterns	For extending behavior with less dynamism
Switch-based Dispatch	Where full reflection is overkill

13. Summary

Feature	Description
What it is	Runtime inspection and manipulation of code structures
Main uses	Testing, serialization, dependency injection, dynamic invocation
Languages	Java, Python, C#, JavaScript, Ruby
Risks	Performance, security, complexity
Common APIs	`java.lang.reflect`, `inspect`, `System.Reflection`, `Reflect`