C#反射

1.What?反射是什么?

反射:无处不在,MVC,Webfrom,asp.net,ORM,IOC,AOP,几乎所有的框架都离不开反射,那么反射到底是什么?

我们写的代码,计算机要识别,需要二次编译,中间会经过编译器编译,得到dll,exe,再被JIT编译最终被计算机语言识别,执行,那dll,exe是怎么生成的呢?

生成的exe还可以直接打开执行

 那这个exe里面具体是什么呢?我们可以用反编译工具打开看看,打开就可以看到我们反编译以后的IL:也是一种面向对象语言,但是不太好阅读

反射Reflection:system.Reflection,其实就是.net.fromwork提供的一个帮助内库,可以读取并使用metadata

那我们如何去读取信息呢?

2.用反射加载和读取信息[三种方式]

我们先随便写个接口类:新建-DB.Interface类库,新建一个接口类IDBHelper

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Threading.Tasks;
 6 
 7 namespace DB.Interface
 8 {
 9     // DB.Interface接口类库
10     public interface IDBHelper
11     {
12         void Query();
13     }
14 }

再新建一个DB.MySql类库,新建一个MySqlHelper类继承接口IDBHelper

using DB.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DB.MySql
{
    public class MySqlHelper : IDBHelper
    {
        /// <summary>
        /// MySqlHelper构造函数
        /// </summary>
        public MySqlHelper()
        {
            Console.WriteLine("{0}被构造", this.GetType().Name);
        }
        /// <summary>
        /// Query方法
        /// </summary>
        public void Query()
        {
            Console.WriteLine("{0}.Query",this.GetType().Name);
        }
    }
}
MySqlHelper

按照上面的步骤,新建一个DB.SqlServer类库,新建一个SqlServerHelper类继承接口IDBHelper

using DB.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DB.SqlServer
{
    /// <summary>
    /// SqlServer实现
    /// </summary>
    public class SqlServerHelper : IDBHelper
    {
        /// <summary>
        /// SqlServerHelper构造函数
        /// </summary>
        public SqlServerHelper()
        {
            Console.WriteLine("{0}被构造",this.GetType().Name);
        }
        /// <summary>
        /// Query方法
        /// </summary>
        public void Query()
        {
            Console.WriteLine("{0}.Query",this.GetType().Name);
        }
    }
}
SqlServerHelper
                #region Reflecgion
                {
                    Console.WriteLine("---------------------------------------------反射加载和读取信息---------------------------------------------------------");
                    //动态加载 都是把dll加到内存里面去,不需要向上面的普通方法一样引用
                    //1.一个完整的dll名称,不需要后缀,目的:把dll加载到内存中间去;
                    //缺陷:但是有个限制从编译以后生成的exe所在的路径去查找,既可以找dll,又可以找exe,两个一样得话先找dll【常用】
                    Assembly assembly = Assembly.Load("DB.MySql");
                    //2.还有一种加载方式,path,需要一个完整的路径,性能差不多,也可以切换为别的引用了的路径【全名称= 全路径+dll名称 + 后缀】
                    Assembly assembly1 = Assembly.LoadFile(@"F:\LearnTest\MyReflectionFirst\MyReflectionFirst\bin\Debug\DB.MySql.dll");
                    //3.loadfrom:带后缀的,当前路径查找,也可以全路径
                    Assembly assembly2 = Assembly.LoadFrom("DB.MySql.dll");//【当前路径+ 后缀】
                    Assembly assembly3 = Assembly.LoadFrom(@"F:\LearnTest\MyReflectionFirst\MyReflectionFirst\bin\Debug\DB.MySql.dll");

                    //读取里面的信息
                    foreach (var types in assembly.GetTypes())//GetTypes 获取此程序集中的全部类型
                    {
                        Console.WriteLine(types.Name);
//type.IsGenericType //判断当前是否是泛型类
foreach (var method in types.GetMethods())//返回为GetMethods的所有公共方法 { Console.WriteLine(method.Name); } } } #endregion

 我们跟踪就可以看到利用反射加载出来的一些基本信息

3.反射使用信息

                #region Common
                {
                    Console.WriteLine("---------------------------------------------Common---------------------------------------------------------");
                    {
                        //添加接口引用,内库引用,实例化并且调用方法
                        IDBHelper dBHelper = new MySqlHelper();
                        dBHelper.Query();
                    }
                }
                #endregion
                #region Reflecgion
                {
                    Console.WriteLine("---------------------------------------------用反射使用信息---------------------------------------------------------");
                    //1.动态加载
                    Assembly assembly = Assembly.Load("DB.MySql");
                    // 第一步我们会获取到全部的类型,也可以指定获取类型【完整类型名称】
                    Type type = assembly.GetType("DB.MySql.MySqlHelper");
                    //3.实例化
                     // 意思跟Activator.CreateInstance(type);差不多都是实例化new MySqlHelper();但是这边创建的实例是个object类型
                    object oDBHelper=Activator.CreateInstance(type);
                    //很确定oDBHelper里面有Query这个方法Why不能直接调用方法?编译器不认可,不能直接调用
                    //c#是一门强类型语言,静态语言,编译时就确定好了类型确保安全
                    //oDBHelper.Query()
                    //dynamic可以是因为它很特殊编译器不检查,运行时才检查
                    //dynamic dDBHelper = Activator.CreateInstance(type);
                    //dDBHelper.Query();

                    //4.类型转换,类型不对会直接返回null
                    IDBHelper dBHelper = oDBHelper as IDBHelper;
                    //5.方法调用
                    dBHelper.Query();
                }
                #endregion

那么问题来了我只需要用普通方法两句话写完的,我们为什么要用反射要写5句???何必呢?意义何在?

我们就上面的代码先来封装一下看看:

1 <configuration>
2     <startup> 
3         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
4     </startup>
5     <appSettings>
6         <!--以英文逗号","分开-->
7         <add key="IDBHelperConfig" value="DB.MySql.MySqlHelper,DB.MySql"/>
8 </configuration>
namespace MyReflectionFirst
{
    public class SingleFactory
    {
        /// <summary>
        /// private避免被人可以看到,static静态,会在程序第一次调用的时候读取,只读一遍
        /// </summary>
        private static string IDBHelperConfig = ConfigurationManager.AppSettings["IDBHelperConfig"].ToString();
        private static string TypeName = IDBHelperConfig.Split(',')[0];
        private static string DLLName = IDBHelperConfig.Split(',')[1];
        public static IDBHelper CreateInstance()
        {
            Assembly assembly = Assembly.Load(DLLName);
            Type type = assembly.GetType(TypeName);
            object oDBHelper = Activator.CreateInstance(type);
            IDBHelper dBHelper = oDBHelper as IDBHelper;
            return dBHelper;
        }
    }
}

那我们再来调用看看:

                {
                    Console.WriteLine("-------------------------------------Reflecgion+Factory+Config-------------------------------------------------");
                    IDBHelper dBHelper = SingleFactory.CreateInstance();
                    dBHelper.Query();
                }

这是普通方法和反射封装完成调用 的结果以及代码对比,从调用上是不是差不多了呢?

我们再进一步对比延伸扩展一下:

如果我们需要更换一下版本呢?

普通方法:【就必须重新引用,修改代码,重新编译发布

                        //如果从MySqlHelper换成SqlServerHelper,就必须重新引用,修改代码,重新编译发布
                        IDBHelper dBHelper = new SqlServerHelper();
                        dBHelper.Query();

而我们的反射,只需修改配置文件即可:

                      <add key="IDBHelperConfig" value="DB.SqlServer.SqlServerHelper,DB.SqlServer"/>

 结果:

那要是我们要新增一个以前没有的Oracle版本:

按照上面的步骤,新建一个DB.Oracle类库,新建一个OracleHelper类继承接口IDBHelper

using DB.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DB.Oracle
{
    public class OracleHelper : IDBHelper
    {
        public OracleHelper() 
        {
            Console.WriteLine("{0}被构造",this.GetType().Name);
        }
        public void Query()
        {
            Console.WriteLine("{0}.Query",this.GetType().Name);
        }

    }
}
OracleHelper

 用反射,通过修改配置文件就可以达到以下结果:

                  <add key="IDBHelperConfig" value="DB.Oracle.OracleHelper,DB.Oracle"/>

结果:

//特点:动态扩展性太强
//可配置可扩展:完全不修改原有代码,只是增加新的实现,copy,修改配置文件,就可以支持新功能
//原理:反射的动态加载和动态创建对象,以及配置文件结合
//可以支持随机换,也可以后面新增
//前提:实现类必须是事先已有的,而且在目录下面的

4.反射的使用

上面我们用反射获取了无参数的构造函数,那么我们怎么去获取有参数的构造函数呢?我们怎么去获取构造函数参数,以及类型,调用?

 让我们看一个例子,在DB.SqlServer类库中,新建一个ReflecgionTest类

    public class ReflecgionTest
    {
        #region Identity
        public ReflecgionTest()
        {
            Console.WriteLine("这是{0}无参数构造函数", this.GetType());
        }
        public ReflecgionTest(string name)
        {
            Console.WriteLine("这是{0}有参数构造函数", this.GetType());
        }
        public ReflecgionTest(int id)
        {
            Console.WriteLine("这是{0}有参数构造函数", this.GetType());
        }
        #endregion
    }
                {
                    Console.WriteLine("-----------------------------------ctor&parameter---------------------------------------------------");
                    Assembly assembly = Assembly.Load("DB.SqlServer");
                    Type type = assembly.GetType("DB.SqlServer.ReflecgionTest");
                    //获取构造函数
                    foreach (ConstructorInfo ctor in type.GetConstructors())//循环访问集合或数组的名称
                    {
                        Console.WriteLine(ctor.Name);
                        //获取构造函数参数
                        foreach (var parameter in ctor.GetParameters())
                        {
                            //获取构造函数参数类型
                            Console.WriteLine(parameter.ParameterType);
                        }
                    }

                    //怎么为不同的构造函数指定不同的参数类型
                    //object test1 = Activator.CreateInstance(type);
                    //object test2 = Activator.CreateInstance(type, "123");
                    //object test3 = Activator.CreateInstance(type, 123);
                    //应用建议改为以下写法
                    object test4 = Activator.CreateInstance(type, new object[] { "123" });
                    object test5= Activator.CreateInstance(type, new object[] { 123});
                }

结果:

5.反射-黑科技:反射破坏单例

让我们看一个例子,在DB.SqlServer类库中,新建一个Singleton类

namespace DB.SqlServer
{
    /// <summary>
    /// 单例模式:就是一个类,保证在整个进程中就只有一个实例
    /// </summary>
    public sealed class Singleton
    {
        //3.当然这个实例只能有一个,所以我们提供了一个静态字段,
        private static Singleton _singleton = null;
        //1.构造函数私有化,才不能随便new,才能保证只有一个对象
        private Singleton()
        {
            Console.WriteLine("{0}被构造",this.GetType().Name);
        }
        //4.这个字段只能初始化一次,那怎么初始化?我们交给了这个静态构造函数,它由CLR保障,在程序启动的第一次调用这个类Singleton之前完成的调用,而且只调用一次
        static Singleton()
        {
            _singleton = new Singleton();
        }
        //2.私有化了之后,对外不能new,但我可以对外提供一个公开的静态方法,负责提供这个对象的实例,可以调用这个方法获取这个实例,那怎么获取?
        public static Singleton GetInstance()
        {
            return _singleton;
        }
    }
}
                {
                    Console.WriteLine("-----------------------------------扩展:未使用反射之前的单例调用---------------------------------------------------");
                    //Singleton singleton = new Singleton();//私有化不能直接构造
                    Singleton singleton1 = Singleton.GetInstance();
                    Singleton singleton2 = Singleton.GetInstance();
                    Singleton singleton3 = Singleton.GetInstance();
                    Console.WriteLine($"{Object.ReferenceEquals(singleton1, singleton3)}");//不管有几个实例,结果肯定为True,因为都是同一个对象,只会被构造一次
                }
                {
                    Console.WriteLine("-----------------------------------扩展:反射破坏单例---反射调用私有构造函数---------------------------------------------------");
                    Assembly assembly = Assembly.Load("DB.SqlServer");
                    Type type = assembly.GetType("DB.SqlServer.Singleton");
                    //Singleton singletonA=(Singleton)Activator.CreateInstance(type);//类型转换
                    //如上写法会报错,因为上面我们说过它相当于一个实例化,但是这个构造函数私有化,不能直接New
                    Singleton singletonA = (Singleton)Activator.CreateInstance(type,true);//但是反射做到了这件事
                    //Why这个地方执行了第一次使用的时候会执行两遍构造函数,程序在一次使用这个类的时候就会去完成静态构造函数的构造,程序在每次使用都会再去构造一次
                    Singleton singletonB = (Singleton)Activator.CreateInstance(type, true);
                    Singleton singletonC = (Singleton)Activator.CreateInstance(type, true);
                    //nonPublic:如果公共或非公共默认构造函数可以匹配,则为true;如果只有公共默认构造函数可以匹配,则为false。
                    //所以对象是不一样的,对象被构造了多次
                    Console.WriteLine($"{Object.ReferenceEquals(singletonA,singletonC)}");

                }

结果对比:

 六.反射调用泛型类与方法

让我们看一个例子,在DB.SqlServer类库中,新建一个GenericTest类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DB.SqlServer
{
    public class GenericTest<T,W,X>
    {
        public void Show(T t, W w,X x)
        {
            Console.WriteLine("This's 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("This's t.type={0},w.type={1}, x.type={2},t:{3},w:{4},x:{5}", t.GetType().Name, w.GetType().Name, x.GetType().Name, t, w, x);
        }
    }
    public class GenericDouble<T>
    {
        public void Show<W, X>(T t, W w, X x)
        {
            Console.WriteLine("This's t.type={0},w.type={1}, x.type={2},t:{3},w:{4},x:{5}", t.GetType().Name, w.GetType().Name, x.GetType().Name,t,w,x);
        }
    }
}
泛型
                {
                    Console.WriteLine("-----------------------------------扩展:反射和泛型---------------------------------------------------");
                    Assembly assembly = Assembly.Load("DB.SqlServer");
                    Type type = assembly.GetType("DB.SqlServer.GenericTest");
                    Object oGeneric = Activator.CreateInstance(type);
                }

按照之前的操作,我们发现这边得到的type=null?Why?

//原因:因为public class GenericTest<T,W,X>它是泛型编译之后会变为DB.SqlServer.GenericTest`3<T, W, X>【反编译工具也可以看到】

// 我们需要把它修改为:
Type type = assembly.GetType("DB.SqlServer.GenericTest`3");

跟踪结果已经找到了我们要的数据了:

 再执行,报错了,类型找到了,为什么它不能创建这个实例?它不是有个无参数构造函数吗?为什么没能创建一个实例?

 那这代码现在应该如何修改呢?

                    //在泛型类型时,不能忘记我们创建对象,它是不能够实例化的,【eg:GenericTest genericTest=new GenericTest()】那肯定是不行的
                    //起码你得指定好类型才能够实例化【eg:GenericTest<int, string, DateTime> genericTest = new GenericTest<int, string, DateTime>();】那应该怎样写呢?
                    Type typeMake = type.MakeGenericType(new Type[] {typeof(int),typeof(string),typeof(DateTime) });
                    //泛型类是一个不确定类型的,这句话就表示我把类型确定一下,你要什么参数类型,这边是个type数组,new Type[] {}数组
                    Object oGeneric = Activator.CreateInstance(typeMake);//只有这个typeMake才可以创建,这边不能强制转换,因为需要类型

跟踪的结果:

如果反射创建对象之后,知道方法名称,怎么样不做类型转换,直接调用方法?让我们直接下面的实例吧

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DB.SqlServer
{
    public class ReflecgionTest
    {
        #region Identity
        public ReflecgionTest()
        {
            Console.WriteLine("这是{0}无参数构造函数", this.GetType());
        }
        public ReflecgionTest(string name)
        {
            Console.WriteLine("这是{0}有参数构造函数", this.GetType());
        }
        public ReflecgionTest(int id)
        {
            Console.WriteLine("这是{0}有参数构造函数", this.GetType());
        }
        #endregion

        #region Method
        /// <summary>
        /// 无参方法
        /// </summary>
        public void Show1()
        {
            Console.WriteLine("这里是{0}的Show1", this.GetType());
        }
        /// <summary>
        /// 有参数方法
        /// </summary>
        /// <param name="id"></param>
        public void Show2(int id)
        {
            Console.WriteLine("这里是{0}的Show2", this.GetType());
        }
        /// <summary>
        /// 重载方法之一
        /// </summary>
        /// <param name="id"></param>
        /// <param name="name"></param>
        public void Show3(int id, string name)
        {
            Console.WriteLine("这里是{0}的Show3,id:{1},string:{2}", this.GetType(),id,name);
        }
        /// <summary>
        /// 重载方法之二
        /// </summary>
        /// <param name="name"></param>
        /// <param name="id"></param>
        public void Show3(string name, int id)
        {
            Console.WriteLine("这里是{0}的Show3_2,string:{1},id:{2}", this.GetType(),name,id);
        }
        /// <summary>
        /// 重载方法之三
        /// </summary>
        /// <param name="id"></param>
        public void Show3(int id)
        {

            Console.WriteLine("这里是{0}的Show3_3,id:{1}", this.GetType(),id);
        }
        /// <summary>
        /// 重载方法之四
        /// </summary>
        /// <param name="name"></param>
        public void Show3(string name)
        {

            Console.WriteLine("这里是{0}的Show3_4,name:{1}", this.GetType(),name);
        }
        /// <summary>
        /// 重载方法之五
        /// </summary>
        public void Show3()
        {
            Console.WriteLine("这里是{0}的Show3_1", this.GetType());
        }
        /// <summary>
        /// 私有方法
        /// </summary>
        /// <param name="name"></param>
        private void Show4(string name)
        {
            Console.WriteLine("这里是{0}的Show4_私有方法调用", this.GetType());
        }
        /// <summary>
        /// 静态方法
        /// </summary>
        /// <param name="name"></param>
        public static void Show5(string name)
        {
            Console.WriteLine("这里是{0}的Show5_静态方法调用", typeof(ReflecgionTest));
        }
        #endregion
    }
}
ReflecgionTest.cs

反射调用:无参数,有参数,重载,静态,私有方法实例

                {
                    Console.WriteLine("如果反射创建对象之后,知道方法名称,怎么样不做类型转换,直接调用方法?");
                    Assembly assembly = Assembly.Load("DB.SqlServer");
                    Type type = assembly.GetType("DB.SqlServer.ReflecgionTest");
                    Object test = Activator.CreateInstance(type);
                    //主要是查看它里面的所有方法名,参数,参数类型
                    foreach (var metohd in type.GetMethods())
                    {
                        Console.WriteLine(metohd.Name+"");
                        foreach (var parameter in metohd.GetParameters())
                        {
                            Console.WriteLine($"{parameter.Name},{parameter.ParameterType.Name}");
                        }
                    }
                    //反射调用无参数的方法
                    {
                        MethodInfo methodInfo = type.GetMethod("Show1");
                        methodInfo.Invoke(test, null);//第一个参数表示实例,后一个参数列表
                    }
                    //反射调用带参数的方法
                    {
                        MethodInfo methodInfo1 = type.GetMethod("Show2");
                        methodInfo1.Invoke(test, new object[] { 123 });
                    }
                    //重载方法调用
                    {
                        MethodInfo method=type.GetMethod("Show3",new Type[] { typeof(string),typeof(int)});
                        method.Invoke(test, new object[] { "现在是哪一年", 2020});
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3",new Type[] { typeof(int),typeof(string)});
                        method.Invoke(test, new object[] { 2020, "year" });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3",new Type[] { typeof(int)});
                        method.Invoke(test, new object[] { 2020 });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3",new Type[] { typeof(string)});
                        method.Invoke(test, new object[] { "wang" });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3",new Type[] { });
                        method.Invoke(test, null);
                    }
                    //静态方法【特别】:实例可以要,也可以不要【null】
                    {
                        MethodInfo method = type.GetMethod("Show5");
                        method.Invoke(null,new object[] { "你好"});
                    }
                    {
                        MethodInfo method = type.GetMethod("Show5");
                        method.Invoke(test, new object[] { "你好" });
                    }
                    {//反射调用私有方法
                        var method = type.GetMethod("Show4", BindingFlags.Instance | BindingFlags.NonPublic);
                        method.Invoke(test, new object[] { "私有方法调用" });
                    }
                }

结果:

  那么泛型的方法又如何用反射调用呢?

                {
                    Console.WriteLine("-----------------------------------扩展:泛型方法GenericMethod---------------------------------------------------");
                    Assembly assembly = Assembly.Load("DB.SqlServer");
                    Type type = assembly.GetType("DB.SqlServer.GenericMethod");
                    Object oGeneric = Activator.CreateInstance(type);
                    MethodInfo method = type.GetMethod("Show");//泛型方法不用Show`3
                    var methodnew=method.MakeGenericMethod(new Type[]{ typeof(int),typeof(string), typeof(DateTime)});
                    methodnew.Invoke(oGeneric, new object[] { 12, "泛型方法 ", DateTime.Now });
                }

结果:

泛型方法和泛型类同时存在的情况:

                {
                    Console.WriteLine("扩展:泛型类+泛型方法GenericMethod");
                    Assembly assembly = Assembly.Load("DB.SqlServer");
                    Type type = assembly.GetType("DB.SqlServer.GenericDouble`1").MakeGenericType(new Type[] { typeof(int) });
                    Object oObject=Activator.CreateInstance(type);
                    MethodInfo method = type.GetMethod("Show").MakeGenericMethod(new Type[] {typeof(string),typeof(DateTime) });
                    method.Invoke(oObject,new object[] { 2020,"hello",DateTime.Today});
                }

结果:

 七:反射的应用:

获取全部的实体的全部属性并给其赋值:

//实体类不考虑扩展问题,没意义
                    Console.WriteLine("---------------------------------------------Reflection---------------------------------------------------------");
                    Type type = typeof(People);
                    Object opeople=Activator.CreateInstance(type);
                    //获取全部的属性
                    foreach (var prop in type.GetProperties())
                    {
                        Console.WriteLine($"{type.Name}.{prop.Name}={prop.GetValue(opeople)}");
                        //给prop里面的属性增加一个值
                        if (prop.Name.Equals("Id"))
                        {
                            prop.SetValue(opeople, 1);
                        }
                        else if(prop.Name.Equals("Name"))
                        {
                            prop.SetValue(opeople, "泛型实体属性");
                        }
                        Console.WriteLine($"{type.Name}.{prop.Name}={prop.GetValue(opeople)}");
                    }
                    foreach (var field in type.GetFields())
                    {
                        Console.WriteLine($"{type.Name}.{field.Name}={field.GetValue(opeople)}");
                        if (field.Name.Equals("Description"))
                        {
                            field.SetValue(opeople, "只是一个字段");
                        }
                        Console.WriteLine($"{type.Name}.{field.Name}={field.GetValue(opeople)}");
                    }
//思考:反射对实体层的操作如此麻烦,Why我们还要用它?eg:让我们一起看一个场景:
        public Company FindOld(int Id)
        {
            string sql = @"SELECT  [Id]
                                    ,[Name]
                                    ,[CreateTime]
                                    ,[CreatorId]
                                    ,[LastModifierId]
                                    ,[LastModifyTime]
                                    FROM [Company]
                                    where Id="+Id;
            //[Name],[CreateTime],[CreatorId],[LastModifierId],[LastModifyTime],[Id]
            using (SqlConnection con = new SqlConnection(ConnectionStringCustomers))
            {
                SqlCommand sqlCommand = new SqlCommand(sql, con);
                con.Open();
                var reader=sqlCommand.ExecuteReader();
                if (reader.Read())//有数据才开始读,有数据True
                {
                    Console.WriteLine(reader[1]);
                }
                con.Close();
                con.Dispose();
            }
            return new Company();
        }

现在只有一个表,我们还有一个表,那如果我们有很多表,那岂不是都需要写很多方法, 如果我们希望一个方法,能返回不同的类型,针对以上代码优化:

        /// <summary>
        ///  如果我们希望一个方法,能返回不同的类型?泛型+反射【不同类型,不同sql】,
        /// </summary>
        public T Find<T>(int Id)
        {
            Type type = typeof(T);

            //type.GetProperties().Select(p=> p.Name)得到属性名称,
            //type.GetProperties().Select(p => $"[{p.Name}]")得到它的属性名称并写出如下格式:[CreatorId]*/
            //得到的是一个集合,需要把它变成一个逗号连接的字符串

            //得到它的属性名称,把它变成一个逗号连接的字符串
            string prop = string.Join(",", type.GetProperties().Select(p => $"[{p.Name}]"));
            
            //动态拼接Sql
            string sql = $"select {prop} from [{type.Name}] where ID={Id}";
            Object oObject = Activator.CreateInstance(type);
            //如果是User表User在数据库里面属于关键字,[{type.Name}]类似FROM [User]
            using (SqlConnection con = new SqlConnection(ConnectionStringCustomers))
            {
                SqlCommand sqlCommand = new SqlCommand(sql, con);
                con.Open();
                var reader = sqlCommand.ExecuteReader();
                if (reader.Read())//有数据才开始读,有数据True
                {
                    //获取所有的属性进行赋值
                    foreach (var propinfo in type.GetProperties())
                    {
                        //针对数据库名跟实力类名一一对应的场景
                        propinfo.SetValue(oObject, reader[propinfo.Name] is DBNull ? null : reader[propinfo.Name]);
                    }
                    return (T)oObject;
                }
                else
                {
                    return default;
                }
            }
            
        }

调用:

                {
                    SqlServerHelper sqlServer = new SqlServerHelper();
                    Company company = sqlServer.Find<Company>(1);
                    User user = sqlServer.Find<User>(1);
                }
                {
                    Console.WriteLine("---------------------------------------------Common---------------------------------------------------------");
                    People people = new People();
                    people.Id = 1;
                    people.Name = "普通";
                    people.Description = "描述:";
                    Console.WriteLine($"people.Id ={people.Id}");
                    Console.WriteLine("people.Name = {0},people.Description={1}",people.Name,people.Description);
                }
//Get:反射展示是意义的,可以不用改代码,普通方法需要修改
//Set:感觉没什么用,但是还是有用,
                    //反射:
                    //优点:动态,【几乎任何一个框架里面都有反射,我们搭建框架就是希望有良好的扩展性,能够应对将来任意的需求变化】
                    //缺点;1.使用麻烦【封装一下】;2.避开编译器检查,运行时出问题;3.性能问题;
using DB.Interface;
using DB.SqlServer;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace MyReflectionFirst
{
    public class Monitor
    {
        public static void Show()
        {
            Console.WriteLine("------------------------------Monitor普通方法与反射的性能测试--------------------------------------------");
            //初始化
            long ComonTime = 0;
            long ReflectionTime = 0;
            {
                Stopwatch stopwatch = new Stopwatch();
                stopwatch.Start();
                for (int i = 0; i < 1_000_000; i++)
                {
                    IDBHelper sqlServer = new SqlServerHelper();
                    sqlServer.Query();
                }
                stopwatch.Stop();
                ComonTime = stopwatch.ElapsedMilliseconds;
            }
            {
                Stopwatch stopwatch = new Stopwatch();
                stopwatch.Start();
                Assembly assembly = Assembly.Load("DB.SqlServer");
                Type type = assembly.GetType("DB.SqlServer.SqlServerHelper");
                for (int i = 0; i < 1_000_000; i++)
                {
                    Object oDBHelper = Activator.CreateInstance(type);
                    IDBHelper dBHelper = oDBHelper as IDBHelper;
                    dBHelper.Query();
                }
                stopwatch.Stop();
                ReflectionTime = stopwatch.ElapsedMilliseconds;
            }
            Console.WriteLine("ComonTime:{0}ms,ReflectionTime:{1}ms", ComonTime, ReflectionTime);
            //ComonTime:71ms,ReflectionTime:134ms
        }
    }
}
Monitor普通方法与反射的性能测试

 

posted @ 2020-11-12 17:46  wangwangwangMax  阅读(64)  评论(1编辑  收藏