Reflection

Introduction

 System.Reflection -namespace
 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 the GetTypes 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");
    }
  }
 
}

Reflection provides objects (of type Type) that encapsulate assemblies, modules and types. You can use reflection to dynamically create an instance of a type, bind the type to an existing object, or get the type from an existing object and invoke its methods or access its fields and properties. If you are using attributes in your code, Reflection enables you to access them. For more information, see Attributes.
Here's a simple example of Reflection using the static method GetType - inherited by all types from the Object base class - to obtain the type of a variable:

C#

// Using GetType to obtain type information:
int i = 42;
System.Type type = i.GetType();
System.Console.WriteLine(type);

The output is:
System.Int32
In this example, Reflection is used to obtain the full name of a loaded assembly:

C#

// Using Reflection to get information from an Assembly:
System.Reflection.Assembly o = System.Reflection.Assembly.Load("mscorlib.dll");
System.Console.WriteLine(o.GetName());

The output is:
mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

Reflection Overview

Reflection is useful in the following situations:

• When you need to access attributes in your program's metadata. See the topic Accessing Attributes With Reflection.
  
• For examining and instantiating types in an assembly.
  
• For building new types at runtime. Use classes in System.Reflection.Emit.
  
• For performing late binding, accessing methods on types created at run time. See the topic Dynamically Loading and Using Types.