1.反射

1.什么是程序集

程序集是经由百年一起编译得到的，供进一步编译执行的那个中间产物

在WINDOWS系统中，它一般表现为后缀.dll(库文件)或者是.exe(可执行文件)的格式

说人话：

程序集就是我们写的一个代码集合，我们现在写的所有代码

最终都会被编译器翻译为一个程序集供别人使用

比如一个代码库文件（dll）或者一个可执行文件（exe）

2.元数据

元数据就是用来描述数据的数据

这个概念不仅仅用于程序上，在别的领域也有元数据

说人话：

程序中的类，类中的函数、变量等等信息就是 程序的元数据

有关程序以及类型的数据被称为 元数据，它们保存在程序集中

3.反射的概念

程序在运行时，可以查看其他程序集或者自身的元数据

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

说人话：

在程序运行时。通过反射可以得到其它程序集或者自己程序集代码的各种信息

类，函数，变量，对象等等，实例化它们，执行它们，操作它们

4.反射的作用

因为反射可以在程序编译后获得信息，所以它提高了程序的拓展性和灵活性

1. 程序运行时得到所有元数据，包括元数据的特性
2. 程序运行时，实例化对象，操作对象
3. 程序运行时创建新对象，用这些对象执行任务

5.语法相关 

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

1.type 

2.Assembly

3.Activator

 6.反射关键类Type

Type（类的信息类）

它是反射功能的基础！

它是访问元数据的主要方式

使用 Type 的成员获取有关类型申明的信息

有关类型的成员（如构造函数，方法，字段，属性和类的事件）

1.获取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.通过类的名字 也可以获取类型

   注意 类名必须包含命名空间 不然找不到

            Type type3 = Type.GetType("System.Int32");
            Console.WriteLine(type3);

2.得到类的程序集信息

可以通过Type可以得到类型所在程序集信息

            Console.WriteLine(type.Assembly);
            Console.WriteLine(type2.Assembly);
            Console.WriteLine(type3.Assembly);

3.获取类中的所有公共成员

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

 4.获取类的公共构造函数并调用

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, "4444" }) as Test;

5.获取类的公共成员变量 

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通过反射 设置指定对象的某个变量的值
            infoj.SetValue(test, 100);
            Console.WriteLine(infoj.GetValue(test));

6.获取类的公共成员方法 

            //通过Type类中的 GetMethod方法 得到类中的方法
            //MethodInfo 是方法的反射信息
            Type strType = typeof(string);
            MethodInfo[] methods = strType.GetMethods();
            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);

7.其他 

            //Type
            //得枚举
            //GetEnumName
            //GetEnumNames
 
            //得事件
            //GetEvent
            //GetEvents
 
            //得接口
            //GetInterface
            //GetInterfaces
 
            //得属性
            //GetProperty
            //GetPropertys
            //等等

7.反射关键类Assembly

程序集类

主要用来加载其他程序集，加载后才能使用Type来使用其他程序集中的信息

如果想要使用不是自己程序集中的内容 需要先加载程序集

比如 dll文件（库文件）
简单的把库文件看成一种代码仓库，它提供给使用者一些可以直接拿来用的变量、函数或类

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

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

1.先加载一个指定程序集 

            Assembly assembly = Assembly.LoadFrom(@"D:\C#\CSharp进阶\lesson18-多线程\bin\Debug\netcoreapp3.1\lesson18-多线程");
            Type[] types = assembly.GetTypes();
            for (int i = 0; i < types.Length; i++)
            {
                Console.WriteLine(types[i]);
            }

 2.再加载程序集中的一个类对象 之后才能使用反射

            Type icon = assembly.GetType("lesson18-多线程.Icon");
            MemberInfo[] members = icon.GetMembers();
            for (int i = 0; i < members.Length; i++)
            {
                Console.WriteLine(members[i]);
            }
            //通过反射 实例化一个 icon对象
            //首先得到枚举Type 来得到可以传入的参数
            Type moveDir = assembly.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);
                draw.Invoke(iconObj, null);
                move.Invoke(iconObj, null);
            }

3.类库工程创建 

8.反射关键类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);

9.总结 

反射

在程序运行时，通过反射可以得到其他程序集或者自己的程序集代码的各种信息

类、函数、变量、对象等等，实例他们，执行他们，操作他们

关键类：Type、Assembly、Activator

对于我们的意义

在初中级阶段 基本不会使用反射

所有目前对于大家来说，了解反射可以做申明就行

很长时间都不会用到反射相关知识点

为什么要学反射

为了之后学习Unity引擎的基本工作原理做铺垫

Unity引擎的基本工作机制 就是建立在反射的基础上

2.特性

1.特性是什么

特性是一种允许我们向程序的程序集添加元数据的语言结构

它是用于保存程序结构信息的某种特殊类型的类

特性提供功能强大的方法以将申明信息与 C# 代码（类型、方法、属性等）相关联

特性与程序实体关联后，即可在运行时使用反射查询特性信息

特性的目的是告诉编译器把程序结构的某组元数据嵌入程序集中

它可以放置在几乎所有的申明中（类、变量、函数等等申明）

说人话：

特性本质是个类

我们可以利用特性类为元数据添加额外信息

比如一个类、成员变量、成员方法等等为他们添加更多的额外信息

之后可以通过反射来获取这些额外信息

2.自定义特性

    //继承特性基类 Attribute
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Field,AllowMultiple =true,Inherited =false)]
    class MyCustomAttribute : Attribute
    {
        //特性中的成员 一般根据需求来写
        public string info;
        public MyCustomAttribute(string info)
        {
            this.info = info;
        }
        public void TestFun()
        {
            Console.WriteLine("特性的方法");
        }
    }

3.特性的使用

基本语法

[特性名（参数列表）]

本质上 就是在调用特性类的构造函数

写在哪里？

类、函数、变量上一行，表示他们具有该特性信息

    [MyCustom("自己写的用于计算的类")]
    [MyCustom("自己写的用于计算的类")]
    class MyClass
    {
        [MyCustom("这是一个成员变量")]
        public int value;
 
        //[MyCustom("这是一个用于计算加法的函数")]
        //public void TestFun([MyCustom("函数参数")] int a)
        //{
 
        //}
        
        public void TestFun(int a)
        {
 
        }
 
    }

    class Program
    {
        [DllImport("Test.dll")]
        public static extern int Add(int a, int b);
 
        [Conditional("Fun")]
        static void Fun()
        {
            Console.WriteLine("Fun执行");
        }
 
        static void Main(string[] args)
        {
            Console.WriteLine("特性");
 
            #region 特性的使用
            MyClass mc = new MyClass();
            Type t = mc.GetType();
            //t = typeof(MyClass);
            //t = Type.GetType("lesson21-特性。MyClass");
 
            //判断是否使用了某个特性
            //参数一：代表特性的类型
            //参数二：代表是否搜索继承链（属性和事件忽略此参数）
            if (t.IsDefined(typeof(MyCustomAttribute), false))
            {
                Console.WriteLine("该类型应用了MyCustom特性");
            }
            object[]array=t.GetCustomAttributes(true);
            for (int i = 0; i < array.Length; i++)
            {
                if (array[i] is MyCustomAttribute)
                {
                    Console.WriteLine((array[i] as MyCustomAttribute).info);
                    (array[i] as MyCustomAttribute).TestFun();
                }
            }
 
            TestClass tc = new TestClass();
            //tc.OldSpeak("123");
            tc.Speak();
 
            tc.SpeakCaller("123123123");
 
            Fun();
            #endregion
        }
    }

 4.限制自定义特性的使用范围

    //通过为特性类 加特性 限制其使用范围
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = true, Inherited = true)]
    //参数一：AttributeTargets   特性能够用在哪些地方
    //参数二：AllowMultiple      是否允许多个特性实例用在同一个目标上
    //参数三：Inherited          特性是否能被派生类和重写成员继承  
    public class MyCustom2Attribute : Attribute
    {
        
    }

5.系统自带特性——过时特性

过时特性    Obsolete

用于提示用户 使用的方法等成员已经过时 建议使用新方法

一般加载函数前的特性

    class TestClass
    {
        //参数一：调用过时方法时 提示的内容
        //参数二：true-使用该方法时会报错 false-使用该方法时直接警告
        [Obsolete("OldSpeak方法已经过时了，请使用Speak方法",false)]
        public void OldSpeak(string str)
        {
            Console.WriteLine(str);
        }
        public void Speak()
        {
            Console.WriteLine("123");
        }
        public void SpeakCaller(string str, [CallerFilePath]string fileName = "",
            [CallerLineNumber]int line = 0, [CallerMemberName]string target = "")
        {
            Console.WriteLine(str);
            Console.WriteLine(fileName);
            Console.WriteLine(line);
            Console.WriteLine(target);
        }
    }

6.系统自带特性——调用者信息特性

哪个文件调用

CallerFilePath特性
哪一行调用
CallerLineNumber特性
哪个函数调用
CallerMemberName特性
 
需要引用命名空间 using System.Runtime.CompilerServices;
一般作为函数参数的特性

7.系统自带特性——条件编译特性

条件编译特性
Conditional
它会和预处理指令 #define 配合使用
 
需要引用命名空间 using System.Diagnostics;
主要可以用在一些调试代码上
有时想执行有时不想执行的代码
#define 函数名
函数前面加 [Conditional("函数名")]

8.系统自带特性——外部Dll包函数特性 

 DllImport
 
用来标记非.Net（C#）的函数，表明该函数在一个外部的DLL中定义
一般用来调用C或者C++的Dll包写好的方法
需要引用命名空间 using System.Runtime.InteropServices;
 
函数前面加 [DllImport("函数名")]

9.总结

特性是用于 为元数据再添加更多的额外信息（变量、方法等等）

我们可以通过反射获取这些额外的数据 来进行一些特殊的处理

自定义特性——继承Attribute

系统自带特性：过时特性

为什么要学特性

Unity引擎中很多地方都用到了特性来进行一些特殊处理