An Introduction to Reflection in C#

Introduction

In this article, we will see something about reflection in .NET. First, we will see what the System.Reflectionnamespace will do for .NET developers. Reflection allows the inspection of metadata in a PE file and late binding (run time) to types and their members. The System.Reflection namespace defines the following types to analyze the module's metadata of an assembly: Assembly, Module, Enum, ParameterInfo, MemberInfo,Type, MethodInfo, ConstructorInfo, FieldInfo, EventInfo, and PropertyInfo.

The System.Type class is the main class for reflection. The System.Type class is an abstract class and that represents a type in the Common Type System (CLR). By using this class, we can find the type name, the types used in a module (an assembly may contain one or more modules) and namespace, and to see whether a given type is a value or a reference type, and so on. It also allows us to query the type's fields, methods, properties, and events by parsing the corresponding metadata tables. FCL's Serialization mechanism uses reflection to determine what fields a type defines. The serialization formatter then can obtain the values of these fields and write them into the byte stream.

Late bindings can be achieved by using reflection. For example, in some applications, we don't know which assembly to load during compile time, so we ask the user to enter the assembly name and type during run time and the application can load assembly. For this purpose, the System.Reflection.Assembly type offers three static methods that allow you to explicitly load an assembly: Load, LoadFrom, and LoadWithPartialName. These methods are something similar to the LoadLibrary Win32 API. As our System.Reflection namespace is going to work with assembly and metadata, let's see something about assembly and metadata.

Assembly and Metadata

An assembly is a logical DLL or EXE, and a manifest is a detailed description (metadata) of an assembly. The .NET compiler produces a portable executable PE file for CLR with the extensions of .exe or .dll. This PE file is mainly comprised of metadata and IL (Intermediate Language). Metadata contains a number of different tables; for example, a type definition table, a filed definition table, a method definition table, and so forth. By parsing these tables, we can get an assembly's types and attributes. The FCL's System.Reflection namespace supports several types to reflect over or parse these metadata tables.

PE (Portable Executable) = Metadata (bunch definition tables) + IL (Microsoft Intermediate Language) + Some other data which are not relevant to this article.

Example: Reflecting Types (Querying Types)

The following code shows how to query a type for its attributes using the System.Type class. Refer to the download project ReflectionQueryTest.zip. The ReflectType(string) method takes type string and queries all attributes for that type. Call this method by sending different types as parameters. To call different Reflection classes, include using System.Reflection;

 
 
using System;
using System.Reflection;
 
namespace ReflectionQueryTest
{
 
  public class TestBaseClass {}
 
  public class TestDerivedClass : TestBaseClass {}
 
  struct TestStruct {}
 
  interface TestInterface {}
 
  class TestAttribute : System.Attribute {}
 
  enum TestEnum {}
 
  class Class1
  {
    private static void ReflectType(string sTypeName)
    {
      try
      {
        // get the type from the given string
        Type type = Type.GetType(sTypeName);
 
        Console.WriteLine("Type name: {0}", type.FullName);
        Console.WriteLine("\tHasElementType = {0}",
                          type.HasElementType);
        Console.WriteLine("\tIsAbstract = {0}",
                          type.IsAbstract);
        Console.WriteLine("\tIsAnsiClass = {0}",
                          type.IsAnsiClass);
        Console.WriteLine("\tIsArray = {0}", type.IsArray);
            .
            .
            .
 
      }
      catch (System.NullReferenceException)
      {
        Console.WriteLine("{0} is not a valid type", sTypeName);
      }
    }
 
    static void Main(string[] args)
    {
      // Reflect all the attributes for the given type by
      // passing the name of the type
      ReflectType("System.Int32");
      ReflectType("ReflectionQueryTest.TestDerivedClass");
      ReflectType("ReflectionQueryTest.TestStruct");
      ReflectType("ReflectionQueryTest.TestBaseClass");
 
      ReflectType("ReflectionQueryTest.TestInterface");
      ReflectType("ReflectionQueryTest.TestAttribute");
      ReflectType("ReflectionQueryTest.TestEnum");
    }
  }
}

Example: Parsing Types of an Assembly

In the following example, we will see how to parse the types in an assembly. To do this, follow these steps:

1. Get the assembly name.
2. Instantiate the assembly by using the LoadFrom method.
3. Call the GetTypes method of the Assembly class. This method returns an array of all types of an assembly. The GetValidAssembly method checks whether the user supplied any assembly; if not, it gets the current assembly name. Include using System.Diagnostics; this is to get the current process name.

 
 
private static string GetValidAssembly(string[] sAssem)
{
string sAssemName;
 
  if (0 == sAssem.Length)
  {
    Process pr = Process.GetCurrentProcess();
    sAssemName = pr.ProcessName + ".exe";
  }
  else
{
    sAssemName = sAssem[0];
  }
  return sAssemName;
}

Call LoadFrom to load the given assembly; it's like calling LoadLibrary in the Win32 API. Then, call theGetTypes method of the assembly class, which returns an object (Type array) that contains all the types in the given assembly. See the example project found in ReflectAssembly.zip.

 
 
static void Main(string[] args)
{
  string sAssemblyName = GetValidAssembly(args);
  Assembly assem = Assembly.LoadFrom(sAssemblyName);
 
  Type[] types = assem.GetTypes();
 
  foreach (Type t in types)
  {
    try
    {
      Console.WriteLine("Type information for:" + t.FullName);
      Console.WriteLine("\tBase class = " + t.BaseType.FullName);
      Console.WriteLine("\tIs Class = " + t.IsClass);
      Console.WriteLine("\tIs Enum = " + t.IsEnum);
      Console.WriteLine("\tAttributes = " + t.Attributes);
    }
    catch (System.NullReferenceException)
    {
      Console.WriteLine("Error msg");
    }
  }
 
}