C#进阶07——反射和特性

1.反射

1.什么是程序集

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

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

说人话：

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

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

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

2.元数据

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

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

说人话：

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

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

3.反射的概念

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

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

说人话：

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

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

4.反射的作用

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

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

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引擎中很多地方都用到了特性来进行一些特殊处理

相关阅读:
【高级篇 / ZTNA】(7.0) ❀ 02. 测试版许可注册冲突的解决办法 ❀ FortiGate 防火墙
 2022-05-05 mybatis-plus 批量插入修改操作
 报错解决：RuntimeError: expected scalar type Long but found Float
Linux、Unix、WindowsＣ语言理解查看字节序排序
 python mean()求平均值
 antd form Item设置初始值
 反向输出一个三位数
 博途PLC S7-1200/1500 ModbusTcp通信SCL代码篇（轮询）
考公顺序步骤
 如何从800万数据中快速捞出自己想要的数据？
原文地址：https://blog.csdn.net/weixin_45274937/article/details/126644755