C#高级进阶教程_02_反射

字数统计: 3.6k字   |   阅读时长≈ 16分

首先熟悉一下原先接口的使用，顺便复习一下接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Console.WriteLine("欢迎来到.net高级班vip课程，今天是梁老师的反射的课程");
                {
                    Console.WriteLine("**********Common_接口执行MysqlHelper01*****************");
                    IDBHelper iDBHelper = new MySqlHelper();
                    iDBHelper.Query();
                    //获取类型信息的两种方式
                    Type type = typeof(MySqlHelper);
                    iDBHelper.GetType();
                }
                {
                    Console.WriteLine("********Common_接口执行SqlServerHelper02*****************");
                    IDBHelper iDBHelper = new SqlServerHelper();
                    iDBHelper.Query();
                }

//01老的调用方式

IDBHelper iDBHelper = new MySqlHelper();

iDBHelper.Query();

1
2
3
4
public interface IDBHelper
    {
        void Query();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
public class MySqlHelper : IDBHelper
   {
       public MySqlHelper()
       {
           Console.WriteLine("{0}被构造", this.GetType().Name);
       }


       public void Query()
       {
           Console.WriteLine("{0}.Query", this.GetType().Name);
       }
   }
1
2
3
4
5
6
7
8
9
public SqlServerHelper()
        {
            Console.WriteLine("{0}被构造", this.GetType().Name);
        }

        public void Query()
        {
            Console.WriteLine("{0}.Query", this.GetType().Name);
        }

反射入门了解尝试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Console.WriteLine("************************Reflection反射的入门学习*****************");
                     
                    //Assembly assembly1 = Assembly.LoadFile(@"D:\ruanmou\online11\20180425Advanced11Course2Reflection\MyReflection\MyReflection\bin\Debug\Ruanmou.DB.MySql.dll");
                    //完整路径的加载  可以是别的目录   加载不会错，但是如果没有依赖项，使用的时候会错
                    //Assembly assembly2 = Assembly.LoadFrom("Ruanmou.DB.MySql.dll");//带后缀或者完整路径
                    
                    
                    //02新的调用方式：
                    Assembly assembly = Assembly.Load("Ruanmou.DB.MySql");                 //01. 加载dll  dll名称无后缀（从当前目录加载）   反射的特点：01直接寻找路径，并不是通过引用加载，02依靠的是字符串运行！
                                                                                                                                                     // 03对具体类型的依赖，目前换成了字符串。
                    // foreach (var item in assembly.GetModules())                         //通过程序程序集获取模块（dll）
                    // {
                    //     Console.WriteLine("-----"+item.FullyQualifiedName);             //获取到的模块的名字“Ruanmou.DB.MySql.dll”
                    // }
                    // foreach (var item in assembly.GetTypes())
                    // {
                    //     Console.WriteLine("-----"+item.FullName);                       //获取到类型的完整名字是"Ruanmou.DB.MySql.MySqlHelper"
                    // }
                    Type type = assembly.GetType("Ruanmou.DB.MySql.MySqlHelper");          //02.获取类型信息
                       Console.WriteLine("获取到的类型是："+type);
                    object oDBHelper = Activator.CreateInstance(type);                     //03. 创建对象   这个很关键！！！Activator.CreateInstance
                      //oDBHelper.Query();//编译器报错，oDBHelper是objec不能调用，但实际上方法是有的   编译器不认可  
                    IDBHelper iDBHelper = (IDBHelper)oDBHelper;                            //04. 类型转换
                    iDBHelper.Query();                                                     //05. 方法调用

利用工厂模式创建对象，作为就是封装，让代码看起来简洁。

**
**

**
**

**
**

**
**

**
**

一、利用反射创建对象

IOC使用**
**

1
2
3
4
5
6
7
8
9
10
11
12
13
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
  </startup>
  <appSettings>
    <add key="IDBHelperConfig" value="Ruanmou.DB.MySql.MySqlHelper,Ruanmou.DB.MySql"/>                    //字符串存储的使用小技巧：使用“，”隔开的小技巧
  </appSettings>
  <connectionStrings>
    <!--数据库连接字符串-->
    <add name="Customers" connectionString="Data Source=ElevenPC; Database=Customers; User ID=sa; Password=Passw0rd; MultipleActiveResultSets=True" providerName="System.Data.SqlClient" />
  </connectionStrings>
</configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public  class Factory
    {
        private static string IDBHelperConfig = ConfigurationManager.AppSettings["IDBHelperConfig"];     //记得添加SqlConfiguration的引用
        private static string DllName = IDBHelperConfig.Split(',')[1];                                   //获取配置文件中的第一个字符串
        private static string TypeName = IDBHelperConfig.Split(',')[0];                                  //获取配置文件中的第二个字符串
        
        public static IDBHelper CreateHelper()//1 2
        {
            Assembly assembly = Assembly.Load(DllName);        //1 加载dll         反射的特点：直接寻找路径，并不是通过引用加载。  DllName本来要修改的是字符串，但最终将其封装到了配置文件中！
            Type type = assembly.GetType(TypeName);            //2 获取类型信息      
            object oDBHelper = Activator.CreateInstance(type); //3 创建对象
            IDBHelper iDBHelper = (IDBHelper)oDBHelper;        //4 类型转换
            return iDBHelper;
        }
    }

反射的意义作用：

1. 更改配置文件，程序就会做出相应的修改。

2. 不需要编译/需要重启生效，此方法叫做程序的可配置。

3. 将dll导入后就可以生效，不需要更改代码。只需要更改配置文件即可。 （dll需要提前写好）此方法叫做程序的可配置可扩展。

4. 不需要再添加引用，直接通过文件目录寻找加载dll，然后仅仅需要更改配置文件的字符串名称，程序即刻更改，不需要更改程序代码。

5. 配置文件的使用，经常使用到反射。 反射，将dll拷贝进去，反射是动态的，依赖的是字符串！ （类似于热更新？？？）

6. 接口的应用？IOC的应用？？

1
2
3
Console.WriteLine("************************Reflection+Factory+Config*****************");
  IDBHelper iDBHeler = Factory.CreateHelper();  //工厂的价值！让代码更简洁，让复杂过程封装，最终效果看起来和老的调用方式类似！    最终还是面向抽象的思想，最后改动的仅仅是配置文件即可！
  iDBHeler.Query();                             //可配置可扩展   反射是动态的  依赖的是字符串

**
**

**

**
**

破坏单例/创建泛型（选修）**

Activator.CreateInstance的拓展使用：

** 单例模式：**

** 概 念： **单例是一个只允许创建自身的单个实例的类。

** 意 图： **保证一个类仅有一个实例，并提供一个访问它的全局访问点。

** 主要解决： **一个全局使用的类，频繁地创建与销毁。

** 何时使用：**当想控制实例数目，节省系统资源的时候。

** 使用场景：**

** ** 1.要求生产唯一序列号。

2.WEB中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来；

3.创建的一个对象需要消耗的资源过多，比如I/O与数据库的连接等；

4.全局配置文件访问类，单例子来保证唯一性；

5.日志记录帮助类，全局一个实例一般就够了；

6.桌面应用常常要求只能打开一个程序实例或一个窗口。

** 单例的要求是他们是懒惰的创建——即直到第一次需要时才创建实例。 **

** 单例只有一个实例。**

单例写法一：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public sealed class Singleton                              // 静态的在程序内存中只有一个
    {
        private static Singleton _Singleton = null;        
        private Singleton()                                // 将构造函数私有化
        {
            Console.WriteLine("Singleton被构造");
        }

        private static Singleton()                        // 静态函数，程序一打开即刻被调用。
        {
            _Singleton = new Singleton();
        }

        public static Singleton GetInstance()            // 对外提供静态方法
        {
            return _Singleton;
        }
    }

单例写法二：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public sealed class Singleton
{
    private static readonly Singleton instance = new Singleton();
    // 显式静态构造函数告诉C＃编译器
    // 不要将类型标记为BeforeFieldInit
    static Singleton()                                 
    {
    }

    private Singleton()                             // 将构造函数私有化
    {
    }

    public static Singleton Instance               // 对外提供静态方法
    {
        get
        {
            return instance;
        }
    }
}

单例写法三：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Singleton
{
        private static Singleton instance;      //instance单例变量名

        private Singleton()
        {
        
        }

        public static Singleton GetInstance()
        {
                if(instance==null)
                {
                        instance=new Singleton();
                }
                return instance;
        }
}

**
**

**

**
**

破坏单例**

1
2
3
4
5
6
7
8
9
10
11
12
Console.WriteLine("************************Reflection+Instance（反射+单例）*****************");
      //Singleton singleton = new Singleton();                                     // 单例是不能被这样初始化的，因为构造方法被私有化了！
      Singleton singleton1 = Singleton.GetInstance();                              // 1，2，3 创建的是同一个单例对象！
      Singleton singleton2 = Singleton.GetInstance();
      Singleton singleton3 = Singleton.GetInstance();
      {
        Assembly assembly = Assembly.Load("Ruanmou.DB.SqlServer");
        Type type = assembly.GetType("Ruanmou.DB.SqlServer.Singleton");
        Singleton singleton4 = (Singleton)Activator.CreateInstance(type, true);   // 利用Activator.CreateInstance（type, true）可以破坏单例，可以创建多个实例，可以访问私有的构造方法了！
        Singleton singleton5 = (Singleton)Activator.CreateInstance(type, true);   // 有点破解和黑客的意思了！
        Singleton singleton6 = (Singleton)Activator.CreateInstance(type, true);   
      }

多构造函数的情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class ReflectionTest
    {
        #region Identity
        /// <summary>
        /// 无参构造函数
        /// </summary>
        public ReflectionTest()
        {
            Console.WriteLine("这里是{0}无参数构造函数", this.GetType());
        }

        /// <summary>
        /// 带参数构造函数
        /// </summary>
        /// <param name="name"></param>
        public ReflectionTest(string name)
        {
            Console.WriteLine("这里是{0} 有参数构造函数", this.GetType());
        }

        public ReflectionTest(int id)
        {
            Console.WriteLine("这里是{0} 有参数构造函数", this.GetType());
        }
    }
1
2
3
4
5
6
7
8
{
    Assembly assembly = Assembly.Load("Ruanmou.DB.SqlServer");                                             // 01. dll加载
    Type type = assembly.GetType("Ruanmou.DB.SqlServer.ReflectionTest");                                   // 02. 获取类型信息
    object oReflectionTest1 = Activator.CreateInstance(type);                                              // 03. 第一种，直接调用的是无参数的构造函数。
    object oReflectionTest2 = Activator.CreateInstance(type, new object[] { 123 });                        // 04. 第二种，直接调用的是带参数的构造函数。 （params） object[] args
    object oReflectionTest3 = Activator.CreateInstance(type, new object[] { "123" });                      //                                                       args:与要调用构造函数的参数数量、顺序和类型匹配的参数数组。
}

泛型的情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
namespace Ruanmou.DB.SqlServer
{
    public class GenericClass<T, W, X>
    {
        public void Show(T t, W w, X x)
        {
            Console.WriteLine("t.type={0},w.type={1},x.type={2}", t.GetType().Name, w.GetType().Name, x.GetType().Name);
        }
    }

    public class GenericMethod
    {
        public void Show<T, W, X>(T t, W w, X x)
        {
            Console.WriteLine("t.type={0},w.type={1},x.type={2}", t.GetType().Name, w.GetType().Name, x.GetType().Name);
        }
    }

    public class GenericDouble<T>
    {
        public void Show<W, X>(T t, W w, X x)
        {
            Console.WriteLine("t.type={0},w.type={1},x.type={2}", t.GetType().Name, w.GetType().Name, x.GetType().Name);
        }
    }
}
1
2
3
4
5
6
7
8
{
    Assembly assembly = Assembly.Load("Ruanmou.DB.SqlServer");
    Type type = assembly.GetType("Ruanmou.DB.SqlServer.GenericClass`3");                                // `3代表几个，这样泛型类型才能查找成功！
      //object oGeneric = Activator.CreateInstance(type);
    Type newType = type.MakeGenericType(new Type[] { typeof(int), typeof(string), typeof(DateTime) });  // MakeGenericType指定泛型参数类型
                                                                                                        // 生成实例要用MakeGenericType指定后的类型（泛型要先指定类型）
    object oGeneric = Activator.CreateInstance(newType);
}

Typeof(MySqlHelper)与iDBHelper.GetType()的区别：

一个针对类型，一个针对变量使用。

以上为API的使用技巧（API Show）。

**
**

二、利用反射调用方法：

** MVC使用**

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//oReflectionTest.Show1();
 {
   MethodInfo method = type.GetMethod("Show1");
   method.Invoke(oReflectionTest, null);                          
 }
 {
   MethodInfo method = type.GetMethod("Show2");
   method.Invoke(oReflectionTest, new object[] {123});
  }
  {
    MethodInfo method = type.GetMethod("Show5");
    method.Invoke(oReflectionTest, new object[] {"麦田的稻草人"});
    method.Invoke(null, new object[] {"果然"});//静态方法不需要实例
  }
  {
    MethodInfo method = type.GetMethod("Show3", new Type[] { });
    method.Invoke(oReflectionTest, new object[] { });
  }
  {
    MethodInfo method = type.GetMethod("Show3", new Type[] {typeof(int)});
    method.Invoke(oReflectionTest, new object[] {123});
  }
  {
    MethodInfo method = type.GetMethod("Show3", new Type[] {typeof(string)});
   method.Invoke(oReflectionTest, new object[] {"Ant"});
  }
  {
    MethodInfo method = type.GetMethod("Show3", new Type[] {typeof(int), typeof(string)});
    method.Invoke(oReflectionTest, new object[] {234, "W"});
  }
  {
    MethodInfo method = type.GetMethod("Show3", new Type[] {typeof(string), typeof(int)});
    method.Invoke(oReflectionTest, new object[] {"W", 234});
  }

泛型调用私有方法

1
2
3
4
5
6
7
8
9
10
11
12
 {  //反射也可以把私有方法也能调用
  MethodInfo method = type.GetMethod("Show4", BindingFlags.Instance | BindingFlags.NonPublic);
  method.Invoke(oReflectionTest, new object[] {"天空之上"});
}
{
  Type typeGenericDouble = assembly.GetType("Ruanmou.DB.SqlServer.GenericDouble`1");//`1,带有几个泛型参数，目前是一个参数。
  Type newType = typeGenericDouble.MakeGenericType(new Type[] {typeof(int)t       //泛型需要给定类型，使用新类型
  object oGeneric = Activator.CreateInstance(newType);                              //将类型实例化使用
  MethodInfo method = newType.GetMethod("Show");                                    //类型.方法，类型找方法
  MethodInfo methodNew = method.MakeGenericMethod(new Type[] {typeof(string), typeof(DateTime)});//泛型方法需要指定类型
  methodNew.Invoke(oGeneric, new object[] {123, "流浪诗人", DateTime.Now});         //调用方法的时候，需要实例对象，需要参数的时候，需要将参数传入                                                                              
}

三、反射调用属性、字段

** ORM使用 （实体）**

没有使用反射：

1
2
3
4
5
6
7
8
People people = new People();
  people.Id = 123;
  people.Name = "Lutte";
  people.Description = "高级班的新学员";

  Console.WriteLine($"people.Id={people.Id}");
  Console.WriteLine($"people.Name={people.Name}");
  Console.WriteLine($"people.Description={people.Description

使用反射的方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//通过反射操作属性
Type type = typeof(People);
object oPeople = Activator.CreateInstance(type);           //01.实例化时候，调用了构造函数
foreach (var prop in type.GetProperties())                 //02.通过类型遍历属性
{
   // Console.WriteLine("————————————查看类型的名称————————————");
   // Console.WriteLine(type.Name);     //People类型的名字：People  
   // Console.WriteLine("————————————查看属性的名称————————————");
   // Console.WriteLine(prop.Name);     //属性的名字：ID/Name/Description
   // Console.WriteLine("————————————查看属性的值————————————");
   // Console.WriteLine(prop.GetValue(oPeople));
    
    if (prop.Name.Equals("Id"))
    {
        prop.SetValue(oPeople, 234);
    }
    else if (prop.Name.Equals("Name"))
    {
        prop.SetValue(oPeople, "风潇潇");
    }
    Console.WriteLine("————————————查看属性的名称————————————");
    Console.WriteLine(prop.Name);     //属性的名字：ID/Name/Description
    Console.WriteLine("————————————查看属性的值————————————");
    Console.WriteLine(prop.GetValue(oPeople));
    
    Console.WriteLine($"{type.Name}.{prop.Name}={prop.GetValue(oPeople)}");  //类名.属性名
}

//通过反射获取字段
 foreach (var field in type.GetFields())                   //03.通过类型遍历字段
 {
     Console.WriteLine(type.Name);
     Console.WriteLine(field.Name);
     Console.WriteLine(field.GetValue(oPeople));
     if (field.Name.Equals("Description"))
     {
         field.SetValue(oPeople, "高级班的新学员");
     }
     Console.WriteLine($"{type.Name}.{field.Name}={field.GetValue(oPeople)}");

原先的硬编码的方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
People people = new People();
  people.Id = 123;
  people.Name = "Lutte";
  people.Description = "高级班的新学员";

  {
      //PeopleDTO peopleDTO = (PeopleDTO)people;
      PeopleDTO peopleDTO = new PeopleDTO()
      {
          Id = people.Id,
          Name = people.Name,
          Description = people.Description
      }; //硬编码

利用反射的形式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Type typePeople = typeof(People);
Type typePeopleDTO = typeof(PeopleDTO);
object people = Activator.CreateInstance(typePeople);
object peopleDTO = Activator.CreateInstance(typePeopleDTO);                //创建出实例

//通过反射获取属性
foreach (var prop in typePeopleDTO.GetProperties())
{ 
   //  if (prop.Name.Equals("Id"))
   // {
   //     //object value = typePeople.GetProperty("Id").GetValue(people);
   //     object value01 = typePeople.GetProperty(prop.Name).GetValue(people);
   //     prop.SetValue(peopleDTO, value01);
   // }
   // else if (prop.Name.Equals("Name"))
   // {
   //     //object value = typePeople.GetProperty("Name").GetValue(people);
   //     object value02 = typePeople.GetProperty(prop.Name).GetValue(people);
   //     prop.SetValue(peopleDTO, value02);
   // }
   //利用反射快速通用方式获取
   object value = typePeople.GetProperty(prop.Name).GetValue(people);
   prop.SetValue(peopleDTO, value);
}


//通过反射获取字段
foreach (var filed in typePeopleDTO.GetFields())
{
        object value = typePeople.GetField(filed.Name).GetValue(people);
        filed.SetValue(peopleDTO, value);
}

作业：

反射的重要应用：数据库查询的应用。

** 总结：**

反射的优缺点：

**
**

** 1.反射的优点：
**

动态: IOC : 动态加载dll，动态获取类型，动态获取对象。

MVC: 类型的实例化，方法的调用，给动态了。

ORM: ORM设置值给动态了。

面向对象开发，最大的特点是静态语言，追求稳定。程序稳定！

但是程序可扩展的话，面向抽象，接口！随意替换，可配置可扩展！通过动态的形式拼接出来，形成系统/框架。

反射对于框架来说，至关重要！

** 2.反射的缺点：**

01. 反射写起来较为复杂。

02. 避开编译器的检查。编译器不会报错了，找错不容易！

03. 性能问题。反射性能不好！性能损失很大！500倍左右！但是实际操作起来，影响不大。

性能优化：空间换时间！ 差别7倍左右！ 将加载dll，放在外面。 第一次加载的时候放入缓存。

MVC：第一次访问很慢，后面很快！ 第一次：各种映射信息读取一边。

EF: 第一次使用很慢，后面很快！

IOC：

ORM等框架的使用！

讲一个可用的东西写成通用的东西！

额外总结：

API的自学能力很重要！

Map的使用！

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
三维数字孪生、虚拟仿真
三维平台数据展示、VR沉浸式开发、党建360/720全景开发

联系QQ:2583493258

很惭愧

只做了一点微小的工作
谢谢大家