Skip to content
Related Articles

Related Articles

Improve Article
What is Reflection in C#?
  • Last Updated : 28 Aug, 2019

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:

ClassDescription
Assemblydescribes an assembly which is a reusable, versionable, and self-describing building block of a common language runtime application
AssemblyNameIdentifies an assembly ith a unique name
ConstructorInfoDescribes a class constructor and gives access to the metadata
MethodInfoDescribes the class method and gives access to its metadata
ParameterInfoDescribes the parameters of a method and gives access to its metadata
EventInfoDescribes the event info and gives accessto its metadata
PropertyInfoDiscovers the attributes of a property and provides access to property metadata
MemberInfoObtains 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.




// 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.




// 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



My Personal Notes arrow_drop_up
Recommended Articles
Page :