22.特性

CSharp > CSharp进阶 > CSharp进阶语法知识 CSharp 语法知识 CSharp进阶 反射和特性
发布时间 :
字数:7.3k 阅读 : 评论:
  1. 22.反射和特性-特性
    1. 22.1 知识点
      1. 特性是什么
      2. 自定义特性
      3. 特性的使用
        1. Type.IsDefined方法 判断这个类是否使用了某个特性
        2. Type.GetCustomAttributes方法 获取Type类元数据中的所有特性 一个类可能有很多特性一起修饰 返回一个object数组
      4. 限制自定义特性的使用范围
      5. 系统自带特性——过时特性
      6. 系统自带特性——调用者信息特性
      7. 系统自带特性——条件编译特性
      8. 系统自带特性——外部 DLL 包函数特性
      9. 总结
    2. 22.2 知识点代码
    3. 22.3 练习题
      1. 为反射练习题中的类库工程中的Player对象，随便为其中一个成员变量加一个自定义特性，同样实现反射练习题中的要求，但是当在设置加了自定义特性的成员变量时，在控制台中打印一句，非法操作，随意修改XXX成员
    4. 22.4 练习题代码
    5. 22.5 类库工程代码

22.反射和特性-特性

22.1 知识点

特性是什么

特性是一种允许我们向程序的程序集添加元数据的语言结构。它是用于保存程序结构信息的某种特殊类型的类。

特性提供功能强大的方法以将声明信息与 C# 代码（类型、方法、属性等）相关联。特性与程序实体关联后，即可在运行时使用反射查询特性信息。

特性的目的是告诉编译器把程序结构的某组元数据嵌入程序集中。它可以放置在几乎所有的声明中（类、变量、函数等等声明）。

说人话：

特性本质是个类，我们可以利用特性类为元数据添加额外信息。比如一个类、成员变量、成员方法等等为他们添加更多的额外信息。之后可以通过反射来获取这些额外信息。

自定义特性

  • 特性基类 Attribute
  • 自定义特性 继承 特性基类Attribute 来实现自定义特性
  • 一般来说，自定义特性的命名是 自定义特性名 + Attribute 后缀
// 实例
// 我的自定义特性类
class MyCustomAttribute : Attribute
{
    // 特性中的成员，一般根据需求来写
    public string myCustomAttributeInfo;

    public MyCustomAttribute(string myCustomAttributeInfo)
    {
        this.myCustomAttributeInfo = myCustomAttributeInfo;
    }

    public void MyCustomAttributeFun()
    {
        Console.WriteLine("我的自定义特性类中的函数");
    }
}

特性的使用

  • 基本语法: [特性名(参数列表)]（注意：一般不包括 Attribute 后缀，系统默认省略）
  • 本质上，就是在调用特性类的构造函数，参数列表是构造函数要传的参数
  • 写在哪里？
    • 类、函数、变量上一行，表示他们具有该特性信息
// 实例
[MyCustom("这个是我自己写的一个我的类")]
class MyClass
{
    [MyCustom("这是我的类中的一个成员变量")]
    public int myClassValue;

    [MyCustom("这是我的类中的一个用于测试的函数")]
    public void myClassFun([MyCustom("这是我的类中的测试函数的参数")] int a)
    {

    }
}

在主函数中使用

实例化测试类对象

//创建myClass变量 得到myClass的Type
MyClass myClass = new MyClass();
Type myClassType = myClass.GetType();
//myClassType = typeof(MyClass);
//myClassType = Type.GetType("Lesson21_特性.MyClass");

Type.IsDefined方法 判断这个类是否使用了某个特性

//Type类中的IsDefined方法 判断这个类是否使用了某个特性 返回一个bool值
//参数一：特性的类型 传入特性的Type
//参数二：代表是否搜索继承链 比如父类里面有没有这个特性 属性和事件忽略此参数
//注意：Type类中的IsDefined方法只会判断这个类有没有使用某个特性 假如这个类没有使用这个特性 但是类中的其他成员使用了这个特性 仍然返回false
if (myClassType.IsDefined(typeof(MyCustomAttribute), false))
{
    Console.WriteLine("该类型应用了MyCustom特性");//该类型应用了MyCustom特性
}

Type.GetCustomAttributes方法 获取Type类元数据中的所有特性 一个类可能有很多特性一起修饰 返回一个object数组

//Type类中的GetCustomAttributes方法 获取Type类元数据中的所有特性 一个类可能有很多特性一起修饰 返回一个object数组
//参数一：代表是否搜索继承链 比如父类里面有没有这个特性 属性和事件忽略此参数
object[] myClassTypeAllCustomAttributesArray = myClassType.GetCustomAttributes(true);

//for循环遍历Type类元数据中的所有特性数组 判断特性是不是你想得到的特性 是的话可以调用特性中的成员
for (int i = 0; i < myClassTypeAllCustomAttributesArray.Length; i++)
{
    //一个类可能有很多特性一起修饰 用is判断特性是不是你想得到的特性
    if (myClassTypeAllCustomAttributesArray[i] is MyCustomAttribute)
    {
        //输出我的自定义特性类中的信息
        Console.WriteLine((myClassTypeAllCustomAttributesArray[i] as MyCustomAttribute).myCustomAttributeInfo);//这个是我自己写的一个我的类
        //调用我的自定义特性类中的函数
        (myClassTypeAllCustomAttributesArray[i] as MyCustomAttribute).MyCustomAttributeFun();//我的自定义特性类中的函数
    }
}

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

  • 通过为特性类加特性限制自定义特性的使用范围
  • 基本语法：[AttributeUsage(AttributeTargets.XX | AttributeTargets.XX, AllowMultiple = ?, Inherited = ?)]
    • 参数一：AttributeTargets — 特性能够用在哪些地方，| 代表或
    • 参数二：AllowMultiple — 是否允许多个特性实例用在同一个目标上，默认是 false
    • 参数三：Inherited — 特性是否能被派生类和重写成员继承，默认是 false
//实例

//我的自定义特性类2 只能使用到 类 结构体 上 允许多个特性实例用在同一个目标上 特性能被派生类和重写成员继承
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = true, Inherited = true)]
public class MyCustom2Attribute : Attribute
{

}

//我的自定义特性类3 只能使用到 类 变量 上 允许多个特性实例用在同一个目标上 特性能被派生类和重写成员继承
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
public class MyCustom3Attribute : Attribute
{

}


[MyCustom2()]//MyCustom2能使用到 类 结构体 上
[MyCustom2()]//MyCustom2允许多个特性实例用在同一个目标上
[MyCustom3()]//MyCustom3能使用到 类 变量 上
[MyCustom3()]//MyCustom3允许多个特性实例用在同一个目标上
//我的类2
class MyClass2
{
    //[MyCustom2()]//MyCustom2报错 只能使用到 类 结构体 上
    [MyCustom3()]//MyCustom3能使用到 类 变量 上
    public int myClass2Value;

    //[MyCustom2()]//MyCustom2报错 只能使用到 类 结构体 上
    //[MyCustom3()]//MyCustom3报错 只能使用到 类 变量 上
    public void myClass2Fun(int a)
    //public void myClass2Fun([MyCustom()] int a)//MyCustom2报错 只能使用到 类 结构体 上
    {

    }
}

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

  • 用于提示用户使用的方法等成员已经过时，建议使用新方法
  • 一般加在函数前的特性
  • 关键字：Obsolete
  • 基本语法：[Obsolete("提示的内容", true或false)]
    • 参数一：调用过时方法时提示的内容
    • 参数二：true - 使用该方法时会报错，false - 使用该方法时直接警告
//实例

//测试说话类
class TestSpeakClass
{
    [Obsolete("OldSpeak方法已经过时了，请使用NewSpeak方法", false)]
    //老说话方法
    public void OldSpeak(string info)
    {
        Console.WriteLine(info);
    }

    //新说话方法
    public void NewSpeak(string info)
    {
        Console.WriteLine(info);
    }
}

在主函数内。

//创建测试说话类实例
TestSpeakClass testSpeakClass = new TestSpeakClass();
testSpeakClass.OldSpeak("老说话方法");//老说话方法
//因为Obsolete构造时 第二个参数是flase 调用时会发出警告：OldSpeak方法已经过时了，请使用NewSpeak方法
//假如Obsolete构造时 第二个参数是true 会直接报错
testSpeakClass.NewSpeak("新说话方法");//新说话方法

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

  • 哪个文件调用？
    • CallerFilePath特性：[CallerFilePath]
  • 哪一行调用？
    • CallerLineNumber特性：[CallerLineNumber]
  • 哪个函数调用？
    • CallerMemberName特性：[CallerMemberName]

需要引用命名空间 using System.Runtime.CompilerServices;

一般作为函数参数的特性，有时会在try catch中的catch中打印调用者信息特性。
调用者信息特性作为函数参数的特性时，必须要有默认值。
这样调用函数时，假如有调用者信息特性作为函数参数的参数不传值的话，他就能把调用者信息替换到默认值上，可以写逻辑在函数中打印出来。

在测试说话类中添加说出调用者信息方法。

//说出调用者信息方法
public void SpeakCallerInfo(string info, [CallerFilePath] string fileName = "",
    [CallerLineNumber] int line = 0, [CallerMemberName] string target = "")
{
    Console.WriteLine(info);
    Console.WriteLine(fileName);
    Console.WriteLine(line);
    Console.WriteLine(target);
}

在主函数内。

//说出调用者信息方法 试着只传info 不传后面的调用者信息
//public void SpeakCallerInfo(string info, [CallerFilePath] string fileName = "",
//    [CallerLineNumber] int line = 0, [CallerMemberName] string target = "")
testSpeakClass.SpeakCallerInfo("SpeakCallerInfo方法");
//E:\GameDevelopment\GameDevelopmentLearning\C#\C#进阶\CSharp进阶教程\Lesson21_特性\Program.cs
//275
//Main

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

  • 条件编译特性
    • 关键字：Conditional
    • 基本语法：[Conditional("#define定义的符号")]
    • 它会和预处理指令 #define 配合使用
    • 需要引用命名空间 using System.Diagnostics;
    • 主要可以用在一些调试代码上
    • 有时想执行有时不想执行的代码
    • 假如没有定义传入的 define 定义的符号就不会执行
    • 假如有定义传入的 define 定义的符号就会执行
//实例
[Conditional("ConditionalCompilationFun")]
//条件编译方法
static void ConditionalCompilationFun()
{
    Console.WriteLine("条件编译方法执行");
}

在脚本最前面。

// 定义 ConditionalCompilationFun
#define ConditionalCompilationFun

在主函数内。

// 因为脚本最前面定义 ConditionalCompilationFun，所以能正常执行，否则执行无效
ConditionalCompilationFun(); // 条件编译方法执行

系统自带特性——外部 DLL 包函数特性

  • 外部Dll包函数特性

    • 关键字：DllImport

    • 基本语法：[DllImport("外部Dll包的路径或文件名")]

    • 用来标记非.Net(C#)的函数，表明该函数在一个外部的DLL中定义。

    • 一般用来调用 C 或者 C++ 的Dll包写好的方法。

    • 需要引用命名空间 using System.Runtime.InteropServices

// 实例
// 假设某个 C++ 的 DLL 包和当前程序集放在同一目录 
[DllImport("CPP.dll")]
// 映射 C++ 的 DLL 包的加法方法到 C# 里来，C++ 的 DLL 包你会有相同函数名、参数、返回值的函数，这样调用的时候就是调用 C++ 的 DLL 包的加法方法的逻辑
public static extern int Add(int a, int b);

总结

  • 特性是用于为元数据再添加更多的额外信息（变量、方法等等）。
  • 我们可以通过反射获取这些额外的数据来进行一些特殊的处理。
  • 自定义特性——继承 Attribute 类。
  • 系统自带特性：过时特性。
  • 为什么要学习特性：Unity 引擎中很多地方都用到了特性来进行一些特殊处理。

22.2 知识点代码

//脚本最前面

#region 知识点七 系统自带特性——条件编译特性

//定义ConditionalCompilationFun
#define ConditionalCompilationFun

#endregion

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace Lesson21_特性
{
    #region 知识点一 特性是什么
    //特性是一种允许我们向程序的程序集添加元数据的语言结构
    //它是用于保存程序结构信息的某种特殊类型的类

    //特性提供功能强大的方法以将声明信息与 C# 代码（类型、方法、属性等）相关联。
    //特性与程序实体关联后，即可在运行时使用反射查询特性信息

    //特性的目的是告诉编译器把程序结构的某组元数据嵌入程序集中
    //它可以放置在几乎所有的声明中（类、变量、函数等等申明）

    //说人话：
    //特性本质是个类
    //我们可以利用特性类为元数据添加额外信息
    //比如一个类、成员变量、成员方法等等为他们添加更多的额外信息
    //之后可以通过反射来获取这些额外信息
    #endregion

    //class语句块外 namespace语句块内

    #region 知识点二 自定义特性
    //特性基类 Attribute
    //继承特性基类Attribute来实现自定义特性
    //一般来说 自定义特性的命名是 自定义特性名 + Attribute后缀

    //实例
    //我的自定义特性类
    class MyCustomAttribute : Attribute
    {
        //特性中的成员 一般根据需求来写
        public string myCustomAttributeInfo;

        public MyCustomAttribute(string myCustomAttributeInfo)
        {
            this.myCustomAttributeInfo = myCustomAttributeInfo;
        }

        public void MyCustomAttributeFun()
        {
            Console.WriteLine("我的自定义特性类中的函数");
        }
    }
    #endregion

    #region 知识点三 特性的使用

    //基本语法:[特性名(参数列表)]（注意：一般不包括Attribute后缀，系统默认省略）
    //本质上 就是在调用特性类的构造函数 参数列表是构造函数要传的参数
    //写在哪里？
    //类、函数、变量上一行，表示他们具有该特性信息

    //实例


    [MyCustom("这个是我自己写的一个我的类")]
    //[MyCustom("这个是我自己写的一个我的类")]
    //我的类
    class MyClass
    {
        [MyCustom("这是我的类中的一个成员变量")]
        public int myClassValue;

        [MyCustom("这是我的类中的一个用于测试的函数")]
        public void myClassFun([MyCustom("这是我的类中的测试函数的参数")] int a)
        {

        }


        //public void MyCustomAttributeFun(int a)
        //{

        //}
    }


    #endregion

    #region 知识点四 限制自定义特性的使用范围

    //通过为特性类 加特性 限制自定义特性的使用范围
    //基本语法：[AttributeUsage(AttributeTargets.XX | AttributeTargets.XX, AllowMultiple = ?, Inherited = ?)]
    //参数一：AttributeTargets —— 特性能够用在哪些地方 |代表或
    //参数二：AllowMultiple —— 是否允许多个特性实例用在同一个目标上 默认是false
    //参数三：Inherited —— 特性是否能被派生类和重写成员继承 默认是false

    //实例

    //我的自定义特性类2 只能使用到 类 结构体 上 允许多个特性实例用在同一个目标上 特性能被派生类和重写成员继承
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = true, Inherited = true)]
    public class MyCustom2Attribute : Attribute
    {

    }

    //我的自定义特性类3 只能使用到 类 变量 上 允许多个特性实例用在同一个目标上 特性能被派生类和重写成员继承
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
    public class MyCustom3Attribute : Attribute
    {

    }


    [MyCustom2()]//MyCustom2能使用到 类 结构体 上
    [MyCustom2()]//MyCustom2允许多个特性实例用在同一个目标上
    [MyCustom3()]//MyCustom3能使用到 类 变量 上
    [MyCustom3()]//MyCustom3允许多个特性实例用在同一个目标上
    //我的类2
    class MyClass2
    {
        //[MyCustom2()]//MyCustom2报错 只能使用到 类 结构体 上
        [MyCustom3()]//MyCustom3能使用到 类 变量 上
        public int myClass2Value;

        //[MyCustom2()]//MyCustom2报错 只能使用到 类 结构体 上
        //[MyCustom3()]//MyCustom3报错 只能使用到 类 变量 上
        public void myClass2Fun(int a)
        //public void myClass2Fun([MyCustom()] int a)//MyCustom2报错 只能使用到 类 结构体 上
        {

        }
    }

    #endregion

    #region 知识点五 系统自带特性——过时特性

    //过时特性
    //用于提示用户 使用的方法等成员已经过时 建议使用新方法
    //一般加在函数前的特性
    //关键字：Obsolete
    //基本语法：[Obsolete("提示的内容", true或false)]
    //参数一：调用过时方法时 提示的内容
    //参数二：true-使用该方法时会报错  false-使用该方法时直接警告

    //实例

    //测试说话类
    class TestSpeakClass
    {
        [Obsolete("OldSpeak方法已经过时了，请使用NewSpeak方法", false)]
        //老说话方法
        public void OldSpeak(string info)
        {
            Console.WriteLine(info);
        }

        //新说话方法
        public void NewSpeak(string info)
        {
            Console.WriteLine(info);
        }


        //测试说话类中

        #region 知识点六 系统自带特性——调用者信息特性


        //哪个文件调用？
        //CallerFilePath特性：[CallerFilePath]
        //哪一行调用？
        //CallerLineNumber特性：[CallerLineNumber]
        //哪个函数调用？
        //CallerMemberName特性：[CallerMemberName]

        //需要引用命名空间 using System.Runtime.CompilerServices;
        //一般作为函数参数的特性 有时会在try catch中的catch中打印调用者信息特性
        //调用者信息特性作为函数参数的特性时 必须要有默认值
        //这样调用函数时 假如有调用者信息特性作为函数参数的参数不传值的话 他就能把调用者信息替换到默认值上 可以写逻辑在函数中打印出来

        //说出调用者信息方法
        public void SpeakCallerInfo(string info, [CallerFilePath] string fileName = "",
            [CallerLineNumber] int line = 0, [CallerMemberName] string target = "")
        {
            Console.WriteLine(info);
            Console.WriteLine(fileName);
            Console.WriteLine(line);
            Console.WriteLine(target);
        }

        #endregion
    }

    #endregion


    class Program
    {
        //class语句块内 主函数外


        #region 知识点七 系统自带特性——条件编译特性

        //条件编译特性
        //关键字：Conditional
        //基本语法：[Conditional("#define定义的符号")]
        //它会和预处理指令 #define配合使用
        //需要引用命名空间using System.Diagnostics;
        //主要可以用在一些调试代码上
        //有时想执行有时不想执行的代码
        //假如没有定义传入的define定义的符号 就不会执行
        //假如有定义传入的define定义的符号 就会执行

        //实例
        [Conditional("ConditionalCompilationFun")]
        //条件编译方法
        static void ConditionalCompilationFun()
        {
            Console.WriteLine("条件编译方法执行");
        }

        #endregion

        #region 知识点八 系统自带特性——外部Dll包函数特性

        //外部Dll包函数特性
        //关键字：DllImport
        //基本语法：[DllImport("外部Dll包的路径或文件名")]

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


        //实例
        //假设某个C++的Dll包和当前程序集放在同一目录 
        [DllImport("CPP.dll")]
        //映射C++的Dll包的加法方法到C#里来 C++的Dll包你会有 相同 函数名 参数 返回值 的函数 这样调用的时候就是调用C++的Dll包的加法方法的逻辑
        public static extern int Add(int a, int b);


        #endregion




        static void Main(string[] args)
        {
            Console.WriteLine("特性");

            //主函数内

            #region 知识点三 特性的使用

            //创建myClass变量 得到myClass的Type
            MyClass myClass = new MyClass();
            Type myClassType = myClass.GetType();
            //myClassType = typeof(MyClass);
            //myClassType = Type.GetType("Lesson21_特性.MyClass");

            //Type类中的IsDefined方法 判断这个类是否使用了某个特性 返回一个bool值
            //参数一：特性的类型 传入特性的Type
            //参数二：代表是否搜索继承链 比如父类里面有没有这个特性 属性和事件忽略此参数
            //注意：Type类中的IsDefined方法只会判断这个类有没有使用某个特性 假如这个类没有使用这个特性 但是类中的其他成员使用了这个特性 仍然返回false
            if (myClassType.IsDefined(typeof(MyCustomAttribute), false))
            {
                Console.WriteLine("该类型应用了MyCustom特性");//该类型应用了MyCustom特性
            }

            //Type类中的GetCustomAttributes方法 获取Type类元数据中的所有特性 一个类可能有很多特性一起修饰 返回一个object数组
            //参数一：代表是否搜索继承链 比如父类里面有没有这个特性 属性和事件忽略此参数
            object[] myClassTypeAllCustomAttributesArray = myClassType.GetCustomAttributes(true);

            //for循环遍历Type类元数据中的所有特性数组 判断特性是不是你想得到的特性 是的话可以调用特性中的成员
            for (int i = 0; i < myClassTypeAllCustomAttributesArray.Length; i++)
            {
                //一个类可能有很多特性一起修饰 用is判断特性是不是你想得到的特性
                if (myClassTypeAllCustomAttributesArray[i] is MyCustomAttribute)
                {
                    //输出我的自定义特性类中的信息
                    Console.WriteLine((myClassTypeAllCustomAttributesArray[i] as MyCustomAttribute).myCustomAttributeInfo);//这个是我自己写的一个我的类
                    //调用我的自定义特性类中的函数
                    (myClassTypeAllCustomAttributesArray[i] as MyCustomAttribute).MyCustomAttributeFun();//我的自定义特性类中的函数
                }
            }

            #endregion

            #region 知识点五 系统自带特性——过时特性

            //创建测试说话类实例
            TestSpeakClass testSpeakClass = new TestSpeakClass();
            testSpeakClass.OldSpeak("老说话方法");//老说话方法
            //因为Obsolete构造时 第二个参数是flase 调用时会发出警告：OldSpeak方法已经过时了，请使用NewSpeak方法
            //假如Obsolete构造时 第二个参数是true 会直接报错
            testSpeakClass.NewSpeak("新说话方法");//新说话方法

            #endregion

            #region 知识点六 系统自带特性——调用者信息特性

            //说出调用者信息方法 试着只传info 不传后面的调用者信息
            //public void SpeakCallerInfo(string info, [CallerFilePath] string fileName = "",
            //    [CallerLineNumber] int line = 0, [CallerMemberName] string target = "")
            testSpeakClass.SpeakCallerInfo("SpeakCallerInfo方法");
            //E:\GameDevelopment\GameDevelopmentLearning\C#\C#进阶\CSharp进阶教程\Lesson21_特性\Program.cs
            //275
            //Main


            #endregion

            #region 知识点七 系统自带特性——条件编译特性

            //因为脚本最前面 定义ConditionalCompilationFun 所以能正常执行 否则执行无效
            ConditionalCompilationFun();//条件编译方法执行

            #endregion

        }
    }

    //总结：

    //特性是用于 为元数据再添加更多的额外信息（变量、方法等等）
    //我们可以通过反射获取这些额外的数据 来进行一些特殊的处理
    //自定义特性——继承Attribute类

    // 系统自带特性：过时特性

    // 为什么要学习特性
    // Unity引擎中很多地方都用到了特性来进行一些特殊处理
}

22.3 练习题

为反射练习题中的类库工程中的Player对象，随便为其中一个成员变量加一个自定义特性，同样实现反射练习题中的要求，但是当在设置加了自定义特性的成员变量时，在控制台中打印一句，非法操作，随意修改XXX成员

修改类库工程 给类库工程加上自定义特性类 为玩家名成员变量添加自定义特性

using System;

namespace MrTao
{
    // 修改类库工程 给类库工程加上自定义特性类 为玩家名成员变量添加自定义特性

    // 我的自定义特性
    class MyCustomAttribute : Attribute
    {

    }

    // 位置
    struct Position
    {
        public int x;
        public int y;
        public Position(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }

    // 玩家
    class Player
    {
        // 为玩家名添加自定义特性
        [MyCustom()]
        public string name;

        public int hp;
        public int atk;
        public int def;
        public Position pos;
    }
}

调用Assembly类的LoadFrom方法 加载一个指定程序集

Assembly assembly = Assembly.LoadFrom(@"E:\GameDevelopment\GameDevelopmentLearning\C#\C#进阶\CSharp进阶教程\测试\bin\Debug\测试");
//注意1：传入的路径是dll文件所在的路径 路径的最后要带上dll文件的文件名 也可以加上dll后缀
//注意2：不能直接传入路径 因为\是转义字符 直接输入\不代表\
//取消转义字符有两种方式：
//1.使用\\ 意思是取消转义 这样一个\\就代表一个真正的\
//2.在路径前加一个@

调用Assembly类的GetTypes方法 获得程序集中的所有类的Type

// 用一个Type类数组装载
Type[] types = assembly.GetTypes();

遍历打印程序集中的所有类的Type

for (int i = 0; i < types.Length; i++)
{
    Console.WriteLine(types[i]);
    // MrTao.MyCustomAttribute
    // MrTao.Position
    // MrTao.Player
}

通过反射 实例化一个程序集中的对象（player对象）

i. 调用GetType()方法 通过传入类名 得到MrTao.Player类的Type

// 注意：类名必须包含命名空间 不然找不到
Type playerType = assembly.GetType("MrTao.Player");

ii. 调用Activator类中的CreateInstance()方法 

// Activator类中的CreateInstance()方法会返回一个object对象 CreateInstance有多个重载
// 第一个参数固定传 你想要构造的类的Type类 比如 实例化一个icon对象就传入iconType
// 后面的参数是变长参数 根据你想要构造的类 的 构造函数参数 传对应的参数 假如是无参构造函数就可以不传
// Player类只有无参构造函数 所以就可以不传
object playerObject = Activator.CreateInstance(playerType);
// 这样就能实例化player的对象 但是由于Player类不在我们的程序集中 所以没有as成Player 而是用object去装

打印playerObject

Console.WriteLine(playerObject);// MrTao.Player

调用Type类中的GetFields()方法 可以得到MrTao.Player类中的所有公共成员变量

// 要用到FieldInfo类的数组 装载 MrTao.Player类中的所有公共成员变量
// FieldInfo类是公共成员变量的反射信息类
// FieldInfo类需要引用命名空间 using System.Reflection;
FieldInfo[] playerTypeFieldInfo = playerType.GetFields();

遍历打印MrTao.Player类的所有公共成员变量

for (int i = 0; i < playerTypeFieldInfo.Length; i++)
{
    Console.WriteLine(playerTypeFieldInfo[i]);
    // System.String name
    // Int32 hp
    // Int32 atk
    // Int32 def
    // MrTao.Position pos
}

首先要得到我们自定特性的Type

Type myCustomAttributeibuteType = assembly.GetType("MrTao.MyCustomAttribute");

获得name成员变量的公共成员变量的反射信息

FieldInfo playerTypeFieldInfoName = playerType.GetField("name");

判断当前name成员变量有没有特性

// 调用MemberInfo类中的GetCustomAttribute方法 尝试获取MemberInfo元数据中的特性
// 如果有就返回MemberInfo元数据中的特性 没有就返回空
// 参数一：我们自定特性的Type
// 注意：知识点提到的Type类中的GetCustomAttributes方法 其实Type是继承MemberInfo的 FieldInfo也继承MemberInfo的

// 得到的特性如果不为空 就证明有这个特性
if (playerTypeFieldInfoName.GetCustomAttribute(myCustomAttributeibuteType) != null)
{
    Console.WriteLine("非法操作，随意修改name成员");// 非法操作，随意修改name成员
}
// 检测没有被自定义特性修饰 可以修改
else
{
    // 调用FieldInfo类中 name成员变量的公共成员变量的反射信息类 的SetValue()方法 传入MrTao.Player类的对象和要设置的值
    // 注意：要先得到用FieldInfo类装的指定名称的公共成员变量的反射信息
    playerTypeFieldInfoName.SetValue(playerObject, "123123");
}

22.4 练习题代码

using System;
using System.Reflection;

namespace Lesson21_练习题
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("特性练习题");

            #region 练习题一
            //为反射练习题中的类库工程中的Player对象
            //随便为其中一个成员变量加一个自定义特性
            //同样实现反射练习题中的要求

            //但是当在设置加了自定义特性的成员变量时，在控制台中打印一句
            //非法操作，随意修改XXX成员


            //调用Assembly类的LoadFrom方法 加载一个指定程序集
            Assembly assembly = Assembly.LoadFrom(@"E:\GameDevelopment\GameDevelopmentLearning\C#\C#进阶\CSharp进阶教程\测试\bin\Debug\测试");
            //注意1：传入的路径是dll文件所在的路径 路径的最后要带上dll文件的文件名 也可以加上dll后缀
            //注意2：不能直接传入路径 因为\是转义字符 直接输入\不代表\
            //取消转义字符有两种方式：
            //1.使用\\ 意思是取消转义 这样一个\\就代表一个真正的\
            //2.在路径前加一个@

            //调用Assembly类的GetTypes方法 获得程序集中的所有类的Type
            //用一个Type类数组装载
            Type[] types = assembly.GetTypes();


            //遍历打印程序集中的所有类的Type
            for (int i = 0; i < types.Length; i++)
            {
                Console.WriteLine(types[i]);
                //MrTao.MyCustomAttribute
                //MrTao.Position
                //MrTao.Player
            }

            //通过反射 实例化一个程序集中的对象（player对象）

            //调用GetType()方法 通过传入类名 得到MrTao.Player类的Type
            //注意：类名必须包含命名空间 不然找不到
            Type playerType = assembly.GetType("MrTao.Player");


            //通过反射 实例化一个player对象
            //调用Activator类中的CreateInstance()方法 
            //Activator类中的CreateInstance()方法会返回一个object对象 CreateInstance有多个重载
            //第一个参数固定传 你想要构造的类的Type类 比如 实例化一个icon对象就传入iconType
            //后面的参数是变长参数 根据你想要构造的类 的 构造函数参数 传对应的参数 假如是无参构造函数就可以不传
            //Player类只有无参构造函数 所以就可以不传
            object playerObject = Activator.CreateInstance(playerType);
            //这样就能实例化player的对象 但是由于Player类不在我们的程序集中 所以没有as成Player 而是用object去装

            //打印playerObject
            Console.WriteLine(playerObject);//MrTao.Player




            //调用Type类中的GetFields()方法 可以得到MrTao.Player类中的所有公共成员变量
            //要用到FieldInfo类的数组 装载 MrTao.Player类中的所有公共成员变量
            //FieldInfo类是公共成员变量的反射信息类
            //FieldInfo类需要引用命名空间 using System.Reflection;
            FieldInfo[] playerTypeFieldInfo = playerType.GetFields();

            //遍历打印MrTao.Player类的所有公共成员变量
            for (int i = 0; i < playerTypeFieldInfo.Length; i++)
            {
                Console.WriteLine(playerTypeFieldInfo[i]);
                //System.String name
                //Int32 hp
                //Int32 atk
                //Int32 def
                //MrTao.Position pos
            }

            //首先要得到我们自定特性的Type
            Type myCustomAttributeibuteType = assembly.GetType("MrTao.MyCustomAttribute");

            //获得name成员变量的公共成员变量的反射信息类
            FieldInfo playerTypeFieldInfoName = playerType.GetField("name");


            //判断当前name成员变量有没有特性

            //调用MemberInfo类中的GetCustomAttribute方法 尝试获取MemberInfo元数据中的特性
            //如果有就返回MemberInfo元数据中的特性 没有就返回空
            //参数一：我们自定特性的Type
            //注意：知识点提到的Type类中的GetCustomAttributes方法 其实Type是继承MemberInfo的 FieldInfo也继承MemberInfo的

            //得到的特性如果不为空 就证明有这个特性
            if (playerTypeFieldInfoName.GetCustomAttribute(myCustomAttributeibuteType) != null)
            {
                Console.WriteLine("非法操作，随意修改name成员");//非法操作，随意修改name成员
            }
            //检测没有被自定义特性修饰 可以修改
            else
            {
                //调用FieldInfo类中 name成员变量的公共成员变量的反射信息类 的SetValue()方法 传入MrTao.Player类的对象和要设置的值
                //注意：要先得到用FieldInfo类装的指定名称的公共成员变量的反射信息
                playerTypeFieldInfoName.SetValue(playerObject, "123123");
            }


            #endregion
        }
    }
}

22.5 类库工程代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MrTao
{

    //修改类库工程 给类库工程加上自定义特性类 为玩家名成员变量添加自定义特性

    //我的自定义特性
    class MyCustomAttribute : Attribute
    {

    }

    //位置
    struct Position
    {
        public int x;
        public int y;
        public Position(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }

    //玩家
    class Player
    {
        //为玩家名添加自定义特性
        [MyCustom()]
        public string name;

        public int hp;
        public int atk;
        public int def;
        public Position pos;
    }
}
转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 785293209@qq.com

赏

©2016-2024 Tao

Built with Hexo and 3-hexo theme

×

喜欢就点赞,疼爱就打赏