标签：style blog http java color 使用
摘自：http://www.cnblogs.com/knowledgesea/archive/2013/03/02/2935920.html
概述反射
通过is运算符，能够判断对象类型是否为特顶类型，如果两种类型是相同类型，或者两者之间存在引用，装箱拆箱转换，则表明两种类型是兼容的。
class Program
{
static void Main(string[] args)
{
A a = new A();
B b = new B();
if (a is A)
{
Console.WriteLine("a is an A"); //这个打印，因为a 是 A 类型的对象
}
if (b is A)
{
//这个打印，因为b是B类型的对象，而B类型派生于A类型，由于b对象可以转换为A类型，因此b对象与A类型是兼容的，但是反过来就不成立，例如下面不打印
Console.WriteLine("b is an A because it is derived from");
}
if (a is B)
{
//这个不打印
Console.WriteLine("This won‘t display , because a not derived from B");
}
if (a is object)
{
//这个打印
Console.WriteLine("a is an object");
}
Console.ReadKey();
}
}
class A { }
class B : A { }
在运行期间执行类型转换，并且能够使得类型转换失败不抛异常，而返回一个null值，其实as也可以看作一个is运算符的简化备选方式（看例子）。
class Program
{
static void Main(string[] args)
{
A a = new A();
B b = new B();
if (a is B)
{
b = (B)a; //由于a变量不是B类型，因此这里将a变量转换为B类型是无效的。
}
else
{
b = null;
}
if (b ==null)
{
//这个打印
Console.WriteLine("The cast in b=(B)a is not allowed");
}
//上面使用as运算符，能够把两部合二为一。
b = a as B; //as类型先检查强制类型转换的有效性，如果有效，则执行强类型转换过程。这些都在这一句完成。
if (b == null)
{
//这个打印
Console.WriteLine("The cast in b=(B)a is not allowed");
}
Console.ReadKey();
}
}
class A { }
class B : A { }
as ,is 能够测试两种类型的兼容性。但大多数情况下，还需要获得某个类型的具体信息。这就用到了typeof,它可以返回与具体类型相关的System.Type对象，通过System.Type对象可以去顶此类型的特征。一旦获得给定类型的Type对象，就可以通过使用该对象定义的各种属性，字段，方法来获取类型的具体信息。Type类包含了很多成员，在接下来的反射中再详细讨论。下面简单的演示Type对象，调用它的三个属性。
static void Main(string[] args)
{
Type t=typeof(StringBuilder);
Console.WriteLine(t.FullName); //FullName属性返回类型的全称
if (t.IsClass)
{
Console.WriteLine("is a class"); //打印
}
if (t.IsSealed) //是否为密封类
{
Console.WriteLine("is Sealed"); //打印
}
Console.ReadKey();
}
|
MemberInfo类中的只读属性 |
|
|
属性 |
描述 |
|
Type DeclaringType |
获取声明该成员的类或接口的类型 |
|
MemberTypes MemberType |
获取成员的类型，这个值用于指示该成员是字段、方法、属性、事件、或构造函数 |
|
Int MetadataToken |
获取与特定元数据相关的值 |
|
Module Module |
获取一个代表反射类型所在模块（可执行文件）的Module对象 |
|
String Name |
成员的名称 |
|
Type ReflectedType |
反射的对象类型 |
请注意
当然除了MemberInfo类定义的方法和属性外，Type类自己也添加了许多属性和方法：如下表（只列出一些常用的，太多了，自己可以转定义Type类看下）
|
Type类定义的方法 |
|
|
方法 |
功能 |
|
ConstructorInfo[] GetConstructors() |
获取指定类型的构造函数列表 |
|
EventInfo[] GetEvents(); |
获取指定类型的时间列 |
|
FieldInfo[] GetFields(); |
获取指定类型的字段列 |
|
Type[] GetGenericArguments(); |
获取与已构造的泛型类型绑定的类型参数列表，如果指定类型的泛型类型定义，则获得类型形参。对于正早构造的类型，该列表就可能同时包含类型实参和类型形参 |
|
MemberInfo[] GetMembers(); |
获取指定类型的成员列表 |
|
MethodInfo[] GetMethods(); |
获取指定类型的方法列表 |
|
PropertyInfo[] GetProperties(); |
获取指定类型的属性列表 |
下面列出Type类定义的常用的只读属性
|
Type类定义的属性 |
|
|
属性 |
功能 |
|
Assembly Assembly |
获取指定类型的程序集 |
|
TypeAttributes Attributes |
获取制定类型的特性 |
|
Type BaseType |
获取指定类型的直接基类型 |
|
String FullName |
获取指定类型的全名 |
|
bool IsAbstract |
如果指定类型是抽象类型，返回true |
|
bool IsClass |
如果指定类型是类，返回true |
|
string Namespace |
获取指定类型的命名空间 |
上面的列术都是为了，这里的使用。
通过使用Type类定义的方法和属性，我们能够在运行时获得类型的各种具体信息。这是一个非常强大的功能。我们一旦得到类型信息，就可以调用其构造函数，方法，和属性。可见，反射是允许使用编译时不可用的代码的。
由于Reflection API非常多，这里不可能完整的介绍他们（这里如果完整的介绍，据说要一本书，厚书）。但是,Reflection API是按照一定逻辑设计的。因此，只要知道部分接口的使用方法，就可以举一反三的使用剩余的接口。
这里我列出四种关键的反射技术：
一旦有了Type对象就可以使用GetMethodInfo()方法获取此类型支持的方法列表。该方法返回一个MethodInfo 对象数组，MethodInfo对象描述了主调类型所支持的方法，他位于System.Reflection命名空间中
MethodInfo类派生于MethodBase抽象类，而MethodBase类继承了MemberInfo类。因此我们能够使用这三个类定义的属性和方法。例如，使用Name属性得到方法名称。这里有两个重要的成员：
下面代码，我将使用反射获得类中所支持的方法，还有方法的信息。
class MyClass
{
int x;
int 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 ReflectDemo
{
static void Main(string[] args)
{
Type t=typeof(MyClass); //获取描述MyClass类型的Type对象
Console.WriteLine("Analyzing methods in "+t.Name); //t.Name="MyClass"
MethodInfo[] mi = t.GetMethods(); //MethodInfo对象在System.Reflection命名空间下。
foreach (MethodInfo m in mi) //遍历mi对象数组
{
Console.Write(m.ReturnType.Name); //返回方法的返回类型
Console.Write(" " + m.Name + "("); //返回方法的名称
ParameterInfo[] pi = m.GetParameters(); //获取方法参数列表并保存在ParameterInfo对象数组中
for (int i = 0; i < pi.Length; i++)
{
Console.Write(pi[i].ParameterType.Name); //方法的参数类型名称
Console.Write(" "+pi[i].Name); // 方法的参数名
if (i + 1 < pi.Length)
{
Console.Write(", ");
}
}
Console.Write(")");
Console.WriteLine(); //换行
}
Console.ReadKey();
}
}
输出结果为：Analyzing methods inMyClass MyClass(int i, int j) int sum() bool IsBetween(int i) void Set(int a, int b) void Set(double a, double b) void Show()
bool Equals(object obj) int GetHashCode() Type GetType() string ToString()
注意：这里输出的除了MyClass类定义的所有方法外，也会显示object类定义的共有非静态方法。这是因为c#中的所有类型都继承于object类。另外，这些信息实在程序运行时动态获得的，并不需要预先知道MyClass类的定义
这种形式可以制定各种标记，已筛选想要获取的方法。他的通用形式为：MethodInfo[] GetMethods(BindingFlags bindingAttr)
BindingFlags是一个枚举，枚举值有（很多只列出5个吧）：
GetMethods(BindingFlags bindingAttr)这个方法，参数可以使用or把两个或更多标记连接在一起，实际上至少要有Instance（或Static）与Public（或NonPublic）标记。否则将不会获取任何方法。
class MyClass
{
int x;
int y;
public MyClass(int i, int j)
{
x = i;
y = j;
}
private 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 ReflectDemo
{
static void Main(string[] args)
{
Type t=typeof(MyClass); //获取描述MyClass类型的Type对象
Console.WriteLine("Analyzing methods in "+t.Name); //t.Name="MyClass"
MethodInfo[] mi = t.GetMethods(BindingFlags.DeclaredOnly|BindingFlags.Instance|BindingFlags.Public); //不获取继承方法，为实例方法，为公开的
foreach (MethodInfo m in mi) //遍历mi对象数组
{
Console.Write(m.ReturnType.Name); //返回方法的返回类型
Console.Write(" " + m.Name + "("); //返回方法的名称
ParameterInfo[] pi = m.GetParameters(); //获取方法参数列表并保存在ParameterInfo对象数组中
for (int i = 0; i < pi.Length; i++)
{
Console.Write(pi[i].ParameterType.Name); //方法的参数类型名称
Console.Write(" "+pi[i].Name); // 方法的参数名
if (i + 1 < pi.Length)
{
Console.Write(", ");
}
}
Console.Write(")");
Console.WriteLine(); //换行
}
Console.ReadKey();
}
}
上面例子，可以看出只显示了Myclass类显示定义的公用方法。private int sum()也不显示。
上面我们通过反射获取到了类中的所有信息，下面我们就再使用反射调用通过反射获取到的方法。
要调用反射获取到的方法，则需要在MethodInfo实例上调用Invoke() 方法。Invoke()的使用，在下面例子中演示，说明。
下面例子是：先通过反射获取到要调用的方法，然后使用Invoke()方法，调用获取到的指定方法；
class MyClass
{
int x;
int y;
public MyClass(int i, int j)
{
x = i;
y = j;
}
private 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)
{
Console.Write("Inside set(int,int).");
x = a;
y = b;
Show();
}
public void Set(double a, double b)
{
Console.Write("Inside set(double,double).");
x = (int)a;
y = (int)b;
Show();
}
public void Show()
{
Console.WriteLine("x:{0},y:{1}", x, y);
}
}
class InvokeMethDemo
{
static void Main()
{
Type t=typeof(MyClass);
MyClass reflectOb = new MyClass(10, 20);
reflectOb.Show(); //输出为： x:10, y:20
MethodInfo[] mi = t.GetMethods();
foreach (MethodInfo m in mi)
{
ParameterInfo[] pi = m.GetParameters();
if (m.Name.Equals("Set", StringComparison.Ordinal) && pi[0].ParameterType == typeof(int))
{
object[] args = new object[2];
args[0] = 9;
args[1] = 10;
//参数reflectOb,为一个对象引用，将调用他所指向的对象上的方法，如果为静态方法这个参数必须设置为null
//参数args，为调用方法的参数数组，如果不需要参数为null
m.Invoke(reflectOb, args); //调用MyClass类中的参数类型为int的Set方法，输出为Inside set(int,int).x:9, y:10
}
}
Console.ReadKey();
}
}
在这之前的阐述中，由于MyClass类型的对象是都是显式创建的，因此使用反射技术调用MyClass类中的方法是没有任何优势的，还不如以普通方式调用方便简单呢。但是，如果对象是在运行时动态创建的，反射功能的优势就会显示出来。在这种情况下，要先获取一个构造函数列表，然后调用列表中的某个构造函数，创建一个该类型的实例。通过这种机制，可以在运行时实例化任意类型的对象，而不必在声明语句中指定类型。
class MyClass
{
int x;
int y;
public MyClass(int i)
{
x = y + i;
}
public MyClass(int i, int j)
{
x = i;
y = j;
}
public int sum()
{
return x + y;
}
}
class InvokeConsDemo
{
static void Main()
{
Type t = typeof(MyClass);
int val;
ConstructorInfo[] ci = t.GetConstructors(); //使用这个方法获取构造函数列表
int x;
for (x = 0; x < ci.Length; x++)
{
ParameterInfo[] pi = ci[x].GetParameters(); //获取当前构造函数的参数列表
if (pi.Length == 2) break; //如果当前构造函数有2个参数，则跳出循环
}
if (x == ci.Length)
{
return;
}
object[] consargs = new object[2];
consargs[0] = 10;
consargs[1] = 20;
object reflectOb = ci[x].Invoke(consargs); //实例化一个这个构造函数有两个参数的类型对象,如果参数为空，则为null
//实例化后，调用MyClass中的方法
MethodInfo[] mi = t.GetMethods(BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance);
foreach (MethodInfo m in mi)
{
if (m.Name.Equals("sum", StringComparison.Ordinal))
{
val = (int)m.Invoke(reflectOb, null); //由于实例化类型对象的时候是用的两个参数的构造函数，所以这里返回的结构为30
Console.WriteLine(" sum is " + val); //输出 sum is 30
}
}
Console.ReadKey();
}
}
在这之前的阐述中可以看出一个类型的所有信息都能够通过反射得到，但是MyClass类型本身，我们却没有做出获取。虽然前面的阐述实例，可以动态确定MyClass类的信息，但是他们都是基于以下事实：预先知道类型名，并且在typeof语句中使用它获得Type对象。尽管这种方式可能在很多种情况下都很管用，但是要发挥反射的全部功能，我们还需要分析程序集的内容来动态确定程序的可用类型。
借助Reflection API,可以加载程序集，获取它的相关信息并创建其公共可用类型的实例。通过这种机制，程序能够搜索其环境，利用潜在功能，而无需在编译期间显式的定义他们。这是一个非常有效，且令人兴奋的概念。
为了说明如何获取程序集中的类型，我创建两个文件。第一个文件定义一组类，第二个文件则反射各个类的信息。 代码效果如下。
1.这下面代码是要编译生成MyClass.exe文件的
class MyClass
{
int x;
int y;
public MyClass(int i)
{
x = y + i;
}
public MyClass(int i, int j)
{
x = i;
y = j;
}
public int sum()
{
return x + y;
}
}
class Demo
{
static void Main()
{
Console.WriteLine("hello word !");
Console.ReadKey();
}
}
2.这下面的代码是获取上面生成程序集的
class Class3
{
static void Main() {
Assembly asm = Assembly.LoadFrom(@"C:\Users\lenovo\Documents\visual studio 2010\Projects\Reflection_test\ConsoleApplication1\bin\Debug\MyClass.exe"); //加载指定的程序集
Type[] alltype = asm.GetTypes(); //获取程序集中的所有类型列表
foreach (Type temp in alltype)
{
Console.WriteLine(temp.Name); //打印出MyClass程序集中的所有类型名称 MyClass , Demo
}
Console.ReadKey();
}
}
上面获取到了，程序集中的类型，如果想操作程序集中类型中的方法，则跟前边我们累述的方法是一个样子的。
标签：style blog http java color 使用
原文地址：http://www.cnblogs.com/KeenLeung/p/3834924.html
