Reflection in C# with Examples

What is Reflection in C#?

Reflection in C# is a mechanism that provides access to type information at runtime. It allows developers to examine, query, and modify elements in an assembly, such as classes, methods, fields, and properties, without having prior knowledge of their existence. The System.Reflection namespace in C# contains classes that facilitate reflection operations. Developers can use reflection to dynamically create objects, invoke methods, and access properties, making it particularly useful in scenarios where the structure of types may vary during runtime. Here's a table outlining some important classes in the System.Reflection namespace:

Examples

Let's explore some practical examples to understand how reflection works in C#.

Example 1: Accessing Type Information

Output:

In this example, we define a class MyClass with a property MyProperty and a method MyMethod. In the Main method, we use reflection to obtain type information of MyClass. We then retrieve and print the names of properties and methods available in the class.

Example 2: Creating an Object Using Reflection

Output:

In this example, we define a class Person with properties Name and Age, as well as a method Greet(). In the Main method, we use reflection to create an instance of the Person class. We set the Name and Age properties using reflection. Finally, we invoke the Greet() method, and it prints the greeting with the name and age we set dynamically.

Applications of Reflection in C#:

Reflection is a powerful feature in C# that opens up a wide array of applications, enabling developers to create dynamic, flexible, and extensible software. Let's explore some key applications of reflection:

• Dependency Injection (DI): Reflection is fundamental to implementing Dependency Injection frameworks and containers. DI involves providing the required objects (dependencies) to a class rather than the class creating them itself. Reflection allows DI containers to identify the dependencies required by a class, instantiate them, and inject them into the class at runtime, promoting loose coupling and easier maintenance.
• Unit Testing: Reflection facilitates automated unit testing by providing the ability to access private and internal members of classes for testing purposes. Testing frameworks often use reflection to inspect and invoke private methods, set private fields, or access internal properties, helping to create comprehensive test suites.
• Plugin Architecture: Reflection is essential in developing plugin-based architectures, where new functionality can be added to an application without modifying its core code. Reflection enables applications to discover and load external plugins dynamically at runtime, allowing developers to extend applications seamlessly.
• Serialization and Deserialization: Serialization is the process of converting an object into a format suitable for storage or transmission, and deserialization is the reverse process. Reflection is used to inspect the structure of objects during serialization and deserialization, making it possible to serialize/deserialize objects of varying types and structures.
• Object Mapping: Object mapping libraries, like AutoMapper, use reflection to map data between objects with different structures. By analyzing object properties at runtime, these libraries automatically map corresponding properties between objects, reducing manual mapping code and improving code maintainability.
• User Interface (UI) Generation: Reflection can be employed to automatically generate user interfaces for data objects or entities. By analyzing object properties, developers can dynamically generate UI elements like forms and data grids, saving development time and effort.

Viewing Metadata with C# Reflection

C# Reflection not only allows dynamic access to types and members but also grants access to valuable metadata associated with them. Through reflection, developers can:

• Inspect type information, including names, base types, and interfaces.
• Retrieve method signatures, return types, and parameter information.
• Access and analyze attributes attached to types and members.
• Examine assembly details such as version numbers and authors.
• Discover custom types dynamically, aiding extensibility and modularity.
• Instantiate types dynamically by reflecting on constructors.
• Work with generic types and their parameters.

Reflection empowers developers to leverage metadata at runtime, enabling the creation of flexible and adaptable C# applications. However, cautious use is advised due to potential performance implications.