在.NET还有一种更灵活的方式得到类型信息，可以通过System.Type类的静态成员GetType()，然后指定类型的完全限定名。采用这种方法，我们可以不需要知道类型的编译时信息，GetType()方法可以接受任何字符串值（而不是强类型），当然这个字符串就是类型名字的字符串形式。

Type.GetType()方法有很多重载，我们介绍一个常用的：

public static Type GetType(string typeName, bool throwOnError, bool ignoreCase);

使用这个方法我们可以指定两个布尔类型的参数，一个用来表示当类型找不到时是否抛出异常，另一个用来表示是否区分字符串大小写，下面就是第三种获得Student的Type类实例的方式：

Type type = Type.GetType("ReflectionTest.Student", false, true);

在上面这个语句中，字符串没有包含类型所在的程序集信息，这种情况就被认为该类型是定义在当前执行的程序集中。当需要得到一个外部程序集的类型元数据时，字符串参数必须使用类型完全限定名，加上类型所在程序集的友好名字。

Type type = Type.GetType("ReflectionTest.Student, ReflectionTest", false, true);

反射

为了进一步了解反射以及System.Type，下面看一个例子，在这个例子中，我们将使用一些System.Reflection中常被用到的类型，例如MethodInfo，FieldInfo和PropertyInfo等。

namespace ReflectionTest
{
    class Student : IComparable
    {
        public int Id { get; private set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public string Gender { get; set; }

        public void Greeting(string name)
        {
            Console.WriteLine("{0} said Hello to {1}", this.Name, name);
        }

        public string GetInfo()
        {
            return string.Format("Basic Info:\n Name: {0}\n Age: {1}\n Gender: {2}", this.Name, this.Age, this.Gender);
        }

        public int CompareTo(object obj)
        {
            throw new NotImplementedException();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Type type = typeof(Student);
            ListMethods(type);
            ListFields(type);
            ListProps(type);
            ListInterfaces(type);
            ListOhterStatus(type);
            Console.Read();
        }

        static void ListMethods(Type t)
        {
            Console.WriteLine("------Methods------");
            var methodInfos = from m in t.GetMethods()
                              select m;
            foreach (var methodInfo in methodInfos)
            {
                //Get return type
                string retVal = methodInfo.ReturnType.FullName;
                string paramInfo = "(";
                // Get params
                foreach (ParameterInfo pi in methodInfo.GetParameters())
                {
                    paramInfo += string.Format("{0} {1}", pi.ParameterType, pi.Name);
                }
                paramInfo += ")";
                Console.WriteLine("-->{0} {1} {2}", retVal, methodInfo.Name, paramInfo);
            }
            Console.WriteLine();
        }

        static void ListFields(Type t)
        {
            Console.WriteLine("------Fields------");
            var fieldNames = from f in t.GetFields()
                             select f.Name;
            foreach(var fieldName in fieldNames)
                Console.WriteLine("-->{0}", fieldName);
            Console.WriteLine();
        }

        static void ListProps(Type t)
        {
            Console.WriteLine("------Properties------");
            var propNames = from p in t.GetProperties()
                             select p.Name;
            foreach (var propName in propNames)
                Console.WriteLine("-->{0}", propName);
            Console.WriteLine();
        }

        static void ListInterfaces(Type t)
        {
            Console.WriteLine("------Interfaces------");
            var interfaceNames = from i in t.GetInterfaces()
                             select i.Name;
            foreach (var interfaceName in interfaceNames)
                Console.WriteLine("-->{0}", interfaceName);
            Console.WriteLine();
        }

        static void ListOhterStatus(Type t)
        {
            Console.WriteLine("------Other status------");
            Console.WriteLine("Full name is: {0}", t.FullName);
            Console.WriteLine("Base class is: {0}", t.BaseType);
            Console.WriteLine("Is type abstract? {0}", t.IsAbstract);
            Console.WriteLine("Is type a class type? {0}", t.IsClass);
            
            Console.WriteLine();
        }
    }
}

例子还是比较简单的，我们通过反射查看了Student类型的一些元数据信息，结果如下，通过这个例子大致了解到反射的基本使用。

动态加载程序集

在程序的运行中，我们有时会需要加载外部程序集，这个操作被称作动态加载。

通过System.Reflection中的Assembly类型，我们就可以动态的加载程序集，并找到关于程序集的相关特性。通过Assembly类提供的Load()和LoadFrom()方法，我们可以通过代码动态的加载一个程序集。

注意，当使用Load()时，需要把要加载的程序集放到ExternalAssemblyTest工程的"bin/debug"目录，这样Load()方法才能找到这个程序集；当我们使用LoadFrom()方法的时候就比较灵活了，我们可以指定要加载程序集的绝对路径。下面看一个简单的例子：

namespace ExternalAssemblyTest
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Assembly asm = Assembly.Load("ReflectionTest");
                //Assembly asm = Assembly.LoadFrom(@"C:\WorkSpace\VS\SharpInDepth\ExternalAssemblyTest\bin\Debug\ReflectionTest.exe");
                DisplayTypesInAssembly(asm);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            Console.Read();
        }

        static void DisplayTypesInAssembly(Assembly asm)
        {
            Console.WriteLine("------Types in Assembly------");
            Console.WriteLine("-->{0}", asm.FullName);
            var types = from t in asm.GetTypes()
                            select t;
            foreach (var type in types)
                Console.WriteLine("Type: {0}", type);
        }
    }
}

通过这个例子我们可以到了两种动态加载程序集的方法调用，通过反射，我们可以查看被加载程序集的详细信息。

晚期绑定

晚期绑定（late binding）是一种创建一个给定类型的实例，并在运行时调用其成员，而不需要在编译时知道改类型存在的一种技术。

System.Activator类

System.Activator类是.NET晚期绑定过程中的一个关键类型。在代码中，可以通过System.Activator类的CreateInstance静态方法（CreateInstance有很多重载形式，下面给出了一个常用形式）来创建一个晚期绑定类型的实例。

public static object CreateInstance(Type type)

修改上面的例子，这次先动态加载程序集ReflectionTest，然后通过晚期绑定方式为程序集中的Student类型创建一个实例。

static void Main(string[] args)
{
    try
    {
        Assembly asm = Assembly.Load("ReflectionTest");
        //Assembly asm = Assembly.LoadFrom(@"C:\WorkSpace\VS\SharpInDepth\ExternalAssemblyTest\bin\Debug\ReflectionTest.exe");

        //Get Student Type
        Type studentType = asm.GetType("ReflectionTest.Student");
        //Create Student object with late binding
        object student = Activator.CreateInstance(studentType);
        Console.WriteLine("Create object {0} with late binding", student);
        ListMethods(studentType);

    }
    catch (Exception e)
    {
        Console.WriteLine(e.Message);
    }
    Console.Read();
}

static void ListMethods(Type t)
{
    Console.WriteLine("------Methods------");
    var methodInfos = from m in t.GetMethods()
                      select m;
    foreach (var methodInfo in methodInfos)
    {
        //Get return type
        string retVal = methodInfo.ReturnType.FullName;
        string paramInfo = "(";
        // Get params
        foreach (ParameterInfo pi in methodInfo.GetParameters())
        {
            paramInfo += string.Format("{0} {1}", pi.ParameterType, pi.Name);
        }
        paramInfo += ")";
        Console.WriteLine("-->{0} {1} {2}", retVal, methodInfo.Name, paramInfo);
    }
    Console.WriteLine();
}

代码的输出为

对于已经创建的student实例，我们可以通过反射来调用实例的方法。

调用没有参数的方法

根据前面了解到，当我们得到一个Type实例后，就可以通过Type.GetMethod()得到一个MethodInfo对象；然后就可以通过MethodInfo对象的Invoke()方法来实现一个方法的调用。

举例，可以在例子中加入下面代码来调用Student类型的GetInfo()方法，由于该方法不需要参数，所有Invoke()的时候用一个null。

//Get the method
MethodInfo getInfoMethod = studentType.GetMethod("GetInfo");
//call the method without argument
//null here shows that the method has no argument
string info = (string)getInfoMethod.Invoke(student, null);
Console.WriteLine(info);

代码的输出为，由于没有给Name和Gender属性设置值，所以这里显示为空。

调用有参数的方法

在使用晚期绑定调用需要参数的方法时，要将参数打包到一个object类型的数组中。

下面我们调用属性的set方法给属性赋值。

//Get the method
MethodInfo setName = studentType.GetMethod("set_Name");
//call the method without argument
//create object array with values of arguments
setName.Invoke(student, new object[] { "Wilber" });
MethodInfo setAge = studentType.GetMethod("set_Age");
setAge.Invoke(student, new object[] { 28 });
MethodInfo setGender = studentType.GetMethod("set_Gender");
setGender.Invoke(student, new object[] { "Male" });

程序输出为