框架结构师的入门基础

前言

反射

本人理解:

编程其实就是写代码,而写代码目的就是实现业务,所以,语法和框架也是为了实现业务而存在的。因此,不管多么高大上的目标,实质上都是业务。

简介

  反射是 .NET中的重要机制,通过反射,可以在运行时获得程序或程序集中类型(包括 class、struct、delegate、interface 和 enum 等)的成员和成员的信息。

  通过反射,即可对每一种类型了如指掌,并且也可以通过反射创建、调用和访问对象,即便在编译时不确定该对象的类型。

  程序集包含模块,模块包含类型,而类型包含成员。反射提供封装程序集、模块和类型的对象。可以使用反射动态地创建类型的实例,将类型绑定到现有对象,或从现有对象中获取类型。

装配件:Assembly(程序集)

所以,我认为不要把写代码上升到科学的高度。上升到艺术就可以了,因为艺术本身也没有高度。。。。

优缺点

  优点:

  1. 提高了程序的灵活性和扩展性;
  2. 降低耦合性;
  3. 它允许程序创建和控制任何类的对象,无需提前硬编码目标类。

  缺点:

  1. 性能:使用反射基本上是一种解释操作,从理论上讲使用反射远慢于直接代码;
  2. 可读性降低。

晚绑定:后期绑定

软件设计存在过度设计,语法和框架的理解,也存在过度理解。比如,反编译下,看看反射是怎么实现的。。。

反射的类型成员信息

  • Assembly:定义和加载程序集。

  • Module:模块信息(如包含模块的程序集和模块中的类)。

  • ConstructorInfo:构造函数信息(如名称、参数、访问修饰符等)。
  • MethodInfo:方法成员信息(如名称、返回类型、参数和访问修饰符等)。

  • FieldInfo:字段成员信息(如名称、访问修饰符)。

  • EventInfo:事件成员信息(如名称、事件处理程序的数据类型、自定义特性、声明类型以及事件的反射的类型)。

  • PropertyInfo:属性成员信息(如名称、数据类型、声明类型,反射的类型和属性的只读或可写状态),并获取或设置属性值。

  • ParameterInfo:参数成员信息(如参数名、数据类型以及参数在方法签名中的位置等)。

  • CustomAttributeData:自定义特性信息。

  System.Reflection.Emit命名空间的类提供一种专用形式的反射,使你能够在运行时生成类型。

MSDN:反射(C# 编程指南).aspx)

有兴趣是好事,但就算知道了反射的本质,了解了反射是如何设计的,你技术也没什么质的改变。因为,技术水平最终还是要落实到应用上。

反射的简单用法

  命名空间:System.Reflection、System.Type、System.Reflection.Assembly

  常见的获取 Type 对象的用法:

            Type type1 = typeof(string);            string msg = "";            Type type2 = msg.GetType();

-----------------原文如下--------

在比如,过度的追求代码性能,也不见得是一件好事,因为,[大多数]情况下,硬件比程序员便宜多了。。。(注意这里指的是代码不是算法和数据库性能)

一个常见的示例用法

  我们一开始学习三层架构的时候,都应该会自己跟着老师动手打造一个 SqlHelper 的吧,这里我截取一个通过反射读取数据库数据并填充到一个对象的属性上,通过循环遍历,最后生成一个 list 列表的代码。

        /// <summary>        /// 执行 Reader 并读取数据转换成集合        /// </summary>        /// <typeparam name="T"></typeparam>        /// <param name="sql"></param>        /// <param name="commandType"></param>        /// <param name="parameters"></param>        /// <returns></returns>        public static IList<T> ExecuteReaderToList<T>(string sql, CommandType commandType = CommandType.Text,            params SqlParameter[] parameters) where T : new()        {            var type = typeof;            var props = type.GetProperties();            var list = new List<T>();            using (var reader = ExecuteDataReader(sql, commandType, parameters))            {                while (reader.Read                {                    var entity = new T();                    foreach (var propertyInfo in props)                    {                        var schemaTable = reader.GetSchemaTable();                        if (schemaTable == null)                            return new List<T>();                        schemaTable.DefaultView.RowFilter = $"ColumnName='{propertyInfo.Name}'";                        if (schemaTable.DefaultView.Count <= 0) continue;                        if (!propertyInfo.CanWrite)                            continue;                        var val = reader[propertyInfo.Name];                        if (val != DBNull.Value)                            propertyInfo.SetValue(entity, val);                    }                    list.Add;                }            }            return list;        }

  简单分析使用反射的代码:

    type.GetProperties():获取属性集合;

    propertyInfo.CanWrite:可写属性;

    propertyInfo.SetValue(entity, val):属性赋值,选择对应的对象进行赋值。


反骨仔

微软官方文档

1、 什么是反射
2、 命名空间与装配件的关系
3、 运行期得到类型信息有什么用
4、 如何使用反射获取类型
5、 如何根据类型来动态创建对象
6、 如何获取方法以及动态调用方法
7、 动态创建委托

所以,不论什么事,过度了,总不是好事。

1、什么是反射
        Reflection,中文翻译为反射。
        这是.Net中获取运行时类型信息的方式,.Net的应用程序由几个部分:‘程序集(Assembly)’、‘模块(Module)’、‘类型(class)’组成,而反射提供一种编程的方式,让程序员可以在程序运行期获得这几个组成部分的相关信息,例如:


        Assembly类可以获得正在运行的装配件信息,也可以动态的加载装配件,以及在装配件中查找类型信息,并创建该类型的实例。
Type类可以获得对象的类型信息,此信息包含对象的所有要素:方法、构造器、属性等等,通过Type类可以得到这些要素的信息,并且调用之。
MethodInfo包含方法的信息,通过这个类可以得到方法的名称、参数、返回值等,并且可以调用之。
诸如此类,还有FieldInfo、EventInfo等等,这些类都包含在System.Reflection命名空间下。

本篇文章主要介绍C#反射【用法】。

2、命名空间与装配件的关系
        很多人对这个概念可能还是很不清晰,对于合格的.Net程序员,有必要对这点进行澄清。
        命名空间类似与Java的包,但又不完全等同,因为Java的包必须按照目录结构来放置,命名空间则不需要。

反射是架构师必会的基础,因为任何一个被设计出来的框架,都要使用反射。

        装配件是.Net应用程序执行的最小单位,编译出来的.dll、.exe都是装配件。

反射也是最隐蔽的语法,因为反射写出来后,通常它会被直接封装,然后调用者就只负责使用,不再关注他的具体实现。

        装配件和命名空间的关系不是一一对应,也不互相包含,一个装配件里面可以有多个命名空间,一个命名空间也可以在多个装配件中存在,这样说可能有点模糊,举个例子:
装配件A:

这与它的特性有关,因为反射就是为了减少代码冗余而存在的,所以,看不见很正常。

  1. namespace  N1
  2. {
  3.       public  class  AC1  {…}
  4.       public  class  AC2  {…}
  5. }
  6. namespace  N2
  7. {
  8.       public  class  AC3  {…}
  9.       public  class  AC4{…}
  10. }

反射的定义

复制代码

官方定义:反射提供了封装程序集、模块和类型的对象(Type 类型)。可以使用反射动态创建类型的实例,将类型绑定到现有对象,或从现有对象获取类型并调用其方法或访问其字段和属性。如果代码中使用了属性,可以利用反射对它们进行访问。

装配件B:

看不懂?没关系,我们把它翻译成人类可理解的语言。

  1. namespace  N1
  2. {
  3.       public  class  BC1  {…}
  4.       public  class  BC2  {…}
  5. }
  6. namespace  N2
  7. {
  8.       public  class  BC3  {…}
  9.       public  class  BC4{…}
  10. }

C#编程语言中,最常使用的是类和类中的函数和属性。正向调用的方法是,创建类,然后用类创建一个对象。接下来就可以用这个对象调用类中的方法和属性了。

复制代码

而反射,就是相对于这种正向调用的存在。即,它是反向调用。

这两个装配件中都有N1和N2两个命名空间,而且各声明了两个类,这样是完全可以的,然后我们在一个应用程序中引用装配件A,那么在这个应用程序中,我们能看到N1下面的类为AC1和AC2,N2下面的类为AC3和AC4。
        接着我们去掉对A的引用,加上对B的引用,那么我们在这个应用程序下能看到的N1下面的类变成了BC1和BC2,N2下面也一样。
        如果我们同时引用这两个装配件,那么N1下面我们就能看到四个类:AC1、AC2、BC1和BC2。

反射可以通过类名的字符串来创建类,可以通过函数名的字符串和属性名的字符串,来调用类下的函数和属性。

        到这里,我们可以清楚一个概念了,命名空间只是说明一个类型是那个族的,比如有人是汉族、有人是回族;而装配件表明一个类型住在哪里,比如有人住在北京、有人住在上海;那么北京有汉族人,也有回族人,上海有汉族人,也有回族人,这是不矛盾的。

有同学会问了, 既然正向可以调用,那么反向调用干什么呢?

        上面我们说了,装配件是一个类型居住的地方,那么在一个程序中要使用一个类,就必须告诉编译器这个类住在哪儿,编译器才能找到它,也就是说必须引用该装配件。
        那么如果在编写程序的时候,也许不确定这个类在哪里,仅仅只是知道它的名称,就不能使用了吗?答案是可以,这就是反射了,就是在程序运行的时候提供该类型的地址,而去找到它。
有兴趣的话,接着往下看吧。

会有这种问题的同学,先别着急,继续往下看,反射既然存在,就必然有存在的道理。

3、运行期得到类型信息有什么用
        有人也许疑问,既然在开发时就能够写好代码,干嘛还放到运行期去做,不光繁琐,而且效率也受影响。
这就是个见仁见智的问题了,就跟早绑定和晚绑定一样,应用到不同的场合。有的人反对晚绑定,理由是损耗效率,但是很多人在享受虚函数带来的好处的时侯还没有意识到他已经用上了晚绑定。这个问题说开去,不是三言两语能讲清楚的,所以就点到为止了。
        我的看法是,晚绑定能够带来很多设计上的便利,合适的使用能够大大提高程序的复用性和灵活性,但是任何东西都有两面性,使用的时侯,需要再三衡量。

反射的基础应用

接着说,运行期得到类型信息到底有什么用呢?
还是举个例子来说明,很多软件开发者喜欢在自己的软件中留下一些接口,其他人可以编写一些插件来扩充软件的功能,比如我有一个媒体播放器,我希望以后可以很方便的扩展识别的格式,那么我声明一个接口:

1,类反射

  1. public  interface  IMediaFormat
  2. {
  3. string  Extension  {get;}
  4. Decoder  GetDecoder();
  5. }

先看下面代码;代码为通过类名称的字符,反射出类的对象。

复制代码

public class ReflectionSyntax
{ 
    public static void Excute()
    {
        Type type = GetType("Syntax.Kiba");
        Kiba kiba = (Kiba)Activator.CreateInstance(type);
        Type type2 = GetType2("Syntax.Kiba");
        Kiba kiba2 = (Kiba)Activator.CreateInstance(type2);
    }
    public static Type GetType(string fullName)
    {
        Assembly assembly = Assembly.Load("Syntax");
        Type type = assembly.GetType(fullName, true, false);
        return type;
    }

    public static Type GetType2(string fullName)
    {
        Type t = Type.GetType(fullName);
        return t;
    } 
} 
public class Kiba
{ 
    public void PrintName()
    {
        Console.WriteLine("Kiba518");
    } 
} 

这个接口中包含一个Extension属性,这个属性返回支持的扩展名,另一个方法返回一个解码器的对象(这里我假设了一个Decoder的类,这个类提供把文件流解码的功能,扩展插件可以派生之),通过解码器对象我就可以解释文件流。
那么我规定所有的解码插件都必须派生一个解码器,并且实现这个接口,在GetDecoder方法中返回解码器对象,并且将其类型的名称配置到我的配置文件里面。
这样的话,我就不需要在开发播放器的时侯知道将来扩展的格式的类型,只需要从配置文件中获取现在所有解码器的类型名称,而动态的创建媒体格式的对象,将其转换为IMediaFormat接口来使用。

在代码中我们看到,反射时传递了字符串"Syntax.Kiba",然后通过解析字符串,获取到了该字符串对应的类的类型,最后再借助Activator来辅助创建类的实例。

这就是一个反射的典型应用。

其中字符串"Syntax.Kiba"是一个完全限定名。什么是完全限定名?完全限定名就是命名空间 类名。在反射的时候,需要我们传递完全限定名来确定到底要去哪个命名空间,找哪个类。

4、如何使用反射获取类型
        首先我们来看如何获得类型信息。
        获得类型信息有两种方法,一种是得到实例对象
        这个时侯我仅仅是得到这个实例对象,得到的方式也许是一个object的引用,也许是一个接口的引用,但是我并不知道它的确切类型,我需要了解,那么就可以通过调用System.Object上声明的方法GetType来获取实例对象的类型对象,比如在某个方法内,我需要判断传递进来的参数是否实现了某个接口,如果实现了,则调用该接口的一个方法:

在代码中我们还可以看到,获取类型的方式有两种,一种是较复杂的,一种是简单的。

  1. public  void  Process(  object  processObj  )
  2. {
  3. Type  t  =  processsObj.GetType();
  4. if(  t.GetInterface(“ITest”)  !=null  )
  5.                     …
  6. }

GetType2方法是简单的获取类别,通过Type直接就解析了字符串。而GetType则先进行了加载Assembly(组件),然后再由组件获取类型。

复制代码

两者有什么区别呢?

另外一种获取类型的方法是通过Type.GetType以及Assembly.GetType方法,如:
              Type  t  =  Type.GetType(“System.String”);
        需要注意的是,前面我们讲到了命名空间和装配件的关系,要查找一个类,必须指定它所在的装配件,或者在已经获得的Assembly实例上面调用GetType。
        本装配件中类型可以只写类型名称,另一个例外是mscorlib.dll,这个装配件中声明的类型也可以省略装配件名称(.Net装配件编译的时候,默认都引用了mscorlib.dll,除非在编译的时候明确指定不引用它),比如:
          System.String是在mscorlib.dll中声明的,上面的Type  t  =  Type.GetType(“System.String”)是正确的
          System.Data.DataTable是在System.Data.dll中声明的,那么:
Type.GetType(“System.Data.DataTable”)就只能得到空引用。
          必须:
Type  t  =  Type.GetType("System.Data.DataTable,System.Data,Version=1.0.3300.0,  Culture=neutral,  PublicKeyToken=b77a5c561934e089");
          这样才可以,大家可以看下面这个帖子:
                http://expert.csdn.net/Expert/to ... 2.xml?temp=.1919977
          qqchen的回答很精彩

区别是,用Type直接解析,只能解析当前命名空间下的类。如果该类存在于引用的DLL中,就解析不了。

5、如何根据类型来动态创建对象
        System.Activator提供了方法来根据类型动态创建对象,比如创建一个DataTable:

而GetType方法中的[Assembly.Load指定了程序集名],所以,在反射时,就会去指定的命名空间里找对应的类。这样就能找到非本程序集下的类了。

  1. Type  t  =  Type.GetType("System.Data.DataTable,System.Data,Version=1.0.3300.0,  Culture=neutral,  PublicKeyToken=b77a5c561934e089");
    1. DataTable  table  =  (DataTable)Activator.CreateInstance(t);

[Assembly.Load指定了程序集名]这句话不好理解?

复制代码

没关系,换个表达,Assembly.Load指定了命名空间的名称,所以反射时,会去这个命名空间里找类,这样是不是就好理解了。

例二:根据有参数的构造器创建对象

Assembly

  1. namespace  TestSpace  
  2. {
  3.   public  class  TestClass
  4.       {
  5.       private  string  _value;
  6.       public  TestClass(string  value)  
  7.     {
  8.       _value=value;
  9.       }
  10.   }
  11. }
  12. Type  t  =  Type.GetType(“TestSpace.TestClass”);
  13. Object[]  constructParms  =  new  object[]  {“hello”};  //构造器参数
  14. TestClass  obj  =  (TestClass)Activator.CreateInstance(t,constructParms);

Assembly的存在让反射变得特别灵活,其中Assembly.Load不止可以导入我们引入的程序集(或命名空间)。

复制代码

也可以导入我们未引入程序集的dll。调用模式如下:

把参数按照顺序放入一个Object数组中即可

System.Reflection.Assembly o = System.Reflection.Assembly.Load("mscorlib.dll");

6、如何获取方法以及动态调用方法

Assembly导入了程序集后,还可以不借助Activator来辅助,自己就可以创建类。如下:

  1. namespace  TestSpace
  2. {
  3.       public  class  TestClass  {
  4.           private  string  _value;
  5.           public  TestClass()  {
  6.           }
  7.           public  TestClass(string  value)  {
  8.                 _value  =  value;
  9.           }
    1.           public  string  GetValue(  string  prefix  )  {
  10.           if(  _value==null  )
  11.           return  "NULL";
  12.           else
  13.             return  prefix "  :  " _value;
  14.             }
    1.             public  string  Value  {
  15. set  {
  16. _value=value;
  17. }
  18. get  {
  19. if(  _value==null  )
  20. return  "NULL";
  21. else
  22. return  _value;
  23. }
  24.             }
  25.       }
  26. }
Assembly assembly = Assembly.Load("Syntax");
Kiba kiba = (Kiba)assembly.CreateInstance("Syntax.Kiba");

复制代码

有的同学可能会担心性能,会觉得这样反射,会使程序变慢。

上面是一个简单的类,包含一个有参数的构造器,一个GetValue的方法,一个Value属性,我们可以通过方法的名称来得到方法并且调用之,如:

有这种想法的同学,其实你已经是在过度理解语法了。这种地方的代码性能其实是可以不用关心的。

  1. //获取类型信息
  2. Type  t  =  Type.GetType("TestSpace.TestClass");
  3. //构造器的参数
  4. object[]  constuctParms  =  new  object[]{"timmy"};
  5. //根据类型创建对象
  6. object  dObj  =  Activator.CreateInstance(t,constuctParms);
  7. //获取方法的信息
  8. MethodInfo  method  =  t.GetMethod("GetValue");
  9. //调用方法的一些标志位,这里的含义是Public并且是实例方法,这也是默认的值
  10. BindingFlags  flag  =  BindingFlags.Public  |  BindingFlags.Instance;
  11. //GetValue方法的参数
  12. object[]  parameters  =  new  object[]{"Hello"};
  13. //调用方法,用一个object接收返回值
  14. object  returnValue  =  method.Invoke(dObj,flag,Type.DefaultBinder,parameters,null);

那么,到底会不会变慢呢?

复制代码

答案是这样的,如果你是使用完全限定名来反射,速度就是一样的。如果是反射时,只写了一个类名,那么速度就会变慢。因为它要遍历所有的命名空间,去找这个类。

属性与方法的调用大同小异,大家也可以参考MSDN

即,只要反射时把类的命名空间写全,那么速度就不会慢。

7、动态创建委托
        委托是C#中实现事件的基础,有时候不可避免的要动态的创建委托,实际上委托也是一种类型:System.Delegate,所有的委托都是从这个类派生的
        System.Delegate提供了一些静态方法来动态创建一个委托,比如一个委托:

2,函数反射

  1. namespace  TestSpace  {
  2.       delegate  string  TestDelegate(string  value);
  3.       public  class  TestClass  {
  4. public  TestClass()  {
  5.                   }
  6.                   public  void  GetValue(string  value)  {
  7.                           return  value;
  8.                   }
  9.         }
  10. }

函数的反射应用主要是使用类MethodInfo类反射,下面先看下基础应用。

复制代码

public static void ExcuteMethod()
{ 
    Assembly assembly = Assembly.Load("Syntax"); 
    Type type = assembly.GetType("Syntax.Kiba", true, false);
    MethodInfo method =  type.GetMethod("PrintName"); 
    object kiba = assembly.CreateInstance("Syntax.Kiba");
    object[] pmts = new object[] { "Kiba518" };
    method.Invoke(kiba, pmts);//执行方法  
}
public class Kiba
{
    public string Name { get; set; }
    public void PrintName(string name)
    {
        Console.WriteLine(name);
    }
}

使用示例:

一些同学第一眼看上去可能会有点不适应,因为好像很多类都是大家不经常用的。这也没办法,因为这是一个进阶的过程,必须经历从陌生到熟悉。当你熟悉了这样的代码后,就代表你的技术水平又进步了一个台阶。

  1. TestClass  obj  =  new  TestClass();
    1. //获取类型,实际上这里也可以直接用typeof来获取类型
  2. Type  t  =  Type.GetType(“TestSpace.TestClass”);
  3. //创建代理,传入类型、创建代理的对象以及方法名称
  4. TestDelegate  method  =  (TestDelegate)Delegate.CreateDelegate(t,obj,”GetValue”);
    1. String  returnValue  =  method(“hello”);

下面讲解一些这些代码。

复制代码

首先我们导入了命名空间,接着我们获取了该命名空间下Kiba这个类的类型;接下来我们通过这个类型来获取指定名称的函数。


然后我们通过Assembly创建了一个Kiba的实例,接着定义了一个参数的Object数组,因为Kiba类下的函数PrintName只有一个参数,所以,我们只为这个Object数组添加一个对象[Kiba518]。

另外一篇关于反射的文章

最后,我们通过method.Invoke来调用这个函数,由于是反射,所以调用时,需要指定Kiba类的实例对象和入参。

---------------原文如下------------------

这样,函数的反射就实现了。

反射的定义:审查元数据并收集关于它的类型信息的能力。元数据(编译以后的最基本数据单元)就是一大堆的表,当编译程序集或者模块时,编译器会创建一个类定义表,一个字段定义表,和一个方法定义表等。
          System.reflection命名空间包含的几个类,允许你反射(解析)这些元数据表的代码   

3,属性反射

System.Reflection.Assembly 
System.Reflection.MemberInfo
System.Reflection.EventInfo
System.Reflection.FieldInfo
System.Reflection.MethodBase
System.Reflection.ConstructorInfo
System.Reflection.MethodInfo
System.Reflection.PropertyInfo
System.Type
以下是上面几个类的使用方法:
(1)使用Assembly定义和加载程序集,加载在程序集清单中列出模块,以及从此程序集中查找类型并创建该类型的实例。 
(2)使用Module了解包含模块的程序集以及模块中的类等,还可以获取在模块上定义的所有全局方法或其他特定的非全局方法。 
(3)使用ConstructorInfo了解构造函数的名称、参数、访问修饰符(如pulic 或private)和实现详细信息(如abstract或virtual)等。使用Type的GetConstructors或 GetConstructor方法来调用特定的构造函数。 
(4)使用MethodInfo了解方法的名称、返回类型、参数、访问修饰符(如pulic 或private)和实现详细信息(如abstract或virtual)等。使用Type的GetMethods或GetMethod方法来调用特定的方法。 
(5)使用FiedInfo了解字段的名称、访问修饰符(如public或private)和实现详细信息(如static)等,并获取或设置字段值。 
(6)使用EventInfo了解事件的名称、事件处理程序数据类型、自定义属性、声明类型和反射类型等,添加或移除事件处理程序。 
(7)使用PropertyInfo了解属性的名称、数据类型、声明类型、反射类型和只读或可写状态等,获取或设置属性值。 
(8)使用ParameterInfo了解参数的名称、数据类型、是输入参数还是输出参数,以及参数在方法签名中的位置等。
反射的层次模型:
图片 1
(注:层次间都是一对多的关系)

属性反射是用PropertyInfo类来实现,下面看基础的属性反射。

 

public static void ExcuteProperty()
{
    Kiba kiba = new Kiba();
    kiba.Name = "Kiba518";
    object name = ReflectionSyntax.GetPropertyValue(kiba, "Name");
    Console.WriteLine(name); 
} 
public static object GetPropertyValue(object obj, string name)
{
    PropertyInfo property = obj.GetType().GetProperty(name);
    if (property != null)
    {
        object drv1 = property.GetValue(obj, null);
        return drv1;
    }
    else
    {
        return null;
    } 
}

反射的作用:
1、可以使用反射动态地创建类型的实例,将类型绑定到现有对象,或从现有对象中获取类型
2、应用程序需要在运行时从某个特定的程序集中载入一个特定的类型,以便实现某个任务时可以用到反射。
3、反射主要应用与类库,这些类库需要知道一个类型的定义,以便提供更多的功能。

如代码所示,首先我们定义了一个Kiba的对象,并为Name赋值,然后我们通过GetPropertyValue方法,传递了Kiba对象和要获取值的属性名称。

应用要点:
1、现实应用程序中很少有应用程序需要使用反射类型
2、使用反射动态绑定需要牺牲性能
3、有些元数据信息是不能通过反射获取的
4、某些反射类型是专门为那些clr 开发编译器的开发使用的,所以你要意识到不是所有的反射类型都是适合每个人的。

GetPropertyValue函数里通过使用PropertyInfo完成了反射。

 

有的同学可能会觉得,这个很鸡肋,既然已经得到对象,还反射做什么,直接获取就可以了呀。

反射appDomain 的程序集:

别着急,我们接下来一起看反射的架构应用。

当你需要反射AppDomain 中包含的所有程序集,示例如下:
static void Main
{
       //通过GetAssemblies 调用appDomain的所有程序集
       foreach (Assembly assem in Appdomain.currentDomain.GetAssemblies())
      {
       //反射当前程序集的信息
            reflector.ReflectOnAssembly(assem)
      }
}

反射的架构应用

说明:调用AppDomain 对象的GetAssemblies 方法 将返回一个由System.Reflection.Assembly元素组成的数组。

 框架编写的核心目的之一,是统一系统秩序。那么什么是系统秩序呢?

反射单个程序集:

 首先我们看下系统的构成,系统个通常是由子系统,程序集,类,函数这四部分构成。如下图所示。

上面的方法讲的是反射AppDomain的所有程序集,我们可以显示的调用其中的一个程序集,system.reflecton.assembly 类型提供了下面三种方法:
1、Load 方法:极力推荐的一种方法,Load 方法带有一个程序集标志并载入它,Load 将引起CLR把策略应用到程序集上,先后在全局程序集缓冲区,应用程序基目录和私有路径下面查找该程序集,如果找不到该程序集系统抛出异常
2、LoadFrom 方法:传递一个程序集文件的路径名(包括扩展名),CLR会载入您指定的这个程序集,传递的这个参数不能包含任何关于版本号的信息,区域性,和公钥信息,如果在指定路径找不到程序集抛出异常。
3、LoadWithPartialName:永远不要使用这个方法,因为应用程序不能确定再在载入的程序集的版本。该方法的唯一用途是帮助那些在.Net框架的测试环节使用.net 框架提供的某种行为的客户,这个方法将最终被抛弃不用。

图片 2

注意:system.AppDomain 也提供了一种Load 方法,他和Assembly的静态Load 方法不一样,AppDomain的load 方法是一种实例方法,返回的是一个对程序集的引用,Assembly的静态Load 方发将程序集按值封装发回给发出调用的AppDomain.尽量避免使用AppDomain的load 方法

既然系统由子系统,程序集,类,函数这四个基础元素构成,那么系统秩序,自然指的就是这四个元素的秩序。而这四个元素最难形成秩序的就是函数了。

利用反射获取类型信息:

很显然,任何的项目都存在重复的函数,或者功能相近的函数。而彻底杜绝这种情况,显然是不可能的。那么我们只好尽量是设计会避免重复元素的框架了。而反射,正是为此而存在的。

前面讲完了关于程序集的反射,下面在讲一下反射层次模型中的第三个层次,类型反射
一个简单的利用反射获取类型信息的例子:

反射的架构应用

using system;
using sytem.reflection;
class reflecting 
{
       static void Main(string[]args)
       {
             reflecting reflect=new reflecting();//定义一个新的自身类
             //调用一个reflecting.exe程序集

现实中的框架因为这样那样的原因,会有千奇百怪的设计,所以拘泥于一种设计模式是愚蠢的,实战中要多种设计模式一起应用,局部设计有时候只取设计模式中一部分也可以。这样才能实现项目的量身定制。

             assembly myAssembly =assembly.loadfrom(“reflecting.exe”)
             reflect.getreflectioninfo(myAssembly);//获取反射信息
       }

所以,这里只介绍一种实战的架构应用,一种使用反射的框架基础结构。下面请框架基础代码。

       //定义一个获取反射内容的方法
       void getreflectioninfo(assembly myassembly)
       {
             type[] typearr=myassemby.Gettypes();//获取类型
             foreach (type type in typearr)//针对每个类型获取详细信息
            {
                   //获取类型的结构信息
                  constructorinfo[] myconstructors=type.GetConstructors;

public class Client
{
    public void ExcuteGetNameCommand()
    {
        Proxy proxy = new Proxy();
        GetNameCommand cmd = new GetNameCommand();
        ResultBase rb = proxy.ExcuteCommand(cmd);
    } 
} 
public class Proxy
{
    public ResultBase ExcuteCommand(CommandBase command)
    {
        var result = HandlerSwitcher.Excute(command);
        return result as ResultBase;
    }
}
public class HandlerSwitcher
{
    private const string methodName = "Excute";//约定的方法名
    private const string classNamePostfix = "Handler";//约定的处理Command的类的名称的后缀 
    //获取命名空间的名称
    public static string GetNameSpace(CommandBase command)
    {
        Type commandType = command.GetType();//获取完全限定名
        string[] CommandTypeNames = commandType.ToString().Split('.');
        string nameSpace = "";
        for (int i = 0; i < CommandTypeNames.Length - 1; i  )
        {
            nameSpace  = CommandTypeNames[i];
            if (i < CommandTypeNames.Length - 2)
            {
                nameSpace  = ".";
            }
        } 
        return nameSpace;
    }

    public static object Excute(CommandBase command)
    {
        string fullName = command.GetType().FullName;//完全限定名
        string nameSpace = GetNameSpace(command);//命名空间  
        Assembly assembly = Assembly.Load(nameSpace);
        Type handlerType = assembly.GetType(fullName   classNamePostfix, true, false);
        object obj = assembly.CreateInstance(fullName   classNamePostfix);
        MethodInfo handleMethod = handlerType.GetMethod(methodName);//获取函数基本信息
        object[] pmts = new object[] { command }; //传递一个参数command
        try
        {
            return handleMethod.Invoke(obj, pmts);
        }
        catch (TargetInvocationException tie)
        {
            throw tie.InnerException;
        }
    }
}
public class GetNameCommandHandler
{
    public ResultBase Excute(CommandBase cmd)
    {
        GetNameCommand command = (GetNameCommand)cmd;
        ResultBase result = new ResultBase();
        result.Message = "I'm Kiba518";
        return result;
    }
}
public class GetNameCommand: CommandBase
{  
} 
public class CommandBase
{ 
    public int UserId { get; set; } 

    public string UserName { get; set; } 

    public string ArgIP { get; set; } 
}
public class ResultBase
{ 
    public string Message { get; set; } 
}

                 //获取类型的字段信息
                 fieldinfo[] myfields=type.GetFiedls()

代码中框架很简单,主要目的是实现一个代理,用于处理继承了CommandBase的类的代理。

                 //获取方法信息
                 MethodInfo   myMethodInfo=type.GetMethods();

即,客户端,不论传来什么样的Command,只要它是继承自CommandBase的,这个代理都会找到对应的处理类,并执行处理,且返回结果。

                 //获取属性信息
                 propertyInfo[] myproperties=type.GetProperties

为了更清晰的理解这段代码,我们可以参考下面这个流程图。结合了图片在来看代码,框架结构就会更清晰。

                 //获取事件信息
                 EventInfo[] Myevents=type.GetEvents;
           }
      }
}
其它几种获取type对象的方法:
1、System.type   参数为字符串类型,该字符串必须指定类型的完整名称(包括其命名空间)
2、System.type 提供了两个实例方法:GetNestedType,GetNestedTypes
3、Syetem.Reflection.Assembly 类型提供的实例方法是:GetType,GetTypes,GetExporedTypes
4、System.Reflection.Moudle 提供了这些实例方法:GetType,GetTypes,FindTypes

图片 3

设置反射类型的成员:

这个简单的框架中,使用了一个概念,叫做约定优先原则,也叫做约定优于配置;喜欢概念的小伙伴可以自行百度。

反射类型的成员就是反射层次模型中最下面的一层数据。我们可以通过type对象的GetMembers 方法取得一个类型的成员。如果我们使用的是不带参数的GetMembers,它只返回该类型的公共定义的静态变量和实例成员,我们也可以通过使用带参数的 GetMembers通过参数设置来返回指定的类型成员。具体参数参考msdn 中system.reflection.bindingflags 枚举类型的详细说明。

框架中使用的两个约定如下:

例如:
//设置需要返回的类型的成员内容
bindingFlags bf=bingdingFlags.DeclaredOnly|bingdingFlags.Nonpublic|BingdingFlags.Public;
foreach (MemberInfo mi int t.getmembers(bf))
{
       writeline(mi.membertype)    //输出指定的类型成员
}

第一个是,处理Command的类必须后缀名是Command的类名 Handler结尾。

通过反射创建类型的实例:

第二个是,处理Command的类中的处理函数名必须为Excute。

通过反射可以获取程序集的类型,我们就可以根据获得的程序集类型来创建该类型新的实例,这也是前面提到的在运行时创建对象实现晚绑定的功能
我们可以通过下面的几个方法实现:
1、System.Activator 的CreateInstance方法。该方法返回新对象的引用。具体使用方法参见msdn
2、System.Activator 的createInstanceFrom 与上一个方法类似,不过需要指定类型及其程序集
3、System.Appdomain 的方法:createInstance,CreateInstanceAndUnwrap,CreateInstranceFrom和CreateInstraceFromAndUnwrap
4、System.type的InvokeMember实例方法:这个方法返回一个与传入参数相符的构造函数,并构造该类型。
5、System.reflection.constructinfo 的Invoke实例方法

其实概念就是供大家使用的,会用即可;学习的过程中,概念之类的术语,有个印象即可。

反射类型的接口:

PS:为了阅读方便,这里面的类都集中写在了一个命名空间之下了,如果有想使用这种设计模式的同学,请按照自己项目所需进行扩展。

如果你想要获得一个类型继承的所有接口集合,可以调用Type的FindInterfaces GetInterface或者GetInterfaces。所有这些方法只能返回该类型直接继承的接口,他们不会返回从一个接口继承下来的接口。要想返回接口的基础接口必须再次调用上述方法。


反射的性能:

这样,我们就通过反射实现了一个非常简约的框架,通过使用这个框架,会让代码变的更加简洁。

使用反射来调用类型或者触发方法,或者访问一个字段或者属性时clr 需要做更多的工作:校验参数,检查权限等等,所以速度是非常慢的。所以尽量不要使用反射进行编程,对于打算编写一个动态构造类型(晚绑定)的应用程序,可以采取以下的几种方式进行代替:
1、通过类的继承关系。让该类型从一个编译时可知的基础类型派生出来,在运行时生成该类型的一个实例,将对其的引用放到其基础类型的一个变量中,然后调用该基础类型的虚方法。
2、通过接口实现。在运行时,构建该类型的一个实例,将对其的引用放到其接口类型的一个变量中,然后调用该接口定义的虚方法。
3、通过委托实现。让该类型实现一个方法,其名称和原型都与一个在编译时就已知的委托相符。在运行时先构造该类型的实例,然后在用该方法的对象及名称构造出该委托的实例,接着通过委托调用你想要的方法。这个方法相对与前面两个方法所作的工作要多一些,效率更低一些。

而为了实现每个模块的简洁,反射也将会被封装在各个模块的底层,所以,反射毫无疑问,就是框架设计的基础。

 

反射与特性

个人操作方案:

反射在系统中另一个重要应用就是与特性的结合使用。

源DLL类:

在一些相对复杂的系统中,难免会遇到一些场景,要讲对象中的一部分属性清空,或者要获取对象中的某些属性赋值。通常我们的实现方式就是手写,一个一个的赋值。

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Web.UI;
using System.Collections;

而利用反射并结合特性,完全可以简化这种复杂操作的代码量。

namespace cn.SwordYang
{

 public partial class ReflectionSyntax
 {
     public void ExcuteKibaAttribute()
     {
         Kiba kiba = new Kiba();
         kiba.ClearName = "Kiba518";
         kiba.NoClearName = "Kiba518";
         kiba.NormalName = "Kiba518";
         ClearKibaAttribute(kiba);
         Console.WriteLine(kiba.ClearName);
         Console.WriteLine(kiba.NoClearName);
         Console.WriteLine(kiba.NormalName);
     }
     public void ClearKibaAttribute(Kiba kiba)
     {
         List<PropertyInfo> plist = typeof(Kiba).GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public).ToList();//只获取Public的属性
         foreach (PropertyInfo pinfo in plist)
         {
             var attrs = pinfo.GetCustomAttributes(typeof(KibaAttribute), false);
             if (null != attrs && attrs.Length > 0)
             { 
                 var des = ((KibaAttribute)attrs[0]).Description; 
                 if (des == "Clear")
                 {
                     pinfo.SetValue(kiba, null); 
                 }
             }
         }
     } 
 } 
 public class Kiba
 {
     [KibaAttribute("Clear")]
     public string ClearName { get; set; }
     [KibaAttribute("NoClear")]
     public string NoClearName { get; set; }
     public string NormalName { get; set; }

 }
 [System.AttributeUsage(System.AttributeTargets.All)]
 public class KibaAttribute : System.Attribute
 {
     public string Description { get; set; }
     public KibaAttribute(string description)
     {
         this.Description = description;
     }
 }

    public class TextClass:System.Web.UI.Page
    {

如上述代码所示, 我们通过反射,将拥有KibaAttribute特性的,且描述为Clear的属性,清空了。

public static void RunJs(Page _page, string Source)
        {
            _page.ClientScript.RegisterStartupScript(_page.GetType(), "", "<script type="text/javascript">" Source ";</script>");

当然为了一个属性这么做不值得,但如果一个对象有70个属性的时候,这么做就值得了。

        }

既然能清除属性的数据,那么自然就可以为属性赋值。至于如何实现反射赋值,相信大家可以举一反三。

}

反射 特性最常见的场景

}

反射 特性一起应用,最常见的场景就是用ADO.NET从数据库查询出DataTable的数据,然后将DataTable的数据转换成Model实体类型。

//调用代码

我们在开发中,为了让实体更加充血,往往会对数据实体增加一些属性和方法。(什么是充血?充血就是充血模型,有兴趣的同学可以自行百度了解下,简单说就是为实体加属性和方法。)

System.Reflection.Assembly ass = Assembly.LoadFrom(Server.MapPath("bin/swordyang.dll")); //加载DLL
            System.Type t = ass.GetType("cn.SwordYang.TextClass");//获得类型
            object o = System.Activator.CreateInstance(t);//创建实例

那么,在用反射,将DataTable转存到Model实体的时候,遍历属性并赋值的时候,就会多遍历那么几次。

            System.Reflection.MethodInfo mi = t.GetMethod("RunJs");//获得方法

如果只是一个实体,那么,多遍历几次也没影响。但,如果是数十万的数据,那这多几次的遍历影响就大了。

            mi.Invoke(o, new object[] { this.Page,"alert('测试反射机制')"});//调用方法

而用反射 特性,就可以减少这些额外遍历次数。

反射机制对应设计模式中的策略模式。

讲了这么多为什么不给代码呢?

因为我觉得,将上面的内容全理解的同学,应该可以说,已经框架启蒙了。那么,这个反射 特性的DataTable转数据实体,如果能自己写出来,就算是框架入门了。所以,这里给大家留下了一个练习的空间。

注意,我这里说的是框架,而不是架构。

框架与架构的区别是这样的,框架是个名词,而架构是个动词。框架即便很熟练了,也不见得可以架构的很好。这个大家还是要注意区别。

结语

看完了整篇文章,有的同学可能会有疑问,这么生疏的PropertyInfo和MethodInfo真的有人会用吗?都是Copy代码,然后使用吧。

答案是,当然有人可以熟练应用。反射是架构师的入门基础,任何一个[可以实战]的架构师,都需要随时随地的可以手写出反射,因为优化框架是他们的责任。

所以,对此有所怀疑的小伙伴,可以努力练习了,将委托融入血液,是高级软件工程师的基础,而将反射融入血液,就是架构师的基础了。

C#语法——元组类型

C#语法——泛型的多种应用

C#语法——await与async的正确打开方式

C#语法——委托,架构的血液

C#语法——事件,逐渐边缘化的大哥。

C#语法——消息,MVVM的核心技术。

我对C#的认知。


注:此文章为原创,欢迎转载,请在文章页面明显位置给出此文链接!
若您觉得这篇文章还不错,请点击下右下角的【推荐】,非常感谢!
如果您觉得这篇文章对您有所帮助,那就不妨支付宝小小打赏一下吧。 

图片 4

 

本文由星彩网app下载发布于计算机编程,转载请注明出处:框架结构师的入门基础

TAG标签: 星彩网app下载
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。