C# Reflection Tutorial with Examples (2025 Guide) | Tpoint Tech

In this C# Reflection tutorial, we’ll explore one of the most powerful features of the C# programming language — the ability to inspect and interact with types, methods, properties, and assemblies at runtime. Whether you are building frameworks, debugging tools, or dynamic systems, C# Reflection allows you to write flexible and reusable code.

This 2025 guide from Tpoint Tech will walk you through the fundamentals of Reflection, its use cases, and hands-on examples to help you master it easily.

What Is C# Reflection?

C# Reflection is a mechanism that enables a program to examine and manipulate its own metadata and code structure during execution. In simple terms, Reflection allows your program to discover information about loaded assemblies, classes, methods, properties, and other members — even if they were not known at compile time.

Reflection belongs to the System.Reflection namespace in .NET. You can use it to:

• Retrieve information about assemblies, modules, and types.
• Create instances of types dynamically.
• Invoke methods and access fields or properties at runtime.
• Work with custom attributes or metadata.

Why Use C# Reflection?

Reflection is extremely useful in scenarios where you need flexibility and runtime inspection. Some common use cases include:

1. Developing Frameworks and Libraries – Many .NET frameworks (like Entity Framework or NUnit) use Reflection to identify attributes, properties, and methods dynamically.
2. Building Plugins or Add-ons – You can load external assemblies at runtime and invoke their classes or methods without prior knowledge.
3. Serialization and Deserialization – Reflection helps map class properties to file formats like JSON or XML.
4. Debugging and Diagnostics – Tools use Reflection to analyze program structure or generate documentation.
5. Dynamic Invocation – It allows executing methods without hardcoding method names.

Namespaces and Classes Used in Reflection

To use C# Reflection, you need to include the following namespace:

using System;
using System.Reflection;

Important classes inside the System.Reflection namespace include:

• Assembly – Represents an assembly and allows you to load or inspect it.
• Type – Provides information about classes, interfaces, enums, and other data types.
• MethodInfo, PropertyInfo, FieldInfo – Represent metadata about members of a class.
• ConstructorInfo – Provides information about constructors.

Example 1: Getting Type Information Using Reflection

Let’s start with a simple example that shows how to inspect a class using Reflection.

using System;
using System.Reflection;

namespace ReflectionExample
{
    public class Student
    {
        public int Id { get; set; }
        public string Name { get; set; }

        public void Display()
        {
            Console.WriteLine($"Student ID: {Id}, Name: {Name}");
        }
    }

    class Program
    {
        static void Main()
        {
            Type type = typeof(Student);

            Console.WriteLine("Class Name: " + type.Name);
            Console.WriteLine("Namespace: " + type.Namespace);

            Console.WriteLine("\nProperties:");
            foreach (var prop in type.GetProperties())
            {
                Console.WriteLine(prop.Name);
            }

            Console.WriteLine("\nMethods:");
            foreach (var method in type.GetMethods())
            {
                Console.WriteLine(method.Name);
            }
        }
    }
}

Output:

Class Name: Student
Namespace: ReflectionExample

Properties:
Id
Name

Methods:
get_Id
set_Id
get_Name
set_Name
Display
ToString
Equals
GetHashCode
GetType

Explanation:
Here, we used the typeof() operator to obtain a Type object representing the Student class. Then we listed all properties and methods dynamically using GetProperties() and GetMethods().

Example 2: Creating an Instance Dynamically Using Reflection

You can create an instance of a class at runtime even if you don’t know the type beforehand.

using System;
using System.Reflection;

namespace ReflectionExample
{
    public class Employee
    {
        public void ShowMessage()
        {
            Console.WriteLine("Welcome to Tpoint Tech!");
        }
    }

    class Program
    {
        static void Main()
        {
            Assembly assembly = Assembly.GetExecutingAssembly();
            Type type = assembly.GetType("ReflectionExample.Employee");

            object obj = Activator.CreateInstance(type);
            MethodInfo method = type.GetMethod("ShowMessage");
            method.Invoke(obj, null);
        }
    }
}

Output:

Welcome to Tpoint Tech!

Explanation:

• The Assembly class loads the currently executing assembly.
• GetType() fetches the Employee class.
• Activator.CreateInstance() creates an object dynamically.
• Invoke() executes the ShowMessage() method at runtime.

Example 3: Accessing Private Members with Reflection

Reflection can even access private fields or methods (use this carefully and only when necessary):

using System;
using System.Reflection;

public class Demo
{
    private string secret = "Confidential Data";

    private void DisplaySecret()
    {
        Console.WriteLine(secret);
    }
}

class Program
{
    static void Main()
    {
        Demo demo = new Demo();
        Type type = typeof(Demo);

        FieldInfo field = type.GetField("secret", BindingFlags.NonPublic | BindingFlags.Instance);
        field.SetValue(demo, "Updated Secret Data");

        MethodInfo method = type.GetMethod("DisplaySecret", BindingFlags.NonPublic | BindingFlags.Instance);
        method.Invoke(demo, null);
    }
}

Output:

Updated Secret Data

Explanation:
Using BindingFlags.NonPublic, we accessed private members of the class and modified their values.

Best Practices for Using Reflection

While C# Reflection is powerful, it comes with some trade-offs:

• Performance Overhead – Reflection is slower than direct access, so avoid using it in performance-critical code.
• Security Concerns – Accessing private members can break encapsulation; use it responsibly.
• Maintainability – Code using Reflection can be harder to read and debug.

Whenever possible, prefer strongly-typed code and use Reflection only when necessary.

Conclusion

In this C# Reflection Tutorial (2025 Guide) by Tpoint Tech, we learned how Reflection helps developers inspect and manipulate program metadata dynamically. From retrieving type information to invoking methods and creating instances at runtime, Reflection unlocks a new level of flexibility in your C# applications.

Use it wisely to build dynamic, plugin-based systems, frameworks, and tools — but keep in mind its performance and maintainability implications.

If you want to explore more advanced C# tutorials, visit Tpoint Tech for practical, real-world programming examples and up-to-date .NET development guides.