运行时类型标识：
运行时类型标识(runtime type ID)是一种在程序执行期间标识一个类型的机制。借助运行时类型标识(RTTI)，可以在程序执行期间判定对象的类型。另一个作用是预先检测某个强制类型转换能够成功，从而避免非法的强制类型转换异常。
在C#中有3个支持RTTI的关键字：is as 和typeof。
1.使用is运算符测试类型
通过is运算符能够判断对象的类型是否为特定类型。
它的基本形式为： expr is type
如果expr的类型与type指定的类型相同或兼容，那么此运算的结果为真。否则，结果为假。
2.使用as运算符
有时希望在程序运行期间执行转换，并且即使转换失败，也不会产生异常(在使用强制类型转换时就会如此)。为此，需要使用as运算符，其基本形式为： expr as type
这里，expr表达式江北转换为type指定的类型。如果转换成功，就返回一个type类型的引用，否则返回一个空引用。as 运算符只可以用于引用、装箱、拆箱、或身份转换。
3.使用typeof运算符
as和is运算符能够测试两种类型的兼容性。但在大多数情况下，还需要某个类型的具体信息。为此，应使用C#提供的typeof运算符，它可以返回与具体类型相关的System.Type对象。
通过System.Type对象，可以确定此类型的特征。
typeof运算符的基本形式为：
typeof(type)
其中，type是正在获得的类型，返回的Type对象封装了与type关联的信息。
一旦获得给定类型的Type对象，就可以通过该对象定义的各种属性、字段、方法来获取类型的具体信息。
Type t = typeof(Student);
Console.WriteLine(t.FullName);
反射：
反射(reflection)是一种允许用户获得类型信息的C#特性。术语“反射”源自于它的工作方式：Type对象映射它所代表的底层对象。对Type对象进行查询可以获得(反射)与类型相关的信息。
反射是一种功能强大的机制，它允许学习和使用只在运行时才能知道的类型的功能。
许多支持反射的类都位于System.Reflection名称空间，它们是.NET反射应用程序接口（API）的一部分。
反射的核心：System.Type
System.Type封装了类型，因此是整个反射子系统的核心。System.Type包含了很多属性和方法，使用这些属性和方法可以在运行时得到类型的信息。Type 派生于System.Reflection.MemberInfo 抽象类。
使用反射：
通过使用Type类型定义的方法和属性，能够在运行时获得类型的各种具体信息。这是一个非常强大的功能。一旦得到了类型的信息，就可以调用其构造函数、方法、和属性。因此，反射允许使用编译时不可用的代码。
下面分别说明了四种关键的反射技术：获取方法的信息、调用方法、构造对象以及从程序集中装载类型。
1.获取方法的相关信息
一旦有了Type对象，就可以用GetMethods()方法来获取此类型的方法的列表。
它的一种形式为： MethodInfo[] GetMethods()
它返回一个MethodInfo对象数组，MethodInfo对象描述了主调类型所支持的方法，它位于System.Reflection名称空间中。
MethodInfo派生于抽象类MethodBase，而MethodBase继承了MemberInfo。因此，能够使用这3个类定义的属性和方法。例如，可以使用Name属性得到方法的名称。此时，还有两个重要的方法，ReturnType和GetParameters()。
只读属性ReturnType为一个Type类型的对象，它为用户提供方法的返回类型信息。
GetParameters()返回一个方法的参数列表，它的基本形式为：
ParameterInfo[] GetParameters();
参数信息保存在ParameterInfo对象中。ParameterInfo类定义了大量描述参数信息的属性和方法。其中，两个常用属性是Name（一个包含参数名称信息的字符串）和ParameterType（参数的类型信息）。参数的类型则封装在一个Type对象中。
public class MyClass
{
int x, y;
public MyClass(int i, int j)
{
x = i;
y = j;
}
public int Sum()
{
return x + y;
}
public bool IsBetween(int i)
{
if (x < i & i < y) return true;
else return false;
}
public void Set(int a, int b)
{
x = a;
y = b;
}
public void Set(double a, double b)
{
x = (int)a;
y = (int)b;
}
public void Show()
{
Console.WriteLine(" x:{0},y:{1}", x, y);
}
}
class NTest
{
static void Main(string[] args)
{
Type t = typeof(MyClass);
MethodInfo[] methods = t.GetMethods();
Console.WriteLine("MethodInfo List");
foreach (MethodInfo m in methods)
{
Console.Write("方法：{0}( ", m.Name);
ParameterInfo[] pars = m.GetParameters();
for (int i = 0; i < pars.Length; i++)
{
Console.Write("{0} {1}", pars[i].ParameterType, pars[i].Name);
if (i + 1 < pars.Length) Console.Write(",");
}
Console.Write(")");
Console.WriteLine("");
}
Console.Read();
}
}
输出结果：
//MethodInfo List
//方法：Sum( )
//方法：IsBetween( System.Int32 i)
//方法：Set( System.Int32 a,System.Int32 b)
//方法：Set( System.Double a,System.Double b)
//方法：Show( )
//方法：ToString( )
//方法：Equals( System.Object obj)
//方法：GetHashCode( )
//方法：GetType( )
2.GetMethods()的另一种形式
GetMethods()还有另外一种形式。在这种形式中可以制定各种标记，而筛选出想要的方法。
它的基本形式为：MethodInfo[] GetMethods(BindingFlags flags);
可以使用OR运算符把两个或更多的标记连接在一起。实际上，括号中至少应包含Instance与public标记，否则将不会获得任何方法。
MethodInfo[] methods = t.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
3.使用反射调用方法
一旦知道了一个类型所支持的方法，就可以对方法进行调用。调用时，须使用包含在MethodInfo中的Invoke()方法。下面是它的一种形式：
这里，ob是一个对象引用，将调用它所指向的对象上的方法。对于静态方法，ob必须为null。所有需要传递给方法的参数都必须在args数组中指定。如果方法不需要参数，则args必须为null。另外，数组args的元素数量必须等于参数数量。因此，如果需要两个参数，args就应该具有两个元素的长度，而不能使三个或者四个元素的长度。Invoke()方法返回被调用方法的返回值。
class NTest
{
static void Main(string[] args)
{
MyClass reflectOb = new MyClass(10, 20);
Type t = typeof(MyClass);
MethodInfo[] methods = t.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
Console.WriteLine("MethodInfo List");
foreach (MethodInfo m in methods)
{
ParameterInfo[] pars = m.GetParameters();
if (m.Name.CompareTo("Set") == 0 && pars[0].ParameterType == typeof(int))
{
object[] obj = new object[2];
obj[0] = 9;
obj[1] = 18;
m.Invoke(reflectOb, obj);
}
if (m.Name.CompareTo("Set") == 0 && pars[0].ParameterType == typeof(double))
{
object[] obj = new object[2];
obj[0] = 1.12;
obj[1] = 23.4;
m.Invoke(reflectOb, obj);
}
object num = 0;
if (m.Name.CompareTo("Sum") == 0)
{
num = m.Invoke(reflectOb, null);
Console.WriteLine("sum is " + num.ToString());
}
if (m.Name.CompareTo("IsBetween") == 0)
{
object[] obj = new object[1];
obj[0] = 14;
if ((bool)m.Invoke(reflectOb, obj))
Console.WriteLine("14 is between x and y");
}
if (m.Name.CompareTo("Show") == 0)
{
m.Invoke(reflectOb, null);
}
Console.WriteLine("");
}
Console.Read();
}
}
结果：
//MethodInfo List
//sum is 30
//14 is between x and y
//Inside Set(int,int).Value are x:9,y:18
//Inside Set(double,double).Value are x:1,y:23
//Value are x:1,y:23
4. 获取Type对象的构造函数
由于MyClass类型的对象是显示创建的，因此使用反射技术来调用MyClass上的方法没有任何优势———以普通的方式调用对象上的方法会简单的多。但是，如果对象是在运行时动态创建的，反射功能的优势就显现出来了。通过这种机制，可以在运行时实例化任意类型的对象而不必在声明语句中指定。
为了获得某个类型的构造函数，需要调用Type对象上的GetConstructors()方法。它的一种常用形式为：
ConstructorInfo[] GetConstructors();
该方法会返回一个描述构造函数的ConstructorInfo对象数组。它的GetParameters()方法与MethodInfo中定义的GetParameters()方法非常相似。
一旦找到了合适的构造函数，就调用ConstructorInfo定义的Invoke()方法来创建对象。给方法的一种形式如下所示：
object Invoke(object[] args)
需要传递给此方法的所有参数都在数组args中指定。如果不需要任何参数，那么args必须为null。另外，args必须与包含于参数个数相同的元素，并且实参的类型必须与形参的类型兼容。Invoke()方法返回的是一个指向新构造对象的引用。
static void Main(string[] args)
{
Type t = typeof(MyClass);
ConstructorInfo[] strs = t.GetConstructors(); //取出构造函数列表
ConstructorInfo con = strs[0];
object objreflect = con.Invoke(null); //实例化对象
MethodInfo method = t.GetMethod("Show");
method.Invoke(objreflect, null); //找到方法，并执行
MethodInfo method2 = null;
MethodInfo[] methods = t.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
foreach (MethodInfo m in methods)
{
if (m.Name == "Set" && m.GetParameters()[0].ParameterType == typeof(int))
{
method2 = m; //Set 方法为重载方法，参数类型为int
break;
}
}
object[] obj = new object[2];
obj[0] = 10;
obj[1] = 20;
method2.Invoke(objreflect, obj); //找到方法，并执行
Console.Read();
}
5 从程序集获得类型
程序集提供了它所包含的类和结构的类型信息。借助反射应用程序接口，可以加载程序集，获取它的相关信息并创建其公共可用类型的实例。
为了获取程序集的相关信息，首先需要创建一个Assembly对象。Assembly类并没有定义公有的构造函数，它的对象实例是通过类得一个方法获得的。
这里使用的LoadForm()方法可以加载由文件名指定的程序集，其形式为：
static Assembly LoadFrom(string filename)
其中，filename制定了程序集的文件名。
一旦获得了Assembly类型的对象，就可以通过该对象的GetTypes()方法来得到它所定义的类型。
其基本形式为： Type[] GetTypes()
此方法返回一个数组，它包含了程序集中的类型。
class NTest
{
static void Main(string[] args)
{
Assembly asm = Assembly.LoadFrom("ClassLibrary.dll");
Type[] types = asm.GetTypes();
foreach (Type t in types)
{
Console.WriteLine(t.FullName);
}
Type type = types[0];
Console.WriteLine("当前使用的类为：", type.FullName);
ConstructorInfo[] stru = type.GetConstructors();
object objReflection = stru[0].Invoke(null); //实例化引用对象
MethodInfo m = type.GetMethod("Show");
m.Invoke(objReflection, new object[]{"Vincent","9527"}); //调用方法
Console.Read();
}
}
ClassLibrary.dll中代码为：
namespace ClassLibrary
{
public class Student
{
public string name { get; set; }
public string code { get; set; }
public void Show(string name, string code)
{
Console.WriteLine("My name is {0},code is {1}", name, code);
}
}
public class Teacher
{
public string name { get; set; }
public string subject { get; set; }
public void Show(string name, string code)
{
Console.WriteLine("The teacher's name is {0},subject is {1}", name, subject);
}
}
}