反 射

已于 2023-01-16 18:15:46 修改
阅读量432 收藏
点赞数
分类专栏： C# 文章标签： c# java
于 2023-01-16 18:12:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43590078/article/details/128706454
版权

反射

二、反射

1.dll-IL-metadata 反射

|C#------->编译器编译----->DLL/EXE------->ClR/JIT–>机器码
|-------------------------------- ↙--------↘--------↗--------------------
|-----------------------------↙---------------↘↗-------------------------
|------------------------metadta--------------IL---------------------------
metadta:元数据，清单数据，声明的东西在里面，描述IL里面有啥
IL:中间语言，面向对象语言

2.反射加载dll，读取modle，类，方法，特性

      //普通类型
      IDBHelper dBHelper = new MySqlHelper();
      dBHelper.Query();
      
      //反射
      Assembly assembly = Assembly.Load("Ruan.DB.Mysql");//dll名称，从当前目录加载  1.加载DLL
      //Assembly.LoadFile();//完成路径 加载不会错，但是如果没有依赖项，使用的时候就会出错
      //Assembly assembly1 = Assembly.LoadFrom("Ruan.DB.Mysql.dll");//带后缀或者完整路径
      foreach (var item in assembly.GetTypes())
      {
          Console.WriteLine(item.FullName);
          //Type type = assembly.GetType("Ruan.DB.Mysql.MysqlHelper");//完整的类型名称
          Type type = assembly.GetType(item.FullName);  //2.获取类型信息
          object objHelper = Activator.CreateInstance(type);//3.创建对象
          IDBHelper idBHelper = (IDBHelper)objHelper;//4.类型转变
          idBHelper.Query();
      }    

      //带参数构造
      Assembly assembly = Assembly.Load("Ruan.DB.SqlServer");
      Type type = assembly.GetType("Ruan.DB.SqlServer.ReflectionTest");
      Object activator = Activator.CreateInstance(type);
      Object activator1 = Activator.CreateInstance(type,new Object[] {134});//与要调用构造函数的参数数量、顺序和类型匹配的参数数组
      Object activator2 = Activator.CreateInstance(type, new Object[] { "123" });

类

    public class SqlServerHelper : IDBHelper
    {
        public SqlServerHelper()
        {
           // Console.WriteLine("{0}被构造", this.GetType().Name);
        }
        public void Query()
        {
           // Console.WriteLine("{0}.Query", this.GetType().Name);
        }
    }

3.反射创建对象，反射+简单工厂+配置文件

配置文件

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
    </startup>
  <appSettings>
    <add key="IDBHelperConfig" value="Ruan.DB.Mysql.MySqlHelper"/>  //设置config,将字段保存到Config里面
  </appSettings>
</configuration>

反射+简单工厂

    //建立工厂
    public class Factory
    {
         //读Config   静态字段，一开始就已经初始化，在这里报错，进不去这个方法，就会抛出异常
         //private static string IDBHelperConfig = ConfigurationManager.AppSettings["IDBHelperConfig"];
         // private static string DllName = IDBHelperConfig.; 
         // private static string TypeName = IDBHelperConfig; 
         //工厂创建对象
        public static IDBHelper GreateHelper() 
        {
            string IDBHelperConfig = ConfigurationManager.AppSettings["IDBHelperConfig"];
            string DllName = IDBHelperConfig.Substring(0, IDBHelperConfig.LastIndexOf('.'));  
            string TypeName = IDBHelperConfig; 
            Assembly assembly = Assembly.Load(DllName);//1.加载DLL
            Type type = assembly.GetType(TypeName);  //2.获取类型信息
            object objHelper = Activator.CreateInstance(type);//3.创建对象
            IDBHelper idBHelper = (IDBHelper)objHelper;//4.类型转变
            return idBHelper;
        }
    }

//Reflection+factory+Config
//程序的可配置 可扩展
IDBHelper dBHelper = Factory.GreateHelper();
dBHelper.Query();

4.破坏单例

破坏单例

//Reflection
//单例只可以实例化一次，构造函数私有化，提供一个静态方法，通过静态方法获取实例，静态的实例
Singleton singleton = Singleton.GeInstance();
Singleton singleton1 = Singleton.GeInstance();
Singleton singleton2 = Singleton.GeInstance();//调用的都是一个

//反射可以破坏单例，其实也就是可以调用私有的构造函数
Assembly assembly = Assembly.Load("Ruan.DB.SqlServer");
Type type = assembly.GetType("Ruan.DB.SqlServer.Singleton");
Singleton singleton3 = (Singleton)Activator.CreateInstance(type,true);//这里多个true
Singleton singleton4 = (Singleton)Activator.CreateInstance(type,true);
Singleton singleton5 = (Singleton)Activator.CreateInstance(type,true);

创建单例

namespace Ruan.DB.SqlServer
{
    public sealed class Singleton
    {
        private static Singleton singleton = null;  //静态实例

        private Singleton()    //构造函数私有化后，外界没法构造
        {
            Console.WriteLine("Singleton被构造");
        }
        static Singleton()    //静态构造
        {
            singleton = new Singleton();
        }

        public static Singleton GeInstance() //通过静态方法，来调用实例
        {
            return singleton;
        }
    }
}

5.泛型反射

//泛型
Assembly assembly = Assembly.Load("Ruan.DB.SqlServer");
Type type = assembly.GetType("Ruan.DB.SqlServer.GenericClass`3"); //`3占位符表示几个
//object oGeneric = Activator.CreateInstance(type);//要指定
Type newType = type.MakeGenericType(new Type[] { typeof(int), typeof(string), typeof(DateTime) });//指定type
object oGeneric = Activator.CreateInstance(newType);

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

6.反射调用实例方法，静态方法，重载方法 选修：调用私有方法，调用泛型方法

//Reflection+Method
//举例：MVC URL地址一类名称+方法名称
Assembly assembly = Assembly.Load("Ruan.DB.SqlServer");
Type type = assembly.GetType("Ruan.DB.SqlServer.ReflectionTest");
object oReflection = Activator.CreateInstance(type);
MethodInfo methodInfo = type.GetMethod("Show1");
methodInfo.Invoke(oReflection, null);
MethodInfo methodInfo1 = type.GetMethod("Show2");
methodInfo1.Invoke(oReflection, new object[] {123});
MethodInfo methodInfo2 = type.GetMethod("Show3", new Type[] { });//重载方法，重载的可以传递一个参数列表，Type[]{}类型的数组
methodInfo2.Invoke(oReflection, new object[] { });
MethodInfo methodInfo2_1 = type.GetMethod("Show3", new Type[] {typeof(int)});
methodInfo2_1.Invoke(oReflection, new object[] {123});
MethodInfo methodInfo3 = type.GetMethod("Show4",BindingFlags.Instance|BindingFlags.NonPublic);//调用私有的方法
methodInfo3.Invoke(oReflection, new object[] {"私有方法"});
MethodInfo methodInfo4 = type.GetMethod("Show5");
methodInfo4.Invoke(null,new object[] {"静态方法"});//静态方法不需要实例化，可以给个实例，也可以是null

调用泛型方法

//Reflection+Method+泛型
Assembly assembly = Assembly.Load("Ruan.DB.SqlServer");
Type type = assembly.GetType("Ruan.DB.SqlServer.GenericDouble`1"); 
Type newType = type.MakeGenericType(new Type[] { typeof(string)});
object oGeneric = Activator.CreateInstance(newType);
MethodInfo method = newType.GetMethod("show");
MethodInfo newMethod = method.MakeGenericMethod(new Type[] { typeof(string),typeof(int),typeof(DateTime)});
                    newMethod.Invoke(oGeneric, new object[] {"泛型方法",123,DateTime.Now});
```csharp
在这里插入代码片

 public class ReflectionTest
    {
        public ReflectionTest() 
        {
            Console.WriteLine("这里是{0}无参数构造函数", this.GetType());
        }
        public ReflectionTest(string name) 
        {
            Console.WriteLine("这里是{0}有参构造函数", this.GetType());
        }
        public ReflectionTest(int id)
        {
            Console.WriteLine("这里是{0}有参构造函数", this.GetType());
        }

        public void Show1() 
        {
            Console.WriteLine("这里是{0}的Show1", this.GetType());
        }
        public void Show2(int id)
        {
            Console.WriteLine("这里是{0}的Show2", this.GetType());
        }
        public void Show3() 
        {
            Console.WriteLine("这里是{0}的Show3", this.GetType());
        }
        public void Show3(int id)
        {
            Console.WriteLine("这里是{0}的Show3_1", this.GetType());
        }
        public void Show3(string name)
        {
            Console.WriteLine("这里是{0}的Show3_2", this.GetType());
        }
        public void Show3(string name,int id)
        {
            Console.WriteLine("这里是{0}的Show3_3", this.GetType());
        }
        private void Show4(string name)
        {
            Console.WriteLine("这里是{0}的Show4", this.GetType());
        }
        public static void Show5(string name) 
        {
            Console.WriteLine("这里是{0}的Show4", typeof(ReflectionTest));
        }

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

7.反射字段和属性，分别获取值和设置值

//Reflection+Property/Field
//ORM
//普通
People people = new People();
people.Id = 123;
people.Name = "LIN";
people.Description = "description";

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

//反射
Type type = typeof(People);
object oPeople = Activator.CreateInstance(type);
foreach (var prop in type.GetProperties()) //属性
{
     Console.WriteLine(type.Name);
     Console.WriteLine(prop.Name);
     Console.WriteLine(prop.GetValue(oPeople));
     if (prop.Name.Equals("Id"))
        prop.SetValue(oPeople, 111);
     else if (prop.Name.Equals("Name"))
        prop.SetValue(oPeople, "LIU");
     Console.WriteLine($"{type.Name},{prop.Name},{prop.GetValue(oPeople)}");
}
foreach (var field in type.GetFields())
{
       Console.WriteLine(type.Name);
       Console.WriteLine(field.Name);
       Console.WriteLine(field.GetValue(oPeople));
       if (field.Name.Equals("Description"))
          field.SetValue(oPeople, "de");
       Console.WriteLine($"{type.Name},{field.Name},{field.GetValue(oPeople)}");
}

例子：typeDTO复制typePeople

 //复制类 遍历属性 
People people1 = new People();  //DTO模型基本上一样，不一样的化要建立一个特性。
people1.Id = 123;
people1.Name = "LIN";
people1.Description = "description";

PeopleDTO peopleDTO = new PeopleDTO()
{
     Id = people1.Id,
     Name = people1.Name,
     Description=people1.Description,
};

Type typePeople = typeof(People);
Type typeDTO = typeof(PeopleDTO);
Object type = Activator.CreateInstance(typeDTO);

foreach (var prop in typeDTO.GetProperties())
{
       //if (prop.Name.Equals("Id"))
       //{
       //  //  Object value = typePeople.GetProperty("Id").GetValue(people1); 
       //    Object value = typePeople.GetProperty(prop.Name).GetValue(people1);
       //    prop.SetValue(peopleDTO, value);
       //}
       //else if (prop.Name.Equals("Name"))
       //{
       //   // Object value = typePeople.GetProperty("Name").GetValue(people1); 
       //    Object value = typePeople.GetProperty("prop.Name").GetValue(people1);
       //    prop.SetValue(peopleDTO, value);
       //}
       Object value = typePeople.GetProperty(prop.Name).GetValue(people1);
       prop.SetValue(type, value);//名字一样时
}
foreach (var field in typeDTO.GetFields()) 
{
       Object value = typePeople.GetField(field.Name).GetValue(people1);
       field.SetValue(type,value);
}

8.反射的好处和局限

反射：System.Reflection .Net框架提供的帮助类库，可以读取并且使用metadata
反射优点：动态
反射缺点：
1.复杂，
2.避开了编译器检查
MethodInfo methodInfo = type.GetMethod(“Ssss”);没有这个类
3.性能不好
CommonTime=24,ReflectionTime=4034
ReflectionOneTime=46//空间换时间，声明一次，多次使用基本不影响
MVC第一次访问很慢 后面快
EF第一次访问很慢 后面快

//性能对比
Monitor.Show();//CommonTime=44,ReflectionTime=4331

namespace MyReflection
{
    public class Monitor
    {
        public static void Show() 
        {
            long commonTime = 0;
            long reflectionTime = 0;
            long reflectionOneTime = 0;//声明一次多次使用
            {
                Stopwatch stopwatch = new Stopwatch();
                stopwatch.Start();
                for (int i = 0; i < 1000000; i++) 
                {
                    IDBHelper dBHelper = new SqlServerHelper();
                    dBHelper.Query();
                }
                stopwatch.Stop();
                commonTime = stopwatch.ElapsedMilliseconds;
            }
            {
                Stopwatch stopwatch = new Stopwatch();
                stopwatch.Start();
                for (int i = 0; i < 1000000; i++) 
                {
                    Assembly assembly = Assembly.Load("Ruan.DB.SqlServer");
                    Type type = assembly.GetType("Ruan.DB.SqlServer.SqlServerHelper");
                    Object objHelper= Activator.CreateInstance(type);
                    IDBHelper dBHelper = (IDBHelper)objHelper;
                    dBHelper.Query();
                }
                stopwatch.Stop();
                reflectionTime = stopwatch.ElapsedMilliseconds;
            }
            {
                Stopwatch stopwatch = new Stopwatch();
                stopwatch.Start();
                Assembly assembly = Assembly.Load("Ruan.DB.SqlServer");
                Type type = assembly.GetType("Ruan.DB.SqlServer.SqlServerHelper");
                for (int i = 0; i < 1000000; i++)
                {
                    Object objHelper = Activator.CreateInstance(type);
                    IDBHelper dBHelper = (IDBHelper)objHelper;
                    dBHelper.Query();
                }
                stopwatch.Stop();
                reflectionOneTime = stopwatch.ElapsedMilliseconds;
            }
            Console.WriteLine($"CommonTime={commonTime},ReflectionTime={reflectionTime},ReflectionTime={reflectionOneTime}");
        }
       
    }
}

转到目录↩

一个勤勤恳恳的张大炮
关注
专栏目录
C#通过反射动态加载dll，读取module、类、方法、特性，并通过反射+简单工厂+配置文件 实现ioc
踏雪寻梅
04-06 5893
调用类：class Program { static void Main(string[] args) { SafeInvoke(() =&gt; {//通过委托实现通用的异常处理 #region 通过反射创建对象 { //1 动态加载 默认加载当前路径的dll文...
反射
u014321744的专栏
04-13 450
　　------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ---------- 反射：动态编译的过程。提供了在程序运行过...
机器码、序列号、认证码、注册码的生成算法（一）
宁静致远的博客
03-16 7594
机器码、序列号、认证码、注册码的生成算法（一）第一种、设备动态密码第二种、普通的软件注册码第三种、通过文件去注册 原文链接：https://blog.csdn.net/lweiyue/article/details/90902031 虽然标题列出了很多种“码”，但其实有些是一个意思，只是叫法不一样而已。我所介绍的算法也不是说绝对严谨、不能破解的，它们只是适用于某些场合而已。举个例子，我现在想设计一个长度是24个字符的注册码，但如果你用比较安全的RSA算法来做的话，可能你要用到1024个字节，转成Base6
Java核心技术----反 射
程序研博客
11-09 8161
一、Class类与Java反射 1、访问构造方法 每个Constructor对象代表一个构造方法，利用Constructor对象可以操纵相应的构造方法。 getConstructors() getConstructor(Class<?>... parameterTypes) getDeclaredConstructors() getDeclaredConstructor(Class<?>... parameterTypes) 2、访问成员变量 每个Field对象...
C#高级编程－－反 射！
03-21
【C#高级编程－－反射】反射是C#中一种强大的动态类型操作机制，它允许在程序运行时检查和操作程序元素，如类型、方法、属性等。通过反射，开发者可以实现诸如以下功能： 1. **枚举类型的成员**：在运行时获取类的...
反 射 应 用.rar
07-02
Java的泛型在编译后会被擦除，反射可以帮助我们获取泛型类型信息，这对于实现类型安全的代码容器或者序列化/反序列化等操作很有帮助。 6. **注解处理** 反射可以用来读取和处理类、方法、字段上的注解，这对于...
射流反推力.exe
12-09
射流反推力.exe
影像的辐射处理方法
07-18
通过对校正前后植被、水体和裸岩的光谱特征与标准库曲线对比，结果显示，校正后的影像能够更准确地反演出地物的真实反射率，同时也加快了数据处理速度，为后续的地物成分估算提供了可靠的基础。 在数据预处理阶段，...
辐射对FPGA应用的影响及解决方案
10-20
- 工艺选择：采用非易失性FPGA，如Flash FPGA和反熔丝FPGA，它们具有更好的抗辐射能力。 - Flash FPGA：高能粒子无法引起浮栅电荷变化，故具有配置翻转免疫力。 - 反熔丝FPGA：永久编程的金属链接不会因辐射改变，...
C# 调用Webservice接口接受数据测试
qq_59062726的博客
07-30 213
调用Webservice接口接受天气数据
通过进程协作显示图像-C#
weixin_45114627的博客
07-30 517
如果一个软件比较复杂或者某些情况下需要拆解，可以考试将软件分解成两个或多个进程，但常规的消息传递又不能完全够用，使用消息+共享内存，实现图像传递，当然性能这个方面我并没有测试，仅是一种解决思路吧。
C# 浅谈异步编程 Thread、ThreadPool
a876106354的博客
07-30 539
从 .NET Framework 4 开始，使用多线程的推荐方法是使用任务并行库 (TPL) 和并行 LINQ (PLINQ)。任务并行库（TPL）说的是 System.Threading 和 System.Threading.Tasks 空间中的一组公共类型和 API。较为常见的就是Thread、ThreadPool、Task等。
Xlua原理分析 四
最新发布
qq_25978293的博客
07-30 649
Xlua hotfix原理
C#:枚举及位标志周边知识详解(小白入门)
2301_76886465的博客
07-30 684
详解C#的枚举类型及位标志
【C#】 使用GDI+获取两个多边形区域相交、非相交区域
wangnaisheng的专栏
07-30 212
【C#】 使用GDI+获取两个多边形区域相交、非相交区域
【C#】ThreadPool的使用
wangnaisheng的专栏
07-30 295
【C#】ThreadPool的使用
C# 多线程Paralle使用
qq_44967213的博客
07-26 612
在C#中，Parallel类是 System.Threading.Tasks 命名空间下的一个静态类，它提供了并行执行循环和操作的简便方法。通过使用Parallel类，可以简化多线程编程，提高应用程序执行并行任务的能力。Parallel类主要用于并行执行for和foreach循环。Parallel类包含几个静态方法，如等，这些方法能够自动将迭代分配给多个线程，以实现并行执行。
C# —— 析构函数
一个新人博客，愿多多支持。
07-25 462
构造函数创建对象 对属性进行初始化的作用析构函数: 当一个对象被释放的时候执行。
未添加水分 的原煤样本的平均光谱反射曲线整体较高，随着水分含量的增加，煤炭的整体光谱反 射曲线呈下移的趋势，且在一定范围内，初始添加的水量越多，则曲线下移的幅度越 大，继续加大水量，曲线下降的趋势减小，曲线之间较为接近。
08-12
### 回答1： 这是因为水分的加入会影响煤炭的表面特性和组成结构，导致光的吸收和散射发生变化，从而改变了煤的光谱反射特性。当未添加水分时，煤的表面较为粗糙，能够更有效地反射光线，因此整体光谱反射曲线较高。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值