网站链接: 我爱捣鼓
当前位置: 首页 > web开发  > Asp.net/C#

网上最通俗易懂的好文让你理解什么是.Net/C#反射?

2021/4/11 21:22:25

C#的反射或许大家都知道,但很少有人真正的理解,并把它应用到实际的项目,今天我们就用最通俗易懂的内容让你理解什么是C#反射?反射的基本知识C# 反射(Reflection)反射指程序可以访问、检测和修改它本身状态或行为的一种能力。程序集包含模块,而模块包含类型,类型又…

C#的反射或许大家都知道,但很少有人真正的理解,并把它应用到实际的项目,今天我们就用最通俗易懂的内容让你理解什么是C#反射?

反射的基本知识

C# 反射(Reflection)

反射指程序可以访问、检测和修改它本身状态或行为的一种能力。

程序集包含模块,而模块包含类型,类型又包含成员。反射则提供了封装程序集、模块和类型的对象。

您可以使用反射动态地创建类型的实例,将类型绑定到现有对象,或从现有对象中获取类型。然后,可以调用类型的方法或访问其字段和属性。

优缺点

优点:

1、反射提高了程序的灵活性和扩展性。

2、降低耦合性,提高自适应能力。

3、它允许程序创建和控制任何类的对象,无需提前硬编码目标类。

缺点:

1、性能问题:使用反射基本上是一种解释操作,用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和拓展性要求很高的系统框架上,普通程序不建议使用。

2、使用反射会模糊程序内部逻辑;程序员希望在源代码中看到程序的逻辑,反射却绕过了源代码的技术,因而会带来维护的问题,反射代码比相应的直接代码更复杂。

反射(Reflection)的用途

  • 它允许在运行时查看特性(attribute)信息。

  • 它允许审查集合中的各种类型,以及实例化这些类型。

  • 它允许延迟绑定的方法和属性(property)。

  • 它允许在运行时创建新类型,然后使用这些类型执行一些任务。

通过反射可以提供类型信息,从而使得我们开发人员在运行时能够利用这些信息构造和使用对象。 

反射机制允许程序在执行过程中动态地添加各种功能。  

运行时类型标识 

运行时类型标识(RTTI),可以在程序执行期间判定对象类型。例如使用它能够确切地知道基类引用指向了什么类型对象。

运行时类型标识,能预先测试某个强制类型转换操作,能否成功,从而避免无效的强制类型转换异常。 

在c#中有三个支持RTTI的关键字:is 、 as  、typeof。 下面依次介绍他们 

is运算符:

通过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 { }

as运算符:

在运行期间执行类型转换,并且能够使得类型转换失败不抛异常,而返回一个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 { }

typeof运算符: 

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();
}


反射的核心类:System.Type类

许多支持反射的类都位于System.Reflection命名空间中,他们是.net  Reflection API的一部分,所以在使用的反射的程序中一般都要使用 System.Reflection的命名空间。

System. Type类包装了类型,因此是整个反射子系统的核心,这个类中包含了很多属性和方法,使用这些属性和方法可以在运行时得到类型的信息。

Type类派生于System.Reflection.MemberInfo抽象类

  • MemberInfo类中的只读属性

    属性

    描述

    Type DeclaringType

    获取声明该成员的类或接口的类型

    MemberTypes  MemberType

    获取成员的类型,这个值用于指示该成员是字段、方法、属性、事件、或构造函数

    Int MetadataToken

    获取与特定元数据相关的值

    Module Module

    获取一个代表反射类型所在模块(可执行文件)的Module对象

    String  Name

    成员的名称

    Type  ReflectedType

    反射的对象类型


请注意 

MemberType属性的返回类型为MemberTypes,这是一个枚举,它定义了用于表示不同成员的类型值。这些值包括:MemberTypes.Constructor,   MemberTypes.Method,      MemberTypes.Field,        MemberTypes.Event,      MemberTypes.Property。因此可以通过检查MemberType属性来确定成员的类型,例如,在MemberType属性的值为MemberTypes.Method时,该成员为方法

MemberInfo类还包含两个与特性相关的抽象方法:  

GetCustomAttributes() :获得与主调对象关联的自定义特性列表。

IsDefined(): 确定是否为主调对象定义了相应的特性。

GetCustomAttributesData():返回有关自定义特性的信息(特性稍后便会提到)

当然除了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属性得到方法名称。这里有两个重要的成员:

ReturnType属性  :为Type类型的对象,能够提供方法的返回类型信息

GetParameters()方法  :返回参数列表,参数信息以数组形式保存在PatameterInfo对象中。PatameterInfo类定义了大量描述参数信息的属性和方法。这里也列出两个常用的属性 :Name(包含参数名称信息的字符串),ParameterType(参数类型的信息)。

下面代码,我将使用反射获得类中所支持的方法,还有方法的信息。

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类的定义

GetMethods()方法的另一种形式

这种形式可以制定各种标记,已筛选想要获取的方法。他的通用形式为:MethodInfo[] GetMethods(BindingFlags bindingAttr)

BindingFlags是一个枚举,枚举值有(很多只列出5个吧):

DeclareOnly:仅获取指定类定义的方法,而不获取所继承的方法;

Instance:获取实例方法

NonPublic: 获取非公有方法

Public: 获取共有方法

Static:获取静态方法

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();
}
}


获取Type对象的构造函数

在这之前的阐述中,由于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();       
}
}

上面获取到了,程序集中的类型,如果想操作程序集中类型中的方法,则跟前边我们累述的方法是一个样子的。

以上就是关于C#反射的内容,大家看了之后是否已经搞清楚了呢?感谢您访问“我爱捣鼓(www.woaidaogu.com)”网站的内容,希望对大家有所帮助!引用本文内容时,请注明出处!谢谢合作!


相关资讯

  • C#怎么获取文件夹里所有的图片文件?

    在实际的程序开发中,我们经常需要获取某个文件夹下的所有图片,用到了C#的DirectoryInfo、GetFiles等文件操作方法,具体实现如下://自定义一个结构public struct sFileInfo{ public string FileName; public DateTime FileCreateTime;}protected void Page_Load(…

    2021/3/4 21:48:01
  • c#实现日期时间与unix时间戳互相转换

    为什么使用时间戳?关于Unix时间戳,大概是这个意思,从1970年0时0分0秒开始到现在的秒数.使用它来获得的是一个INT值,储存在数据库里只要使用INT格式就可以了,方便数据库进行排序,搜索,而且比datetime格式更节省数据库空间。 /// <summary> /// Uni…

    2021/3/4 21:40:22