Reflection in C#

Reflection is the process of examining, inspecting, or modifying the metadata and the behavior of types, objects, and assemblies in a program during runtime.

It allows you to access the information about types, methods, fields, properties, and events, as well as to create and manipulate instances of types, call methods, and access fields and properties.


  1. Reflection in C# allows examining, inspecting, or modifying metadata and behavior at runtime.
  2. Building dynamic plugins, serialization/deserialization of objects, and implementing dependency injection are common use cases for Reflection in C#.
  3. Important classes in the System.Reflection namespace includes MethodInfo - PropertyInfo - FieldInfo - ConstructorInfo and Attribute.
  4. To use Reflection in C#, obtain the Type object and access details about members and metadata.
  5. Reflection in C# may have a performance cost, but caching objects, using BindingFlags, and considering dynamic methods can help improve performance.

Why Reflection in C# is useful?

Reflection in C# is useful in various scenarios, such as:

  1. Building dynamic plugins or extensible systems that can load and execute code at runtime.
  2. Implementing serialization and deserialization of objects, especially in cases where the object structure is not known at compile time.
  3. Implementing dependency injection ( DI ) or inversion of control frameworks ( IoC ), which typically involve creating and managing objects at runtime.
  4. Inspecting and analyzing code for debugging, profiling, or generating documentation.

Key classes and methods in the Reflection C#

  1. System.Reflection namespace: Provides classes for inspecting and interacting with types and their members.
  2. Type: Represents a type in the C# language. It provides methods to get information about the type, its members, and its attributes.
  3. MethodInfo: Represents a method in a class. It allows you to retrieve information about the method and invoke it.
  4. PropertyInfo: Represents a property in a class. It enables you to get and set the value of a property.
  5. FieldInfo: Represents a field in a class. It allows you to get and set the value of a field.
  6. ConstructorInfo: Represents a constructor in a class. It enables you to create an instance of the class using the specified constructor.
  7. Attribute: Represents an attribute applied to a type or member. It allows you to retrieve information about the attribute and its properties.

How to use the Reflection in C# code at runtime

To explore code at runtime using the Reflection, you can use the following steps:

  1. Obtain the Type object for the class or type you want to inspect.
  2. You can utilize the methods offered by the Type object to obtain details regarding the members (such as methods, properties, fields, and so on) of the class.
  3. For each member, you can use the corresponding MethodInfo, PropertyInfo, FieldInfo, or ConstructorInfo object to interact with the member, such as invoking a method or getting the value of a property.

To get the properties, methods, and fields of a class using Reflection, you can use the following code:

Type myType = typeof(MyClass);
PropertyInfo[] properties = myType.GetProperties();
MethodInfo[] methods = myType.GetMethods();
FieldInfo[] fields = myType.GetFields();

To retrieve metadata with Reflection such as the type, name, and value of a property , you can use the following code:

Type propertyType = propertyInfo.PropertyType;
string propertyName = propertyInfo.Name;
object propertyValue = propertyInfo.GetValue(myObject);

To inspect the attributes of a class using Reflection in C#, you can use the following code:

Type myType = typeof(MyClass);
object[] attributes = myType.GetCustomAttributes(true);
foreach (Attribute attribute in attributes)

Using Reflection to dynamically create an instance of a class

Type myType = typeof(MyClass);
MyClass myObject = (MyClass)Activator.CreateInstance(myType);

Creating objects with Reflection C# using the Activator class

The Activator class provides methods to create instances of types, as shown in the example above. It is valuable when you don't know the object type at compile time, and you want to create an instance of it at runtime.

To invoke constructor with Reflection in C# using the ConstructorInfo class

Type myType = typeof(MyClass);
ConstructorInfo constructorInfo = myType.GetConstructor(Type.EmptyTypes);
MyClass myObject = (MyClass)constructorInfo.Invoke(null);

To invoke methods on an object using Reflection in C#, you can use the following code:

Type myType = typeof(MyClass);
MethodInfo methodInfo = myType.GetMethod("MyMethod");
object result = methodInfo.Invoke(myObject, null);

Invoking methods with Reflection in C# that have parameters

Type myType = typeof(MyClass);
MethodInfo methodInfo = myType.GetMethod("MyMethodWithParameters");
object[] parameters = new object[] { "parameter1", 42 };
object result = methodInfo.Invoke(myObject, parameters);

Invoking static methods with Reflection C#

Type myType = typeof(MyClass);
MethodInfo methodInfo = myType.GetMethod("MyStaticMethod");
object result = methodInfo.Invoke(null, null);

The performance cost of using Reflection in C#

Using Reflection in C# can be slower than using direct method calls or field accesses because it involves additional steps, such as looking up the metadata and creating objects dynamically. The performance cost may be noticeable when using Reflection extensively or in performance-critical scenarios.

Techniques for improving the performance of Reflection

  1. Cache Reflection objects, such as Type, MethodInfo, and PropertyInfo, if they are used repeatedly.
  2. Use the BindingFlags enumeration to filter the members you are interested in when calling methods like GetMethods or GetProperties.
  3. Consider using dynamic methods or expression trees for more efficient code generation and execution.

When to use Reflection in C# and when to avoid it

Reflection should be used when:

  1. You need to create or manipulate objects, call methods, or access fields and properties dynamically at runtime.
  2. You are implementing extensible systems, plugins, or frameworks that require loading and executing code dynamically.
  3. You are working with code that you cannot modify at compile time.

Reflection should be avoided when:

  1. Performance is a critical concern, and the overhead of using Reflection is not acceptable.
  2. You have access to the source code and can modify it directly or use more efficient alternatives, such as generics or interfaces.


In summary, Reflection in C# is a powerful feature that allows you to explore and interact with the code at runtime. It is particularly useful in scenarios where you need to create or manipulate objects, call methods, or access fields and properties dynamically. However, it comes with a performance cost, and you should consider using more efficient alternatives when possible. As C# continues to evolve, we can expect further improvements and enhancements to the Reflection, making it even more versatile and powerful in the future.

You can read more about Reflection in C# and C# Attributes from other articles we have in our website.