Reflection in C#

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:

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:

Table: Properties in TypeInfo Class in C#

Source: MSDN

Methods in TypeInfo Class

The different methods and their description is given as follows:

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