What is Reflection in C#?
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 ith 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.
using System;
using System.Reflection;
namespace Reflection_Demo {
class Program {
static void Main( string [] args)
{
Type t = typeof ( string );
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.
using System;
using System.Reflection;
namespace Reflection_Metadata {
class Student {
public int RollNo
{
get ;
set ;
}
public string Name
{
get ;
set ;
}
public Student()
{
RollNo = 0;
Name = string .Empty;
}
public Student( int rno, string n)
{
RollNo = rno;
Name = n;
}
public void displayData()
{
Console.WriteLine( "Roll Number : {0}" , RollNo);
Console.WriteLine( "Name : {0}" , Name);
}
}
class GFG {
static void Main( string [] args)
{
Assembly executing = Assembly.GetExecutingAssembly();
Type[] types = executing.GetTypes();
foreach ( var item in types)
{
Console.WriteLine( "Class : {0}" , item.Name);
MethodInfo[] methods = item.GetMethods();
foreach ( var method in methods)
{
Console.WriteLine( "--> Method : {0}" , method.Name);
ParameterInfo[] parameters = method.GetParameters();
foreach ( var arg in parameters)
{
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
Last Updated :
28 Aug, 2019
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...