C#中的反射到底用在哪，通俗解释（unity）、反射的概念及用法-- C#知识点6

看了这么多资源，看了这么多例子，还是没看明白。
今天突然想通了，默认你先知道反射是这么用的，但是不明白反射到底用在什么场景，既然知道了对象，为啥不用对象直接开new，还要通过反射绕这么一大圈？因为，new对象是你知道这个对象是什么，你能访问到它的类，而反射是解决，你不能直接访问到的事情，例如，你在你的项目里访问一个未知dll文件，你可以通过反射，知道这个dll里面封装着哪些类，有哪些成员方法，有哪些成员变量，并且可以去用那些类创建对象，访问他们的方法。

例子1

反射可以用来开发程序插件一类的，比如浏览器支持插件吧，浏览器添加插件后，为什么可以执行插件里的代码，毕竟程序是浏览器在执行，我却跑通了插件的功能，这就用到了反射，我通过反射可以检测到插件中有哪些字段、有哪些方法、和其他的，例如，浏览器开发者跟插件开发者约定好，想执行插件的A功能我这边会调用funA()的方法，你们开发插件的时候必须规范好命名，这样才会通用，通常会写好一个接口给插件开发者让他们继承，就规范了，当然也有其他方法，
这样插件开发者只要继承浏览器的接口，浏览器就可以利用反射动态加载进来，然后实例化接口调用插件内的方法，就可以跑通插件中的代码了

例子2

有时候，比如我写了一个通用类，这个类中有方法作用是进行本地保存 Player类中需要保存 血量、蓝量、等级 Boss类需要保存 怒气值、精神值、成长度、关卡 那么我想通过通用保存类去保存这个player和boss，和以后其他未来可能还要添加的需要被保存的类
我写这个通用类的时候并不知道这些被保存的类中有哪些字段哪些方法以及这个类是什么类，这就需要反射，
在通用类中用Type接受传过来的类的类型 public object LoadData(Type type,string keyName)
那些需要保存的类调用这个通用类的方法，把自己类的类型当参数传进去，LoadData(Player,name) 通用类里面大概这样写
通用类里面大概这样写

  /// <summary>
    /// 读取数据
    /// </summary>
    /// <param name="type">想要读取的数据的类型</param>
    /// <param name="keyName">数据对象的唯一key，自己控制</param>
    /// <returns></returns>
    public object LoadData(Type type,string keyName)
    {
        //这里本可以用object当形参的，但是这样做的话，需要调用者传入一个new好的对象
        //用type就解决了上面的问题，直接传入这个类，然后在这内部去new一个对象
        
        //拿到type就可以得到这个类中有那些字段、方法、......
        //开始检索当前类中有哪些字段、方法、
        //开始遍历存储检测到的字段
       // return null;
    }

例子3

Unity中创建一个脚本AAA.cs
打开脚本，这时候类名应该也是AAA
写入
public int a = 1；
public string bbb = “111”；
private int c = 2；
然后将脚本拖动到一个gameObject上面
会发现unity为其生成了一些文本框

为什么你在脚本里写了public int age ，在unity里却会显示出一个age框实时显示？代码是开发者自己写的，每个人都不一样，unity为什么会知道你代码里写的什么并显示出来？
因为反射，你在写完脚本后，返回unity，发现unity在转圈，其实就可以理解为在将你的代码编译成程序集，unity通过脚本名字去在程序集中寻找这个类（有种情况就是脚本名如果不跟类名一样会报错！就是因为反射，程序在程序集中找不到脚本名一样的类），找到后会将公共字段遍历显示出来（反射找不到私有片段的），，这个过程就是反射的实例 ，然后你可以在面板这里去填写字段，运行的时候，就相当于我通过反射给程序集（也就是脚本）中的变量去赋值
像脚本前面加上[serialized]，就会给私有字段进行序列化，就可以进行反射，所以在面板中就会显示出来
公共字段前面加上[HideInInspector]就不会再面板显示，因为会在反射加载的时候检测，检测到这个字段就不显示了

结构体和类可以，字典加上也不可以

像xxx.UNITY 场景文件其实就是一个文件，unity内部机制读取这个文件，通过里面的字段信息去创建出一个个gameobject和上面的组件，这就是一反射，你可以手动改文件的配置，然后unity也会做出相应的变化

优点

a. 可以动态修改程序，降低了程序的耦合性，提高了程序的灵活性和拓展性
b. 允许程序动态创建和控制任何类，不需要提前硬编码目标类

缺点

a. 性能损耗：前面提到，Reflection通过访问和解析Metadata使程序可以访问、检测和修改自身状态或行为。也就是说，Reflection本质上是一种解释操作，在操作某个程序实体之前，程序需要花时间访问Metadata去弄清楚这个程序实体是什么。因此，Reflection的效率远低于直接代码
b. 模糊代码逻辑：因为Reflection允许程序在提前硬编码目标类的情况下动态创建和控制类，所以在源代码中不能直接看到程序的逻辑，导致使用了Reflection的代码比相应的直接代码更难理解和维护

上面简单的讲了unity的例子1.
反射在unity中的例子2：
创建一个gameObject，可以看到，其上面的transform，这个其实就是一个新的类，内部有position、scale、rorate、等等公开变量，（这就是unity通过反射，进行序列化、反序列化机制将可以显示的东西显示出来），你可以直接改动，就相当于改动了内部变量，

反射在C#中的用法

一个运行的程序查看本身或者其它程序的元数据的行为就叫做反射

using System;
using System.Reflection;
using System.Threading;

namespace Lesson20_反射
{
    #region 知识点回顾
    //编译器是一种翻译程序
    //它用于将源语言程序翻译为目标语言程序

    //源语言程序：某种程序设计语言写成的,比如C#、C、C++、Java等语言写的程序
    //目标语言程序:二进制数表示的伪机器代码写的程序
    #endregion

    #region 知识点一 什么是程序集
    //程序集是经由编译器编译得到的，供进一步编译执行的那个中间产物
    //在WINDOWS系统中，它一般表现为后缀为·dll（库文件）或者是·exe（可执行文件）的格式

    //说人话：
    //程序集就是我们写的一个代码集合，我们现在写的所有代码
    //最终都会被编译器翻译为一个程序集供别人使用
    //比如一个代码库文件（dll）或者一个可执行文件(exe)
    #endregion

    #region 知识点二 元数据
    //元数据就是用来描述数据的数据
    //这个概念不仅仅用于程序上，在别的领域也有元数据

    //说人话：
    //程序中的类，类中的函数、变量等等信息就是 程序的 元数据
    //有关程序以及类型的数据被称为 元数据，它们保存在程序集中
    #endregion

    #region 知识点三 反射的概念
    //程序正在运行时，可以查看其它程序集或者自身的元数据。
    //一个运行的程序查看本身或者其它程序的元数据的行为就叫做反射

    //说人话：
    //在程序运行时，通过反射可以得到其它程序集或者自己程序集代码的各种信息
    //类，函数，变量，对象等等，实例化它们，执行它们，操作它们
    #endregion

    #region 知识点四 反射的作用
    //因为反射可以在程序编译后获得信息，所以它提高了程序的拓展性和灵活性
    //1.程序运行时得到所有元数据，包括元数据的特性
    //2.程序运行时，实例化对象，操作对象
    //3.程序运行时创建新对象，用这些对象执行任务
    #endregion

    class Test
    {
        private int i = 1;
        public int j = 0;
        public string str = "123";
        public Test()
        {

        }

        public Test(int i)
        {
            this.i = i;
        }

        public Test( int i, string str ):this(i)
        {
            this.str = str;

        }

        public void Speak()
        {
            Console.WriteLine(i);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("反射");
            #region 知识点五 语法相关

            #region Type
            //Type（类的信息类）
            //它是反射功能的基础！
            //它是访问元数据的主要方式。 
            //使用 Type 的成员获取有关类型声明的信息
            //有关类型的成员（如构造函数、方法、字段、属性和类的事件）

            #region 获取Type
            //1.万物之父object中的 GetType()可以获取对象的Type
            int a = 42;
            Type type = a.GetType();
            Console.WriteLine(type);
            //2.通过typeof关键字 传入类名 也可以得到对象的Type
            Type type2 = typeof(int);
            Console.WriteLine(type2);
            //3.通过类的名字 也可以获取类型
            //  注意 类名必须包含命名空间 不然找不到,System就是Int32的命名空间
            Type type3 = Type.GetType("System.Int32");
            Console.WriteLine(type3);

            #endregion

            #region 得到类的程序集信息
            //可以通过Type可以得到类型所在程序集信息，会输出所在的程序集，版本
            Console.WriteLine(type.Assembly);
            Console.WriteLine(type2.Assembly);
            Console.WriteLine(type3.Assembly);
            #endregion





            #region 获取类中的所有公共成员
            //首先得到Type
            Type t = typeof(Test);
            //然后得到所有公共成员
            //需要引用命名空间 using System.Reflection;
            MemberInfo[] infos = t.GetMembers();
            for (int i = 0; i < infos.Length; i++)
            {
                Console.WriteLine(infos[i]);
            }
            #endregion

            #region 获取类的公共构造函数并调用
            //1.获取所有构造函数
            ConstructorInfo[] ctors = t.GetConstructors();
            for (int i = 0; i < ctors.Length; i++)
            {
                Console.WriteLine(ctors[i]);
            }

            //2.获取其中一个构造函数 并执行
            //得构造函数传入 Type数组 数组中内容按顺序是参数类型
            //执行构造函数传入  object数组 表示按顺序传入的参数
            //  2-1得到无参构造
            ConstructorInfo info = t.GetConstructor(new Type[0]);
            //执行无参构造 无参构造 没有参数 传null
            Test obj = info.Invoke(null) as Test;
            Console.WriteLine(obj.j);

            //  2-2得到有参构造
            ConstructorInfo info2 = t.GetConstructor(new Type[] { typeof(int) });
            obj = info2.Invoke(new object[] { 2 }) as Test;
            Console.WriteLine(obj.str);

            ConstructorInfo info3 = t.GetConstructor(new Type[] { typeof(int), typeof(string) });
            obj = info3.Invoke(new object[] { 4, "444444" }) as Test;
            Console.WriteLine(obj.str);
            #endregion

            #region 获取类的公共成员变量
            //1.得到所有成员变量
            FieldInfo[] fieldInfos = t.GetFields();
            for (int i = 0; i < fieldInfos.Length; i++)
            {
                Console.WriteLine(fieldInfos[i]);
            }
            //2.得到指定名称的公共成员变量，这里只是获取到类对象，而不是值
            FieldInfo infoJ = t.GetField("j");
            Console.WriteLine(infoJ);

            //3.通过反射获取和设置对象的值
            Test test = new Test();
            test.j = 99;
            test.str = "2222";
            //  3-1通过反射 获取对象的某个变量的值
            Console.WriteLine(infoJ.GetValue(test));
            //  3-2通过反射 设置指定对象的某个变量的值，就是给test对象的j，设置100，
            infoJ.SetValue(test, 100);
            Console.WriteLine(infoJ.GetValue(test));
            #endregion

            #region 获取类的公共成员方法
            //通过Type类中的 GetMethod方法 得到类中的方法
            //MethodInfo 是方法的反射信息
            Type strType = typeof(string);
            MethodInfo[] methods = strType.GetMethods();//获取String类中的所有的公共方法
            for (int i = 0; i < methods.Length; i++)
            {
                Console.WriteLine(methods[i]);
            }
            //1.如果存在方法重载 用Type数组表示参数类型
            MethodInfo subStr = strType.GetMethod("Substring",
                new Type[] { typeof(int), typeof(int) });
            //2.调用该方法
            //注意：如果是静态方法 Invoke中的第一个参数传null即可
            string str = "Hello,World!";
            //第一个参数 相当于 是哪个对象要执行这个成员方法
            object result = subStr.Invoke(str, new object[] { 7, 5 });
            Console.WriteLine(result);

            #endregion

            #region 其它
            //Type;
            //得枚举
            //GetEnumName
            //GetEnumNames

            //得事件
            //GetEvent
            //GetEvents

            //得接口
            //GetInterface
            //GetInterfaces

            //得属性
            //GetProperty
            //GetPropertys
            //等等
            #endregion

            #endregion

            #region Assembly
            //程序集类
            //主要用来加载其它程序集，加载后
            //才能用Type来使用其它程序集中的信息
            //如果想要使用不是自己程序集中的内容 需要先加载程序集
            //比如 dll文件(库文件) 
            //简单的把库文件看成一种代码仓库，它提供给使用者一些可以直接拿来用的变量、函数或类

            //三种加载程序集的函数
            //一般用来加载在同一文件下的其它程序集
            //Assembly asembly2 = Assembly.Load("程序集名称");

            //一般用来加载不在同一文件下的其它程序集
            //Assembly asembly = Assembly.LoadFrom("包含程序集清单的文件的名称或路径");
            //Assembly asembly3 = Assembly.LoadFile("要加载的文件的完全限定路径");

            //1.先加载一个指定程序集
            Assembly asembly = Assembly.LoadFrom(@"C:\Users\MECHREVO\Desktop\CSharp进阶教学\Lesson18_练习题\bin\Debug\netcoreapp3.1\Lesson18_练习题");
            Type[] types = asembly.GetTypes();//得到所有的类
            for (int i = 0; i < types.Length; i++)
            {
                Console.WriteLine(types[i]);
            }
            //得到上面所有的类的名称后，在根据类的名称去创建对象
            //2.再加载程序集中的一个类对象 之后才能使用反射
            Type icon = asembly.GetType("Lesson18_练习题.Icon");
            MemberInfo[] members = icon.GetMembers();//获取所有的类的成员变量
            for (int i = 0; i < members.Length; i++)
            {
                Console.WriteLine(members[i]);
            }
            //通过反射 实例化一个 icon对象
            //首先得到枚举Type 来得到可以传入的参数
            //枚举也算个类，
            Type moveDir = asembly.GetType("Lesson18_练习题.E_MoveDir");
            FieldInfo right = moveDir.GetField("Right");//得到类对象
            //直接实例化对象
            object iconObj = Activator.CreateInstance(icon, 10, 5, right.GetValue(null));
            //得到对象中的方法 通过反射
            MethodInfo move = icon.GetMethod("Move");
            MethodInfo draw = icon.GetMethod("Draw");
            MethodInfo clear = icon.GetMethod("Clear");

            Console.Clear();
            while(true)
            {
                Thread.Sleep(1000);
                clear.Invoke(iconObj, null);
                move.Invoke(iconObj, null);
                draw.Invoke(iconObj, null);
            }
            

            //3.类库工程创建
            #endregion

            #region Activator
            //用于快速实例化对象的类
            //用于将Type对象快捷实例化为对象
            //先得到Type
            //然后 快速实例化一个对象
            Type testType = typeof(Test);
            //1.无参构造
            Test testObj = Activator.CreateInstance(testType) as Test;
            Console.WriteLine(testObj.str);
            //2.有参数构造
            testObj = Activator.CreateInstance(testType, 99) as Test;
            Console.WriteLine(testObj.j);

            testObj = Activator.CreateInstance(testType, 55, "111222") as Test;
            Console.WriteLine(testObj.j);
            #endregion

            #endregion
        }
    }

    //总结
    //反射
    //在程序运行时，通过反射可以得到其他程序集或者自己的程序集代码的各种信息
    //类、函数、变量、对象等等，实例化他们，执行他们，操作他们

    //关键类
    //Type
    //Assembly
    //Activator

    //对于我们的意义
    //在初中级阶段 基本不会使用反射
    //所以目前对于大家来说，了解反射可以做什么就行
    //很长时间内都不会用到反射相关知识点

    //为什么要学反射
    //为了之后学习Unity引擎的基本工作原理做铺垫
    //Unity引起的基本工作机制 就是建立在反射的基础上


}

MemberInfo是FieldInfo的区别

      FieldInfo[] fieldInfos = t.GetFields();
         表示为当前 Type 定义的所有公共字段的 FieldInfo 对象数组。
          MemberInfo[] infos = t.GetMembers();
表示当前 Type 的所有公共成员的 MemberInfo 对象数组。
这两个区别是什么？
MemberInfo是FieldInfo的父类，看下面，MemberInfo可以获取構造函數，屬性，方法，事件而不僅僅是字段
public class TestClass
{
    private int a = 1;//私有一律获取不到
    public int b
    {
        get { return 2; }
        set { value = 2; }
    }
    public int c = 3;
}

public static void TestMethod()
{
    TestClass test = new TestClass();
    PropertyInfo[] pro = test.GetType().GetProperties();
    FieldInfo[] fil = test.GetType().GetFields();
    MemberInfo[] men = test.GetType().GetMembers();

    foreach (var item in pro)//仅能获取到b属性（输出b=2）
    {
        Console.WriteLine("PropertyInfo: " + item.Name  +"=" + item.GetValue(test, null));
    }
    foreach (FieldInfo item in fil)//仅能获取到c字段（输出c=2）
    {
        Console.WriteLine("FieldInfo: " + item.Name + "=" + item.GetValue(test));
    }
    foreach (MemberInfo item in men)//仅能获取到成员元素据
    {
        Console.WriteLine("MemberInfo: "+ item.Name );
    }
}