10X Sale
kh logo
All Courses
  2. Tutorials
  3. Programming Tutorials

Reflection in C#

Updated on Sep 3, 2025
 
45,998 Views
Table of Content

Reflection provide metadata information on types, modules, assemblies etc. at runtime. Therefore, reflection in C# is similar to Runtime Type Information (RTTI) in C++.

Uses of Reflection

Some of the situations when reflections are useful in C# are given as follows:

  1. Reflections are quite useful for creating new types at runtime.
  2. It is easy to use reflection with the program metadata attributes.
  3. Reflection is needed to examine and instantiate types in an assembly.
  4. For late binding to methods and properties, reflections are quite useful.

System.Reflection Namespace

The System.Reflection namespace is required to use reflections as it has classes that allow the user to get the information required about an application. It also allows the user to dynamically add objects, types, values etc. to the application.

Some of the classes in System.Reflection Namespace are as follows:

Classes

Description

AmbiguousMatchException

The exception that is thrown when binding to a member results in more than one member matching the binding criteria. This class cannot be inherited.

AssemblyConfigurationAttribute

This class specifies the build configuration, such as retail or debug, for an assembly.

Binder

This class selects a member from a list of candidates, and performs type conversion from actual argument type to formal argument type.

ConstructorInfo

This class discovers the attributes of a class constructor and provides access to constructor metadata.

EventInfo

This class discovers the attributes of an event and provides access to event metadata

FieldInfo

This class discovers the attributes of a field and provides access to field metadata.

MemberInfo

This class obtains information about the attributes of a member and provides access to member metadata.

Pointer

This class provides a wrapper class for pointers.

ReflectionContext

This class represents a context that can provide reflection objects.

TargetException

This class represents the exception that is thrown when an attempt is made to invoke an invalid target.

TypeInfo

This class represents type declarations for class types, interface types, array types, value types, enumeration types, type parameters, generic type definitions, and open or closed constructed generic types.

Source: MSDN

TypeInfo Class

The TypeInfo class is one of the classes in the System.Reflection namespace. It represents type declarations for class types, array types, interface types, value types, enumeration types etc. This class inherits the IReflectable Type interface.

Properties in TypeInfo Class

The different properties and their description is given as follows:

Properties

Description

CustomAttributes

This property gets a collection that contains this member's custom attributes.

DeclaredConstructors

This property gets a collection of the constructors declared by the current type.

DeclaredEvents

This property gets a collection of the events defined by the current type.

GenericTypeParameters

This property gets an array of the generic type parameters of the current instance.

ImplementedInterfaces

This property gets a collection of the interfaces implemented by the current type.

IsConstructedGenericType

This property gets a value that indicates whether this object represents a constructed generic type. You can create instances of a constructed generic type.

IsContextful

This property gets a value indicating whether the Type can be hosted in a context.

MetadataToken

This property gets a value that identifies a metadata element.

ReflectedType

This property gets the class object that was used to obtain this member.

TypeHandle

This property gets the handle for the current Type.

Table: Properties in TypeInfo Class in C#
Source: MSDN

Methods in TypeInfo Class

The different methods and their description is given as follows:

Methods

Description

AsType()

This method returns the current type as a Type object.

Equals(Object)

This method determines if the underlying system type of the current Type object is the same as the underlying system type of the specified Object.

GetCustomAttributes(Boolean)

When overridden in a derived class, returns an array of all custom attributes applied to this member.

GetDeclaredEvent(String)

This method returns an object that represents the specified public event declared by the current type.

GetDeclaredField(String)

This method returns an object that represents the specified public field declared by the current type.

IsArrayImpl()

When overridden in a derived class, implements the IsArray property and determines whether the Type is an array.

IsContextfulImpl()

This method implements the IsContextful property and determines whether the Type can be hosted in a context.

IsPointerImpl()

When overridden in a derived class, implements the IsPointer property and determines whether the Type is a pointer

IsPrimitiveImpl()

When overridden in a derived class, implements the IsPrimitive property and determines whether the Type is one of the primitive types.

ToString()

This method returns a String representing the name of the current Type.

GetType()

This method gets the current Type.

Table: Methods in TypeInfo Class in C#
Source: MSDN

Now let us see some examples

Program 1: Display methods and properties of a class

Here is an example showing the usage of getting the methods and properties of TextInfo type

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Globalization;
using System.Text;
class Example
{
   static void Main()
   {
           TypeInfo myType = typeof(TextInfo).GetTypeInfo();
           IEnumerable<PropertyInfo> properties = myType.DeclaredProperties;
           IEnumerable<MethodInfo> methods = myType.DeclaredMethods;
           Console.WriteLine(myType);
           Console.WriteLine(properties);
           Console.WriteLine(methods);
           StringBuilder strBuilder = new StringBuilder();
           Console.WriteLine();
           strBuilder.Append("The properties are:");
           foreach (PropertyInfo p in properties)
           {
               strBuilder.Append("\n" + p.Name);
           }
           strBuilder.Append("\n");
           strBuilder.Append("\nThe methods are:");
           foreach (MethodInfo m in methods)
           {
               strBuilder.Append("\n" + m.Name);
           }
           Console.WriteLine(strBuilder);
   }
}

The output of the above program is as follows:

System.Globalization.TextInfo
System.Reflection.PropertyInfo[]
System.Reflection.MethodInfo[]

The properties are:
Invariant
ANSICodePage
OEMCodePage
MacCodePage
EBCDICCodePage
LCID
CultureName
IsReadOnly
ListSeparator
IsAsciiCasingSameAsInvariant
IsRightToLeft

The methods are:
get_Invariant
OnDeserializing
OnDeserialized
OnDeserialized
OnSerializing
GetHashCodeOrdinalIgnoreCase
GetHashCodeOrdinalIgnoreCase
CompareOrdinalIgnoreCase
CompareOrdinalIgnoreCaseEx
IndexOfStringOrdinalIgnoreCase
LastIndexOfStringOrdinalIgnoreCase
get_ANSICodePage
get_OEMCodePage
get_MacCodePage
get_EBCDICCodePage
get_LCID
get_CultureName
get_IsReadOnly
Clone
ReadOnly
VerifyWritable
SetReadOnlyState
get_ListSeparator
set_ListSeparator
ToLower
ToLower
ToLowerAsciiInvariant
ToUpper
ToUpper
ToUpperAsciiInvariant
IsAscii
get_IsAsciiCasingSameAsInvariant
Equals
GetHashCode
ToString
ToTitleCase
AddNonLetter
AddTitlecaseLetter
IsWordSeparator
IsLetterCategory
get_IsRightToLeft
System.Runtime.Serialization.IDeserializationCallback.OnDeserialization
GetCaseInsensitiveHashCode
GetCaseInsensitiveHashCode
GetInvariantCaseInsensitiveHashCode
ToUpperInternal
ToLowerInternal
ToUpperInternal
ToLowerInternal
InternalCompareStringOrdinalIgnoreCase

Program 2: Display the types of various variables using GetType() method

The GetType() method indicates the type of a variable or object. An example that demonstrates this method is as follows:

using System;  
using System.Reflection;  
public class Demo  
{  
   public static void Main()  
   {
       // Type One
       Type type1 = typeof(object[]);
       // Type Two
       Type type2 = "demo string".GetType();
       // Type Three
       int val1 = 50;  
       Type type3 = val1.GetType();  
       Console.WriteLine(type1);
       Console.WriteLine(type1.Name);
       Console.WriteLine(type2);
       Console.WriteLine(type2.Name);
       Console.WriteLine(type3);  
       Console.WriteLine(type3.Name);
   }
}

The output of the above program is as follows:

System.Object[]
Object[]
System.String
String
System.Int32
Int32

Program 3: AssemblyQualifiedName Property

The AssemblyQualifiedName property displays the qualified assembly name associated with a type. The program that demonstrates this property is as follows:

using System;  
using System.Reflection;  
public class Demo  
{  
   public static void Main()  
   {
        Type tp = typeof(System.Object);
       Console.WriteLine ("Qualified assembly name:\n   {0}.",
                          tp.AssemblyQualifiedName.ToString());
   }
}  

The output of the above program is as follows:

Qualified assembly name:
System.Object, mscorlib, Version=4.0.0.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089.

Program 4: Assembly Property

The Assembly property displays the assembly name associated with a type. The program that demonstrates this property is as follows:

using System;  
using System.Reflection;  
public class Demo  
{  
   public static void Main()  
   {
        Type tp = typeof(System.Object);
       Console.WriteLine ("Assembly name:\n   {0}.",
                          tp.Assembly.FullName.ToString());
    }
}

The following is the output:

Qualified assembly name:
  System.Object, mscorlib, Version=4.0.0.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089.

Program 5: Name property

The Name property displays the name of the type. The program that demonstrates this property is as follows:

using System;  
using System.Reflection;  
public class Demo  
{  
   public static void Main()  
   {
       Type tp1 = typeof(System.UInt64);
       Type tp2 = typeof(System.UInt32);
       Type tp3 = typeof(System.UInt16);
       Type tp4 = typeof(System.Uri);
       Console.WriteLine(tp1.Name);  
       Console.WriteLine(tp1.BaseType);  
       Console.WriteLine(tp2.Name);  
       Console.WriteLine(tp2.BaseType);
       Console.WriteLine(tp3.Name);  
       Console.WriteLine(tp3.BaseType);
       Console.WriteLine(tp4.Name);  
       Console.WriteLine(tp4.BaseType);
   }
}

Here is the output:

UInt64
System.ValueType
UInt32
System.ValueType
UInt16
System.ValueType
Uri
System.Object

Program 6: FullName property

The FullName property displays the fully qualified name of the type. The program that demonstrates this property is as follows:

using System;  
using System.Reflection;  
public class Demo  
{  
   public static void Main()  
   {
       Type tp = typeof(System.SByte);  
       Console.WriteLine(tp.FullName);  
       Console.WriteLine(tp.BaseType);  
   }
}  

Here is the output:

System.SByte
System.ValueType
+91

By Signing up, you agree to ourTerms & Conditionsand ourPrivacy and Policy

Get your free handbook for CSM!!
Recommended Courses