What is Reflection in C#?

Last Updated : 19 Jul, 2024

Reflection is the process of describing the metadata of types, methods and fields in a code. The namespace System.Reflection enables you to obtain data about the loaded assemblies, the elements within them like classes, methods and value types. Some of the commonly used classes of System.Reflection are:

Class	Description
Assembly	describes an assembly which is a reusable, versionable, and self-describing building block of a common language runtime application
AssemblyName	Identifies an assembly with a unique name
ConstructorInfo	Describes a class constructor and gives access to the metadata
MethodInfo	Describes the class method and gives access to its metadata
ParameterInfo	Describes the parameters of a method and gives access to its metadata
EventInfo	Describes the event info and gives accessto its metadata
PropertyInfo	Discovers the attributes of a property and provides access to property metadata
MemberInfo	Obtains information about the attributes of a member and provides access to member metadata

Note:

There are numerous other classes, the above table gives info about only the commonly used. Let us now look at an example to depict how reflection works in C#.

Example 1:

In the code given below, we load the type t as a string using the typeof method. Then we apply reflection on t to find any information about string class, like its name, fullname, namespace, and basetype.

csharp

// C# program to illustrate
// the use of Reflection
using System;
using System.Reflection;

namespace Reflection_Demo {
    
class Program {
    
    // Main Method
    static void Main(string[] args)
    {
        // Initialise t as typeof string
        Type t = typeof(string);

        // Use Reflection to find about
        // any sort of data related to t
        Console.WriteLine("Name : {0}", t.Name);
        Console.WriteLine("Full Name : {0}", t.FullName);
        Console.WriteLine("Namespace : {0}", t.Namespace);
        Console.WriteLine("Base Type : {0}", t.BaseType);
    }
}
}

Output:

Name : String
Full Name : System.String
Namespace : System
Base Type : System.Object

Example 2:

In this code, we use reflection to show all the metadata related to the program which includes classes, methods of these classes and the parameters associated with these parameters.

csharp

// C# program to illustrate
// the use of Reflection
using System;
using System.Reflection;

namespace Reflection_Metadata {
    
// Define a class Student
class Student {
    
    // Properties definition
    public int RollNo
    {
        get;
        set;
    }
    
    public string Name
    {
        get;
        set;
    }

    // No Argument Constructor
    public Student()
    {
        RollNo = 0;
        Name = string.Empty;
    }

    // Parameterised Constructor
    public Student(int rno, string n)
    {
        RollNo = rno;
        Name = n;
    }

    // Method to Display Student Data
    public void displayData()
    {
        Console.WriteLine("Roll Number : {0}", RollNo);
        Console.WriteLine("Name : {0}", Name);
    }
}

class GFG {
    
    // Main Method
    static void Main(string[] args)
    {
        // Declare Instance of class Assembly
        // Call the GetExecutingAssembly method
        // to load the current assembly
        Assembly executing = Assembly.GetExecutingAssembly();

        // Array to store types of the assembly
        Type[] types = executing.GetTypes();
        foreach(var item in types)
        {
            // Display each type
            Console.WriteLine("Class : {0}", item.Name);

            // Array to store methods
            MethodInfo[] methods = item.GetMethods();
            foreach(var method in methods)
            {
                // Display each method
                Console.WriteLine("--> Method : {0}", method.Name);

                // Array to store parameters
                ParameterInfo[] parameters = method.GetParameters();
                foreach(var arg in parameters)
                {
                    // Display each parameter
                    Console.WriteLine("----> Parameter : {0} Type : {1}",
                                            arg.Name, arg.ParameterType);
                }
            }
        }
    }
}
}

Output:

 Class : Student
--> Method : get_RollNo
--> Method : set_RollNo
----> Parameter : value  Type : System.Int32
--> Method : get_Name
--> Method : set_Name
----> Parameter : value  Type : System.String
--> Method : displayData
--> Method : ToString
--> Method : Equals
----> Parameter : obj  Type : System.Object
--> Method : GetHashCode
--> Method : GetType

 Class : Program
--> Method : ToString
--> Method : Equals
----> Parameter : obj  Type : System.Object
--> Method : GetHashCode
--> Method : GetType

Late Binding using Reflection in C#

ManasiKirloskar

Improve

Article Tags :

What is Reflection in C#?

Similar Reads

Thank You!

What kind of Experience do you want to share?