Learn about Reflection in C#

Reflection is a powerful feature in C# that allows you to examine and manipulate the structure and behavior of types dynamically at runtime. It gives you the ability to inspect and retrieve information about types, their properties, methods, and other members, and even modify them programmatically. In this post, we will explore the concept of reflection and understand how it can be utilized in C#.

To start with, let's dive into an example. Consider a scenario where you have a class called "Person" with some properties like Name, Age, and Address. You want to determine the names and types of these properties dynamically, without explicitly knowing them at compile-time. This is where reflection comes into play.

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Address { get; set; }
}

To retrieve the information about the properties in the "Person" class, we can use the Type class and its various methods provided by the System.Reflection namespace. Let's see how we can achieve this:

using System;
using System.Reflection;

class Program
{
    static void Main()
    {
        Type personType = typeof(Person);

        PropertyInfo[] properties = personType.GetProperties();

        foreach (PropertyInfo property in properties)
        {
            Console.WriteLine($"Property Name: {property.Name}");
            Console.WriteLine($"Property Type: {property.PropertyType}");
            Console.WriteLine();
        }
    }
}

By using typeof(Person), we obtain the Type object for the "Person" class. The Type class provides several useful methods, such as GetProperties(), which returns an array of PropertyInfo objects representing the properties of the class.

In the foreach loop, we can iterate over each property and retrieve its name and type using the Name and PropertyType properties provided by the PropertyInfo class.

Running the above code will output the following result:

Property Name: Name
Property Type: System.String

Property Name: Age
Property Type: System.Int32

Property Name: Address
Property Type: System.String

As you can see, we were able to dynamically retrieve the names and types of the properties of the "Person" class using reflection.

Reflection can also be used to dynamically instantiate objects, invoke methods, access private members, and more. It's a powerful feature that opens up a lot of possibilities in terms of flexibility and extensibility. However, it's important to note that reflection comes with performance overhead, so it should be used judiciously.

In conclusion, reflection in C# allows you to inspect and manipulate types dynamically at runtime. It gives you the ability to retrieve information about properties, methods, and other members of a type. Reflection can be a useful tool in scenarios where you need to work with types dynamically, without knowing their structure at compile-time. Keep in mind the performance implications while using reflection and leverage this feature wisely in your code.