Exemplo n.º 1
0
        static void Main(string[] args)
        {
            try
            {
                #region 创建连接
                {
                    Console.WriteLine("==========创建连接=============");
                    //IDBHelper iDBHelper = new MySqlHelper();
                    IDBHelper iDBHelper = new SqlServerHelper();

                    //当MySqlHelper换成SqlServerHelper 就必学修改现有的代码,重新编译然后发布,为了提高效率我们可以利用反射来解决这一问题。
                }
                #endregion

                #region 加载DLL
                {
                    Console.WriteLine("==========加载DLL==========");
                    //根据名称加载程序集
                    //Assembly assembly = Assembly.Load("Gs.DB.MySql");
                    //根据完整路径加载程序集
                    //Assembly assembly1 = Assembly.LoadFile(@"‪C:\Users\wango\source\repos\Reflection\Gs.DB.MySql\bin\Debug\Gs.DB.MySql.dll");
                    //根据名称加载程序集
                    Assembly assembly2 = Assembly.LoadFrom("Gs.DB.SqlServer.dll");
                    //根据完整路径加载程序集
                    //Assembly assembly3 = Assembly.LoadFrom(@"C:\Users\wango\source\repos\Reflection\Gs.DB.MySql\bin\Debug\Gs.DB.MySql.dll");
                    ///**
                    ///以上四个assembly获取的结果都是一样的
                    ///看起来LoadFile和LoadFrom作用是一样,他们两个有什么区别呢?
                    ///LoadFile加载dll文件时只会加载指定的dll文件,不会加载与指定dll文件相关的dll文件,而LoadFrom则会加载与指定dll文件相关的dll文件
                    ///LoadFrom加载dll文件时会先检查前面是否已经加载过相同名称的dll,如果载入过相同的dll那就不能再载入,而LoadFile不检查,会直接覆盖之前相同名称的dll文件
                    ///

                    ///

                    foreach (var type in assembly2.GetTypes())
                    {
                        Console.WriteLine("类:" + type.Name);
                        foreach (var method in type.GetMethods())
                        {
                            Console.WriteLine(type.Name + "类中的方法:" + method.Name);
                        }
                    }
                }
                #endregion

                #region 加载DLL并创建对象
                {
                    Console.WriteLine("*****************加载DLL并创建对象、调用方法********************");
                    Assembly assembly = Assembly.Load("Gs.DB.SqlServer");                    //1 动态加载
                    Type     type     = assembly.GetType("Gs.DB.SqlServer.SqlServerHelper"); //2 获取程序集下的指定类
                    foreach (var member in type.GetMembers())
                    {
                        //遍历类中的方法
                        Console.WriteLine("方法名:" + member.Name);
                    }
                    //object oDBHelper = Activator.CreateInstance(type); //创建对象
                    //oDBHelper.Say(); //调用方法,实际上oDBHelper是有SqlServerHelper()这个方法,只不过编译器不通过,解决这个问题可以用dynamic来收
                    dynamic dDBHelper = Activator.CreateInstance(type);
                    dDBHelper.Say(); //dynamic编译器不检查,方法拼写一定要写对

                    //不使用dynamic,转换类型也可以
                    object    oDBHelper       = Activator.CreateInstance(type); //创建对象
                    IDBHelper SqlServerHelper = oDBHelper as IDBHelper;
                    SqlServerHelper.Say();                                      //调用方法,实际上oDBHelper是有SqlServerHelper()这个方法,只不过编译器不通过,解决这个问题可以用dynamic来收
                }
                #endregion 封装之后
                {
                    Console.WriteLine("*****************封装之后********************");
                    IDBHelper iDBHelper = SimpleFactory.CreateInstance();
                    iDBHelper.Say();
                    //程序的可配置,通过修改配置文件就可以自动切换,实现类必须是事先已有的,而且在目录下面,没有写死类型,而是通过配置文件执行,反射创建的
                    //可扩展:完全不修改原有代码,只是增加新的实现,copy,修改配置文件,就可以支持新功能
                    //反射的动态加载和动态创建对象  以及配置文件结合
                }

                #region 调用带参方法
                {
                    //Assembly assembly = Assembly.Load("Ruanmou.DB.SqlServer");
                    //Type type = assembly.GetType("Ruanmou.DB.SqlServer.ReflectionTest");
                    //foreach (ConstructorInfo ctor in type.GetConstructors())
                    //{
                    //    Console.WriteLine(ctor.Name);
                    //    foreach (var parameter in ctor.GetParameters())
                    //    {
                    //        Console.WriteLine(parameter.ParameterType);
                    //    }
                    //}
                    //object oTest1 = Activator.CreateInstance(type);
                    //object oTest2 = Activator.CreateInstance(type, new object[] { 123 });
                    //object oTest3 = Activator.CreateInstance(type, new object[] { "陌殇" });

                    Console.WriteLine("*****************调用带参方法********************");
                    Assembly assembly = Assembly.Load("Gs.DB.SqlServer");
                    Type     type     = assembly.GetType("Gs.DB.SqlServer.ReflectionTest");
                    foreach (ConstructorInfo ctor in type.GetConstructors())
                    {
                        //获取类中的构造方法
                        Console.WriteLine("111:" + ctor.Name);
                        foreach (var parameter in ctor.GetParameters())
                        {
                            //返回构造方法的参数
                            Console.WriteLine("222:" + parameter.ParameterType);
                        }
                    }
                    object oTest1 = Activator.CreateInstance(type);
                    object oTest2 = Activator.CreateInstance(type, new object[] { 960927 });
                    object oTest3 = Activator.CreateInstance(type, new object[] { "调用带参方法" });
                }
                #endregion

                #region 反射破坏单例
                {
                    Console.WriteLine("********************反射破坏单例********************");
                    Singleton singleton1 = Singleton.GetInstance(); //new Singleton();
                    Singleton singleton2 = Singleton.GetInstance();
                    Singleton singleton3 = Singleton.GetInstance();
                    Singleton singleton4 = Singleton.GetInstance();
                    Singleton singleton5 = Singleton.GetInstance();
                    Console.WriteLine($"{object.ReferenceEquals(singleton1, singleton5)}");

                    //反射破坏单例---因为构造方法是用private修饰的,防止外部调用,但是反射不受限制
                    Assembly  assembly   = Assembly.Load("Gs.DB.SqlServer");
                    Type      type       = assembly.GetType("Gs.DB.SqlServer.Singleton");
                    Singleton singletonA = (Singleton)Activator.CreateInstance(type, true);
                    Singleton singletonB = (Singleton)Activator.CreateInstance(type, true);
                    Singleton singletonC = (Singleton)Activator.CreateInstance(type, true);
                    Singleton singletonD = (Singleton)Activator.CreateInstance(type, true);
                    Console.WriteLine($"{object.ReferenceEquals(singletonA, singletonD)}");
                }

                #endregion 反射调用泛型
                {
                    Console.WriteLine("********************反射调用泛型********************");
                    Assembly assembly = Assembly.Load("Gs.DB.SqlServer");
                    Type     type     = assembly.GetType("Gs.DB.SqlServer.GenericClass`3"); //3表示GenericClass有3个参数

                    Type    typeMake = type.MakeGenericType(new Type[] { typeof(string), typeof(int), typeof(DateTime) });
                    dynamic oGeneric = Activator.CreateInstance(typeMake);
                    oGeneric.ShowA();
                    //MethodInfo method = type.GetMethod("Show").MakeGenericMethod(typeof(string), typeof(string), typeof(string));
                    //method.Invoke(oGeneric, new object[] { "123","456","789" });
                }
                #region   做类型转换调用
                {
                    //如果反射创建对象之后,知道方法名称,怎么样不做类型转换,直接调用方法?
                    //反射创建了对象实例---有方法的名称--反射调用方法
                    //dll名称---类型名称---方法名称---我们就能调用方法
                    //MVC就是靠的这一招---调用Action
                    //http://localhost:9099/home/index  经过路由解析---会调用--HomeController--Index方法
                    //浏览器输入时只告诉了服务器类型名称和方法名称,肯定是反射的
                    //MVC在启动时会先加载--扫描全部的dll--找到全部的Controller--存起来--请求来的时候,用Controller来匹配的---dll+类型名称
                    //1 MVC局限性的--Action重载--反射是无法区分---只能通过HttpMethod+特性httpget/httppost
                    //2 AOP--反射调用方法,可以在前后插入逻辑
                    Console.WriteLine("********************不做类型转换调用********************");
                    Assembly assembly = Assembly.Load("Gs.DB.SqlServer");
                    Type     type     = assembly.GetType("Gs.DB.SqlServer.ReflectionTest");
                    object   oTest    = Activator.CreateInstance(type);

                    foreach (var method in type.GetMethods())
                    {
                        //获取类中的方法名
                        Console.WriteLine("方法名:" + method.Name);
                        foreach (var parameter in method.GetParameters())
                        {
                            //获取方法中的参数
                            Console.WriteLine(method.Name + "方法中的参数:" + parameter.Name + "===" + parameter.ParameterType);
                        }
                    }
                    {
                        ReflectionTest reflection = new ReflectionTest();
                        Console.WriteLine("普通调用");
                        reflection.Show1();
                    }
                    {
                        MethodInfo method = type.GetMethod("Show1");
                        Console.WriteLine("反射调用");
                        method.Invoke(oTest, null);
                    }
                    {
                        MethodInfo method = type.GetMethod("Show2");
                        Console.WriteLine("反射调用有参方法");
                        method.Invoke(oTest, new object[] { 123 });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { });
                        Console.WriteLine("反射调用重载无参方法Show3");
                        method.Invoke(oTest, null);
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(int) });
                        method.Invoke(oTest, new object[] { 1700 });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(string) });
                        method.Invoke(oTest, new object[] { "2020年2月23日17:02:00" });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(int), typeof(string) });
                        method.Invoke(oTest, new object[] { 1702, "2020年2月23日17:02:38" });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(string), typeof(int) });
                        method.Invoke(oTest, new object[] { "2020年2月23日17:04:02", 1704 });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show5");
                        method.Invoke(oTest, new object[] { "2020年2月23日17:04:32" });
                    }
                }
                #endregion 调用私有方法
                {
                    //调用私有方法
                    Console.WriteLine("&&&&&&&&&&&&&&&&&&&&私有方法&&&&&&&&&&&&&&&&&&&");
                    Assembly assembly = Assembly.Load("Gs.DB.SqlServer");
                    Type     type     = assembly.GetType("Gs.DB.SqlServer.ReflectionTest");
                    object   oTest    = Activator.CreateInstance(type);
                    var      method   = type.GetMethod("Show4", BindingFlags.Instance | BindingFlags.NonPublic);
                    //var method = type.GetMethod("Show4");
                    method.Invoke(oTest, new object[] { "2020年2月23日17:13:08" });
                }
                #region
                {
                    Console.WriteLine("********************调用泛型方法********************");
                    Assembly assembly = Assembly.Load("Gs.DB.SqlServer");
                    Type     type     = assembly.GetType("Gs.DB.SqlServer.GenericMethod");
                    object   oGeneric = Activator.CreateInstance(type);
                    foreach (var item in type.GetMethods())
                    {
                        //获取类中的方法
                        Console.WriteLine("类中的方法:" + item.Name);
                    }
                    MethodInfo method    = type.GetMethod("Show"); //获取方法
                    var        methodNew = method.MakeGenericMethod(new Type[] { typeof(int), typeof(string), typeof(DateTime) });
                    object     oReturn   = methodNew.Invoke(oGeneric, new object[] { 1920, "2020年2月23日19:20:25", DateTime.Now });
                }
                #endregion
                {
                    Console.WriteLine("********************调用泛型类中的泛型方法********************");
                    Assembly   assembly = Assembly.Load("Gs.DB.SqlServer");
                    Type       type     = assembly.GetType("Gs.DB.SqlServer.GenericDouble`1").MakeGenericType(typeof(int));
                    object     oObject  = Activator.CreateInstance(type);
                    MethodInfo method   = type.GetMethod("Show").MakeGenericMethod(typeof(string), typeof(DateTime));
                    method.Invoke(oObject, new object[] { 1927, "2020年2月23日19:42:22", DateTime.Now });
                }
                #region
                {
                    Console.WriteLine("*****************Common*******************");
                    People people = new People();
                    people.Id          = 001;
                    people.Name        = "孙悟空";
                    people.Description = "我是齐天大圣";
                    Console.WriteLine($"people.Id={people.Id}");
                    Console.WriteLine($"people.Name={people.Name}");
                    Console.WriteLine($"people.Description={people.Description}");
                }
                #endregion 反射赋值
                {
                    //1 get 反射展示是有意义的--反射遍历,可以不用改代码
                    //2 set 感觉好像没啥用
                    Console.WriteLine("*****************反射赋值*******************");
                    Type   type    = typeof(People);
                    object oPeople = Activator.CreateInstance(type);
                    foreach (var prop in type.GetProperties())
                    {
                        Console.WriteLine("类:" + type.Name + ";属性:" + prop.Name + ";值:" + prop.GetValue(oPeople));
                        Console.WriteLine($"{type.Name}.{prop.Name}={prop.GetValue(oPeople)}");
                        if (prop.Name.Equals("Id"))
                        {
                            prop.SetValue(oPeople, 234);
                        }
                        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)}");
                    }
                }
                #region 动态查询数据库
                {
                    Console.WriteLine("******************动态查询数据库*********************");
                    SqlServerHelper helper  = new SqlServerHelper();
                    Company         company = helper.Find <Company>(1);
                    User            user    = helper.Find <User>(1);
                }
                #endregion 测试性能
                {
                    Console.WriteLine("*******************测试性能*******************");
                    Monitor.Show();
                }
                #region

                #endregion
            }
            catch (Exception e)
            {
                Console.WriteLine("错误信息:" + e.Message);
            }
            Console.WriteLine("运行完毕");
            Console.ReadLine();
        }
Exemplo n.º 2
0
        static void Main(string[] args)
        {
            try
            {
                #region Common
                {
                    Console.WriteLine("*************** Common *****************");
                    IDBHelper iDBHelper = new MySqlHelper();
                    iDBHelper.Query();
                }
                #endregion

                #region Reflection
                {
                    Console.WriteLine("************* Reflection ***************");
                    Assembly assembly1 = Assembly.Load("Reflection.DB.MySql"); // 1 动态加载 一个完整的 dll 名称不需要后缀(从 exe 所在的路径进行查找)
                    // Assembly assembly2 = Assembly.LoadFile(@"E:\GitHub\csharp\02Reflection\Reflection.DB.MySql\bin\Debug\netstandard2.0\Reflection.DB.MySql.dll"); // 必须要完整路径
                    // Assembly assembly3 = Assembly.LoadFrom("Reflection.DB.MySql.dll"); // 当前路径
                    // Assembly assembly4 = Assembly.LoadFrom(@"E:\GitHub\csharp\02Reflection\Reflection.DB.MySql\bin\Debug\netstandard2.0\Reflection.DB.MySql.dll"); //完整路径

                    foreach (var type in assembly1.GetTypes())
                    {
                        Console.WriteLine(type.Name);
                        foreach (var method in type.GetMethods())
                        {
                            Console.WriteLine(method.Name);
                        }
                    }
                }
                #endregion
                {
                    Assembly assembly = Assembly.Load("Reflection.DB.MySql");                // 1 动态加载
                    Type     type     = assembly.GetType("Reflection.DB.MySql.MySqlHelper"); // 2 获取类型 完整类型名称

                    object oDBHelper = Activator.CreateInstance(type);                       // 3 创建对象
                    // oDBHelper.Query(); // 无法直接调用方法,编译器不允许
                    // C# 是一种强类型语言,静态语言,编译时就确定好类型保证安全

                    dynamic dDBHelper = Activator.CreateInstance(type);
                    dDBHelper.Query();                            // dynamic 跳过编译器检查,运行时才检查

                    IDBHelper iDBHelper = oDBHelper as IDBHelper; // 4 类型转换 不报错,类型不对就返回 null
                    iDBHelper.Query();                            // 5 方法调用
                }

                {
                    Console.WriteLine("**** Reflection + Factory + Config ****");
                    IDBHelper iDBHelper = SimpleFactory.CreaterInstance();
                    iDBHelper.Query();
                    // 程序是可配置的,通过修改配置就可以自动切换
                    // 没有写死类型,而是通过配置文件执行,反射创建的
                    // 实现类必须是事先已有的,而且在目录下面

                    // 可扩展:完全不修改原有代码,只是增加新的实现、复制、修改配置,则可以支持新功能
                    // 反射的动态加载和动态创建对象,以及配置文件结合
                }

                {
                    Console.WriteLine("********* ctor + parameter **********");
                    Type type = Assembly.Load("Reflection.DB.SqlServer")
                                .GetType("Reflection.DB.SqlServer.ReflectionTest");
                    IDBHelper iDBHelper1 = Activator.CreateInstance(type) as IDBHelper;
                    IDBHelper iDBHelper2 = Activator.CreateInstance(type, new object[] { 123 }) as IDBHelper;
                    IDBHelper iDBHelper3 = Activator.CreateInstance(type, new object[] { "oTest" }) as IDBHelper;

                    foreach (ConstructorInfo ctor in type.GetConstructors())
                    {
                        Console.WriteLine(ctor.Name);
                        foreach (var parameter in ctor.GetParameters())
                        {
                            Console.WriteLine(parameter.ParameterType);
                        }
                    }
                }

                {
                    Console.WriteLine("************ Singleton *************");
                    Singleton singleton  = Singleton.GetInstance();
                    Singleton singleton1 = Singleton.GetInstance();
                    Console.WriteLine(ReferenceEquals(singleton, singleton1));

                    Type type = Assembly.Load("Reflection.DB.SqlServer")
                                .GetType("Reflection.DB.SqlServer.Singleton");
                    //Singleton singletonA = Activator.CreateInstance(type) as Singleton; // error: 无法实例化单例

                    // 反射破坏单例 —— 就是反射调用私有构造函数
                    Singleton singletonA = Activator.CreateInstance(type, true) as Singleton;
                    Singleton singletonB = Activator.CreateInstance(type, true) as Singleton;
                    Console.WriteLine(ReferenceEquals(singletonA, singletonB));
                }

                {
                    Console.WriteLine("********** GenericClass ***********");
                    Type type = Assembly.Load("Reflection.DB.SqlServer")
                                .GetType("Reflection.DB.SqlServer.GenericClass`3");
                    // object oGeneric = Activator.CreateInstance(type); // error: 泛型无法直接实例化
                    Type   typeMake = type.MakeGenericType(new Type[] { typeof(string), typeof(int), typeof(DateTime) });
                    object oGeneric = Activator.CreateInstance(typeMake);
                }

                #region 泛型方法
                {
                    Console.WriteLine("********** GenericMethod ***********");
                    Type type = Assembly.Load("Reflection.DB.SqlServer")
                                .GetType("Reflection.DB.SqlServer.GenericMethod");
                    object oGeneric = Activator.CreateInstance(type);
                    foreach (MethodInfo item in type.GetMethods())
                    {
                        Console.WriteLine(item.Name);
                    }
                    MethodInfo method    = type.GetMethod("Show");
                    MethodInfo methodNew = method.MakeGenericMethod(new Type[] { typeof(int), typeof(string), typeof(DateTime) });
                    methodNew.Invoke(oGeneric, new object[] { 123, "John", DateTime.Now });
                }
                {
                    Console.WriteLine("******* GenericClass&Method ********");
                    Type type = Assembly.Load("Reflection.DB.SqlServer")
                                .GetType("Reflection.DB.SqlServer.GenericDouble`1")
                                .MakeGenericType(typeof(int));
                    object     oObject = Activator.CreateInstance(type);
                    MethodInfo method  = type.GetMethod("Show").MakeGenericMethod(typeof(string), typeof(DateTime));
                    method.Invoke(oObject, new object[] { 123, "John", DateTime.Now });
                }
                #endregion

                {
                    // 反射创建对象后,知道方法名称,可以直接调用而不需做类型转换
                    // 反射创建了对象实例——知道方法的名称——反射调用方法
                    // dll 名称——类型名称——方法名称——我们就能调用方法
                    // MVC 依赖这种模式——调用 Action
                    // http://localhost:9099/home/index 通过路由解析——会调用 HomeController——Index方法
                    // 相当于浏览器输入时告诉了服务器类型的名称和方法的名称
                    // MVC 加载时会先扫描所有 dll —— 找到所有的控制器 —— 请求来时用Controller 来匹配
                    // 1 MVC的局限性:Action 重载时,反射是无法区分的,只能通过 HttpMethod + 特性 HttpGet/HttpPost 等
                    // 2 AOP 反射调用方法,可以在前后插入逻辑
                    Console.WriteLine("********** GenericMethod ***********");
                    Type type = Assembly.Load("Reflection.DB.SqlServer")
                                .GetType("Reflection.DB.SqlServer.ReflectionTest");
                    object oTest = Activator.CreateInstance(type);
                    // 直接调用 Show1 方法
                    foreach (var method in type.GetMethods())
                    {
                        Console.WriteLine(method.Name);
                        foreach (var parameter in method.GetParameters())
                        {
                            Console.WriteLine($"{parameter.Name} {parameter.ParameterType}");
                        }
                    }
                    {
                        MethodInfo method = type.GetMethod("Show1");
                        method.Invoke(oTest, null);
                    }
                    {
                        MethodInfo method = type.GetMethod("Show2");
                        method.Invoke(oTest, new object[] { 123 });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { });
                        method.Invoke(oTest, null);
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(int) });
                        method.Invoke(oTest, new object[] { 123 });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(string) });
                        method.Invoke(oTest, new object[] { "John" });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(int), typeof(string) });
                        method.Invoke(oTest, new object[] { 123, "John" });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(string), typeof(int) });
                        method.Invoke(oTest, new object[] { "John", 123 });
                    }
                    {
                        // 静态方法实例可要可不要
                        MethodInfo method = type.GetMethod("Show5");
                        method.Invoke(oTest, new object[] { "John" });
                        method.Invoke(null, new object[] { "John" });
                    }
                }

                #region 反射调用私有方法
                {
                    Console.WriteLine("********* 反射调用私有方法 *********");
                    Type type = Assembly.Load("Reflection.DB.SqlServer")
                                .GetType("Reflection.DB.SqlServer.ReflectionTest");
                    object oTest   = Activator.CreateInstance(type);
                    var    method  = type.GetMethod("Show4", BindingFlags.Instance | BindingFlags.NonPublic);
                    object oReturn = method.Invoke(oTest, new object[] { "John" });
                }
                #endregion

                #region
                {
                }
                #endregion
            }
            catch (Exception)
            {
                throw;
            }
        }