【微信平台，此文仅授权《NCC 开源社区》订阅号发布】

本篇主要研究类型、类型成员的各种信息和标识，通过反射的操作将信息解析出来。

本文主目的的通过反射操作，生成输出类似下图的信息。

在此之前记一下：

C# 中的访问修饰符：public、private、protected、internal、protected internal。

C# 两个成员关键字 readonly、const。

C# 声明修饰符： sealed、static、virtual、new 、abstract、override。

我们根据反射的类型对象，大概分为：类、值类型、数组、结构体、枚举、接口、抽象类、委托、事件、各种泛型(泛型类、泛型方法、泛型构造函数等)。

此文花了我一天半时间，除了写文章外，查看大量文档资料，创建了很多项目，进行了大量测试验证，最终整理出来。

至此此系列已经进行到第九篇啦。

1，判断类型

从 Type 中解析类型信息，笔者使用思维导图整理如图

判断是否某种类型

一般来说，如果有两个 Type 对象，要判断两个 Type 所反射的类型，是否为同一种类型，可以使用 == 。

            Type A = typeof(ClassA);
            Type B = typeof(ClassB);
            Console.WriteLine(A == B);

1.1 类和委托

1.1.1 判断是否类型或委托

Type.IsClass 属性可以判断一个类型是否为类或者委托。符合条件的会有普通的类(包括泛型)、抽象类(abstract class)、委托(delegate)。

它可以排除值类型和接口。例如简单值类型、结构体、枚举、接口。

1.1.2 判断是否泛型

Type.IsGenericType 属性可以判断类或委托是否为泛型类型。

Type.IsGenericTypeDefinition 属性可以判断 Type 是否是未绑定参数类型的泛型类型。

Type.IsConstructedGenericType 属性判断是否可以此 Type 创建泛型实例。

如果是已绑定参数类型的泛型，则可以使用 Activator.CreateInstance() 等方式实例化类型。

实验过程：

创建三个类型

    public delegate void DeA();
    public delegate void DeB<T>(T t);

    public class ClassC<T>
    {
        public ClassC(T t) { }
    }

打印输出

           // 普通委托
            Type typeA = typeof(DeA);
            Console.WriteLine("类型名称：" + typeA.Name);
            Console.WriteLine("是否为类或委托：" + typeA.IsClass);
            Console.WriteLine("是否为泛型：" + typeA.IsGenericType);
            Console.WriteLine("是否已绑定参数类型：" + typeA.IsGenericTypeDefinition);
            Console.WriteLine("可以用此 Type 创建实例：" + typeA.IsConstructedGenericType);


            // 泛型委托，不绑定参数类型
            Type typeB = typeof(DeB<>);
            Console.WriteLine("\n\n类型名称：" + typeB.Name);
            Console.WriteLine("是否为类或委托：" + typeB.IsClass);
            Console.WriteLine("是否为泛型：" + typeB.IsGenericType);
            Console.WriteLine("是否已绑定参数类型：" + typeB.IsGenericTypeDefinition);
            Console.WriteLine("可以用此 Type 创建实例：" + typeB.IsConstructedGenericType);

            // 泛型委托，绑定参数类型
            Type typeBB = typeof(DeB<int>);
            Console.WriteLine("\n\n类型名称：" + typeBB.Name);
            Console.WriteLine("是否为类或委托：" + typeBB.IsClass);
            Console.WriteLine("是否为泛型：" + typeBB.IsGenericType);
            Console.WriteLine("是否已绑定参数类型：" + typeBB.IsGenericTypeDefinition);
            Console.WriteLine("可以用此 Type 创建实例：" + typeBB.IsConstructedGenericType);

            // 泛型类，未绑定参数
            Type typeC = typeof(ClassC<>);
            Console.WriteLine("\n\n类型名称：" + typeC.Name);
            Console.WriteLine("是否为类或委托：" + typeC.IsClass);
            Console.WriteLine("是否为泛型：" + typeC.IsGenericType);
            Console.WriteLine("是否已绑定参数类型：" + typeC.IsGenericTypeDefinition);
            Console.WriteLine("可以用此 Type 创建实例：" + typeC.IsConstructedGenericType);

            // 泛型类型，已绑定参数
            Type typeD = typeof(ClassC<int>);
            Console.WriteLine("\n\n类型名称：" + typeD.Name);
            Console.WriteLine("是否为类或委托：" + typeD.IsClass);
            Console.WriteLine("是否为泛型：" + typeD.IsGenericType);
            Console.WriteLine("是否已绑定参数类型：" + typeD.IsGenericTypeDefinition);
            Console.WriteLine("可以用此 Type 创建实例：" + typeD.IsConstructedGenericType);

1.1.3 泛型的参数名称和泛型限定

获取泛型类型定义时，泛型参数的名称

    public class MyClass<T1,T2,T3,T4,T5> { }

            Type type = typeof(MyClass<,,,,>);

            var types = ((System.Reflection.TypeInfo)type).GenericTypeParameters;
            foreach (var item in types)
            {
                Console.WriteLine(item.Name);
            }

输出

T1
T2
T3
T4
T5

TypeInfo 用于处理各类类型的泛型类型声明。

《C#反射与特性(四)：实例化类型》第三节中，我们探究了泛型的各种实例化方式。

泛型约束

对于类和方法来说，使用泛型版本，可能会进行泛型约束，我们需要将约束解析出来。

Type 中， GetGenericParameterConstraints 和 GenericParameterAttributes 属性，可以判断约束类型。

GetGenericParameterConstraints 可以获取到参数类型，不过只能对 struct、class、、、T : U 有效。

• 这些约束之间，有着复杂的冲突关系，这里就不一一列举了。
• 而有些类型本身就代表包含多种约束，例如 struct 本身包含 new()、notnull。
• 有些约束条件是可以互相组合的。

从上面看来，要解析泛型约束，不是容易的事。

GenericParameterAttributes 枚举

但是我们来划分一下，针对不同情况下的组合，来理清一下 Type 和 GenericParameterAttributes 的关系。

先看一下 GenericParameterAttributes 枚举，此枚举是用来描述泛型类或方法上泛型参数约束的。

    public enum GenericParameterAttributes
    {
        None = 0,                       // 无特殊情况
        Covariant = 1,                  // 泛型类型参数是可协变的
        Contravariant = 2,              // 泛型类型参数是逆变的
        VarianceMask = 3,               // Contravariant 和 Covariant 的集合
        ReferenceTypeConstraint = 4,    // 引用类型
        NotNullableValueTypeConstraint = 8, // 是值类型且不为空
        DefaultConstructorConstraint = 16,  // 无参数构造函数
        SpecialConstraintMask = 28          // 所有特殊标记的集合
    }

接下来看看不同约束条件和对应的 GenericParameterAttributes 枚举值。

泛型约束关系

泛型约束有各种冲突关系和约束特性，我们来通过表格和图片，一一列举出来。

注：T : U 使用时虽然不提示与其它约束冲突，如果继承的约束有冲突，可能会在编译时或运行期可能会报错。

编写代码时，不与其它约束冲突，但是实际上有些是不能同时使用的。

unmanaged, BaseInterFace 可以用作约束条件，但是 unmanaged 应该是非托管类型，这里我们就不考虑了。

泛型约束关系如图所示：

看完图片后是不是感觉思路很清晰了呢~

泛型约束比较多，他们有多种组合，但是从上图，可以判断组合时：

①(红)

②(黄)(N个蓝)

③(黄)(N个蓝)(橙)

④(任意一种颜色)

⑤(N个蓝色)

由于代码比较多，这里就不显示了，代码已经上传至码云 解析泛型

关于泛型的反射，可以参考这里 https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/generics/generics-and-reflection

1.1.4 是否委托

经过前面的操作，已经可以筛选出一个类型是否为类型或委托，那么判断一个类型是否为委托，可以使用 IsSubclassOf() ，可以判断一个 Type 是否为委托类型。

IsSubclassOf() 可以判断当前 Type 是否派生于 参数中的 Type。

type.IsSubclassOf(typeof(Delegate));

另外，有个多播委托 MulticastDelegate ，可以使用

type.IsSubclassOf(typeof(MulticastDelegate))

1.1.5 访问修饰符

在命名空间中说明的类和委托只能使用 public、internal 两个修饰符修饰访问权限。如果不指定的话，默认下是 internal 。

Type 的两个属性 IsPublic、IsNotPublic可以对此进行识别。

测试：

    public class A { }
    internal class B { }
    class C { }

Main 中输出

            Type typeA = typeof(A);
            Type typeB = typeof(B);
            Type typeC = typeof(C);

            Console.WriteLine(typeA.Name);
            Console.WriteLine("是否public:    "+typeA.IsPublic);
            Console.WriteLine("是否protected:    " + typeA.IsNotPublic);


            Console.WriteLine("\n"+typeB.Name);
            Console.WriteLine("是否public:    " + typeB.IsPublic);
            Console.WriteLine("是否protected:    " + typeB.IsNotPublic);

            Console.WriteLine("\n" + typeC.Name);
            Console.WriteLine("是否public:    " + typeC.IsPublic);
            Console.WriteLine("是否protected:    " + typeC.IsNotPublic);

输出结果

A
是否public:    True
是否protected:    False

B
是否public:    False
是否protected:    True

C
是否public:    False
是否protected:    True

1.1.6 密封类、静态类型、抽象类

密封类是不能被继承的类型，通过 Type 的 IsSealed 可以判断。

    public sealed class A { }

            Console.WriteLine(typeof(A).IsSealed);

sealed 也可以修饰委托。

判断是否为抽象类

    public abstract class MyClass { }

            Console.WriteLine(typeof(MyClass).IsAbstract);

定义类时，static、abstract、sealed 任意两个不能在一起调用。

如果一个类是静态类，那么 IsSealed 和 IsAbstract 都是 true。

Type 中没有判断类是否为静态类的属性或方法，但是可以通过上面的方法判断是否为静态类。

我们可以做一下实验

    public sealed class A { }
    public abstract class B { }
    public static class C { }

            Type typeA = typeof(A);
            Type typeB = typeof(B);
            Type typeC = typeof(C);

            Console.WriteLine("密封类：");
            Console.WriteLine("IsSealed：" + typeA.IsSealed);
            Console.WriteLine("IsAbstract：" + typeA.IsAbstract);

            Console.WriteLine("\n抽象类类：");
            Console.WriteLine("IsSealed：" + typeB.IsSealed);
            Console.WriteLine("IsAbstract：" + typeB.IsAbstract);

            Console.WriteLine("\n静态类");
            Console.WriteLine("IsSealed：" + typeC.IsSealed);
            Console.WriteLine("IsAbstract：" + typeC.IsAbstract);

输出结果

密封类：
IsSealed：True
IsAbstract：False

抽象类类：
IsSealed：False
IsAbstract：True

静态类
IsSealed：True
IsAbstract：True

1.1.7 嵌套类访问权限

下面是有关于嵌套类型的 Type 的 属性。 类和委托都可以使用。

1.1.8 特性

索特性的方式有两种

• 调用 Type 或者 MemberInfo 的 GetCustomAttributes 方法;
• 调用 Attribute.GetCustomAttribute 或者 Attribute.GetCustomAttributes 方法；

《C#反射与特性(七)：自定义特性以及应用》中，对特性的使用做了很详细的介绍，这里不再赘述。

1.1.9 父类、接口

            Type type = typeof(List<>);
            Console.WriteLine("List<> 的父类为：" + type.BaseType);

            Console.WriteLine("List<> 继承的接口：");
            Type[] types = type.GetInterfaces();
            foreach (var item in types)
            {
                Console.WriteLine(item.Name);
            }

1.2 值类型

Type.IsValueType 可以判断一个 Type 是否为值类型，简单值类型、结构体、枚举，都符合要求。

Type.IsEnum 判断 Type 是否为枚举。

Type.IsPrimitive 判断 Type 是否为基础类型。

通过以下过程可以判断一个类型属性何种值类型

        public enum MyTest
        {
            None = 0,   // 不是值类型
            Enum = 1,   // 枚举
            Struct = 2, // 结构体
            Base = 3    // 基础类型
        }
        public static MyTest Test(Type type)
        {
            if (!type.IsValueType)
                return MyTest.None;

            if (type.IsEnum)
                return MyTest.Enum;

            return type.IsPrimitive ? MyTest.Base : MyTest.Struct;
        }

枚举 Type，有如下方法帮助获取枚举信息：

1.3 接口

Type.IsInterface 属性，判断 Type 是否为接口。

1.4 数组

IsArray 判断是否为数组，GetArrayRank() 获取数组的维数。

通过 GetElementType 可以获取数组的元素类型

IsSZArray 判断是否为交错数组/锯齿数组，IsVariableBoundArray 判断是否为一维或多维数组。

IsSZArray 和 IsVariableBoundArray 是 .NET Core 2.0 以上、.NET Standard 2.1 以上才有的。

            Type a = typeof(int[,,,,]);
            Console.WriteLine(a.Name);
            Console.WriteLine("数组元素类型：" + a.GetElementType());
            Console.WriteLine("是否为数组：" + a.IsArray);
            Console.WriteLine("交错数组：" + a.IsSZArray);
            Console.WriteLine("一维或多维数组" + a.IsVariableBoundArray);
            Console.WriteLine("数组维数：" + a.GetArrayRank());


            Console.WriteLine("\n\n");
            Type b = typeof(int[][][][]);
            Console.WriteLine(b.Name);
            Console.WriteLine("数组元素类型：" + b.GetElementType());
            Console.WriteLine("是否为数组：" + b.IsArray);
            Console.WriteLine("交错数组：" + b.IsSZArray);
            Console.WriteLine("一维或多维数组" + b.IsVariableBoundArray);
            Console.WriteLine("数组维数：" + b.GetArrayRank());

不过 GetElementType() 不能一次性拿到最初的元素类型，GetArrayRank 对交错数组也无效。

下面的方法可以快速解析值类型的交错数组。

        // 只能解析值类型、系统基础类型，例如 int 等
        public static (Type, int) Test(Type type)
        {
            if (!type.IsSZArray)
                return (type, 0);

            int num = 0;
            Type that = type;
            while (true)
            {
                that = that.GetElementType();
                num += 1;
                if (that.IsPrimitive)
                    break;
            }
            return (that, num);
        }

调用

            Type b = typeof(int[][][][]);
            var result = Test(b);
            Console.WriteLine("元素类型：" + result.Item1);
            Console.WriteLine("锯齿数：" + result.Item2);

复杂类型的交错数组，可以使用字符串处理。

2， 类型成员

通过第一章的操作，已经可以解析程序集的大纲图了，现在开始来获取类型内部的细节，构建更为清晰的信息。

解析类型结构，过程大致如下

2.1 类

一个类由以下一个或多个成员组成：

特性的话，在《C#反射与特性(七)：自定义特性以及应用》已经讲解了，这里不再赘述。

2.1.1 访问修饰符

public、private两个修饰符，判断起来十分简单；

C# 关键字 protected 和 internal 在 IL 中没有任何意义，且不会用于反射 API 中。也就是说在反射中看来，这两个访问修饰符没作用；不过对于获取信息来说，还是需要想办法解析。

protected、internal、protected internal 对于反射调用来说，是没有意义的，不过对于获取信息来说，还是需要想办法解析。

判断是否为 internal 可以使用 IsAssembly ；判断是否为 protected internal ，可以使用IsFamilyOrAssembly ；两个属性一起用，结果都是 false 的话，则是 protected。

注：protected internal、internal protected 是一样的。

下面方法可以判断并且返回访问修饰符名称

        public static string Visibility(FieldInfo field)
        {
            return
                field.IsPublic ? "public" :
                field.IsPrivate ? "private" :
                field.IsAssembly ? "internal" :
                field.IsFamily ? "protected" :
                field.IsFamilyOrAssembly ? "protected internal" :
                null;
        }

2.1.2 其它修饰符

readonly、static、const 三个修饰符，const 不能与其它修饰符同时存在。

下面的方法可以判断、返回相应的修饰符

        public static string Only(FieldInfo field)
        {
            if (field.IsLiteral)
                return "const";
            if (field.IsStatic && field.IsInitOnly)
                return "readonly static";
            if (field.IsStatic)
                return "static";
            if (field.IsInitOnly)
                return "readonly";

            return string.Empty;
        }

const int a; 使用 IsStatic 结果为 true，因为 const 也属于 static。

2.1.3 字段

通过 2.1.1 和 2.1.2 ，可以解析字段的信息了。

下面来测试一下。

定义一个类型

    public class MyClass
    {
        public int a;
        internal int b;
        protected int c;
        protected internal int d;
        private int e;
        public readonly static float f = 1;
    }

输出解析数据

            Type type = typeof(MyClass);
            FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.Static | BindingFlags.Instance);
            IEnumerable<FieldInfo> fields1 = type.GetRuntimeFields();
            foreach (var item in fields)
            {
                StringBuilder builder = new StringBuilder();
                builder.Append(GetVisibility(item) + " ");
                builder.Append(GetRead(item) + " ");
                builder.Append(item.FieldType.Name + " ");
                builder.Append(item.Name + " ;");
                Console.WriteLine(builder.ToString());
            }

因为反射的显示信息的话，主要是显示元数据，而且 {get;set;} 属性会自动生成私有字段，所以上面的代码会将这些也显示出来。将获取条件改成 BindingFlags.Public | BindingFlags.GetField | BindingFlags.Static | BindingFlags.Instance 。

2.1.4 方法、参数

排除属性的方法

当我们编写一个属性，编译时，编译器会生成对应的 get 和 set 方法，我们一般来说，只是需要显示程序员编写的方法，而非系统生成的。

系统生成的属性的方法，会带有一个 System.Runtime.CompilerServices.CompilerGeneratedAttribute 特性，通过此特性可以排除系统生成的方法。

        public static bool IsPropertyOfAttr(MethodInfo method)
        {
            return method.GetCustomAttributes().Any(x => x.GetType() == typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute));
        }

方法的访问修饰符

判断方法访问修饰符的代码如下

        public static string GetVisibility(MethodInfo method)
        {
            return
                method.IsPublic ? "public" :
                method.IsPrivate ? "private" :
                method.IsAssembly ? "internal" :
                method.IsFamily ? "protected" :
                method.IsFamilyOrAssembly ? "protected internal" :
                null;
        }

前面已经进行了相应的讲解，这里不在赘述。

重写与隐藏关键字

方法，可以有以下关键字修饰：virtual、override、abstract、new；

从继承关系上来说，分类上，一个方法可能是 virtual、abstract；然后继承后，重写 virtual 修饰的方法可能是 override 、 new；abstract 修饰的方法只能使用 override 。

以下属性可以区分修饰符：

IsAbstract、IsVirtual 、IsHideBySig，IsFinal。

virtual、override、abstract、new 修饰的方法，IsHideBySig 结果都是 true，可用此属性判断方法是否有抽象、重写等关键字修饰。

对于 virtual、override 修饰的方法，IsVirtual 为 true，new 修饰的方法 IsVirtual 为 flase。

但是一个方法，如果是实现了接口方法的话，使用 IsVirtual 也会返回 true，IsHideBySig 也会返回 true。

那么就剩下区分 virtual 、 override 了，如果当前方法是重写了父类的，使用MethodInfo.GetBaseDefinition() 可以返回当前方法的所重写父类的方法；如果没有重写，那么就返回方法本身。

IsVirtual 可以判断当前方法是否可以被重写。

但是但是，一个在当前类中定义的，类似 public string Test(){} 的方法，可以被重写，很容易被判断为 new。需要在最后做个判断。

当获取到一个 MethodInfo 时，要区分上面的修饰符，可以使用以下代码流程。

        // virtual override  abstract new
        public static string IsOver(Type type,MethodInfo method)
        {
            // 没有相应的信息，说明没有使用以上关键字修饰
            if (!method.IsHideBySig)
                return string.Empty;

            // 是否抽象方法
            if (method.IsAbstract)
                return "abstract";

            // virtual、override、实现接口的方法
            if (method.IsVirtual)
            {
                // 实现接口的方法
                if (method.IsFinal)
                    return string.Empty;
                // 没有被重写，则为 virtual
                if (method.Equals(method.GetBaseDefinition()))
                    return "virtual";
                else
                    return "override";
            }
            // new
            else
            {
                // 如果是当前类型中定义的方法，则只是一个普通的方法
                if (type == method.DeclaringType)
                    return string.Empty;

                return "new";
            }
        }

获取返回类型

可以从 ReturnParameter、ReturnType和 ReturnTypeCustomAttributes 获取有关返回类型的信息。

ReturnTypeCustomAttributes 是获取特性信息的，这里先不处理。

        // 获取返回类型
        public static string GetReturn(MethodInfo method)
        {
            Type returnType = method.ReturnType;
            ParameterInfo returnParam = method.ReturnParameter;

            if (returnType == typeof(void))
                return "void";
            if (returnType.IsValueType)
            {
                // 判断是否 (type1,type2) 这样的返回
                if (returnParam.ParameterType.IsGenericType)
                {
                    Type[] types = returnParam.ParameterType.GetGenericArguments();
                    string str = "(";
                    for (int i = 0; i < types.Length; i++)
                    {
                        str += types[i].Name;
                        if (i < types.Length - 1)
                            str += ",";
                    }
                    str += ")";
                    return str;
                }
                return returnType.Name;
            }

            // 这里暂不处理复杂的返回类型，例如数组,泛型等。
            return returnType.Name;
        }

method.ReturnType 和 method.ReturnParameter.ParameterType 是一样的。

一般使用 ReturnType 就行了，有些特殊的语法要使用 ReturnParameter 。

笔者暂时没有碰到有区分的使用场景。

是否异步方法

使用以下代码判断是否异步方法

        public static string GetAsync(MethodInfo info)
        {
            return info.GetCustomAttribute(typeof(AsyncStateMachineAttribute))==null?"":"async ";
        }

泛型方法

通过以下代码可以判断是否为泛型方法，并且返回名称。

        // 判断方法是否为泛型方法，并且返回泛型名称
        public static string GetMethodName(MethodInfo method)
        {
            if (!method.IsGenericMethod)
                return method.Name;
            Type[] types = method.GetGenericArguments();
            string str = method.Name + "<";
            for (int i = 0; i < types.Length; i++)
            {
                str += types[i].Name;
                if (i < types.Length - 1)
                    str += ",";
            }
            str += ">";
            return str;
        }

方法参数

步骤一：判断参数是否有 in、ref、out 修饰，如果是的话，类型名称后面会带有字符 & ；params 的话，会带有一个 ParamArrayAttribute 特性。

步骤二：获取参数类型；如果是 in、ref、out 修饰的话，类型名称后面会带有一个 &，需要去除；

步骤三：是否具有默认值，如果存在默认值的话，就返回默认值。

        // 解析方法的参数
        public static string GetParams(MethodInfo method)
        {
            ParameterInfo[] parameters = method.GetParameters();
            if (parameters.Length == 0)
                return string.Empty;

            int length = parameters.Length - 1;
            StringBuilder str = new StringBuilder();
            for (int i = 0; i <= length; i++)
            {
                str.Append(InRefOut(parameters[i]) + " ");
                // 这里不对复杂类型等做处理
                str.Append(GetParamType(parameters[i]) + " ");
                str.Append(parameters[i].Name);
                str.Append(HasValue(parameters[i]) + " ");
                if (i < length)
                    str.Append(",");
            }
            return str.ToString();
        }

        public static string InRefOut(ParameterInfo parameter)
        {
            // in、ref、out ，类型后面会带有 & 符号
            if (parameter.ParameterType.Name.EndsWith("&"))
            {
                return
                    parameter.IsIn ? "in" :
                    parameter.IsOut ? "out" :
                    "ref";
            }
            if (parameter.GetCustomAttributes().Any(x => x.GetType() == typeof(ParamArrayAttribute)))
                return "params";
            return string.Empty;
        }

        // 获取类型
        public static string GetParamType(ParameterInfo parameter)
        {
            string typeName = parameter.ParameterType.Name;
            if (typeName.EndsWith("&"))
                typeName = typeName.Substring(0, typeName.Length - 1);
            return typeName;
        }

        // 是否为可选参数，是否有默认值
        public static string HasValue(ParameterInfo parameter)
        {
            if (!parameter.IsOptional)
                return string.Empty;
            object value = parameter.DefaultValue;
            return " = " + value.ToString();
        }

学以致用

学习如何获取、解析方法的信息后，我们可以在这里实践一下。

定义以下类型，我们最终需要的是 MyClass。

    interface A
    {
        void TestA();
    }
    public abstract class B
    {
        public abstract void TestB();
    }
    public abstract class C : B
    {
        public virtual void TestC()
        {
        }
        public virtual void TestD()
        {
        }
    }
    public class MyClass : C, A
    {
        public void TestA()
        {
            throw new NotImplementedException();
        }

        public override void TestB()
        {
            throw new NotImplementedException();
        }
        public override void TestC()
        {
            base.TestC();
        }
        new public void TestD()
        {

        }
        public (bool, bool) TestE()
        {
            return (true, true);
        }
        public string TestF<T>(T t)
        {
            return t.GetType().Name;
        }
        public string TestG(in string a, ref string aa, out string b, string c = "666")
        {
            b = "666";
            return string.Empty;
        }
        public string TestH(params string[] d)
        {
            return string.Empty;
        }
    }

将 2.1.4 出现的解析方法，复制粘贴到项目中，使用以下代码即可解析出一个类中的方法。

            Type type = typeof(MyClass);
            MethodInfo[] methods = type.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly | BindingFlags.Instance);

            foreach (MethodInfo item in methods)
            {
                StringBuilder builder = new StringBuilder();
                builder.Append(GetVisibility(item) + " ");
                builder.Append(item.GetGetMethod(true).IsStatic ? "static " : string.Empty);
                builder.Append(IsOver(type, item) + " ");
                builder.Append(GetReturn(item) + " ");
                builder.Append(GetMethodName(item) + " ");
                builder.Append("(" + GetParams(item) + ")");
                Console.WriteLine(builder.ToString());
            }

这里不对泛型和数组等复杂类型进行解析，也不输出特性。

可以尝试将 MyClass 换成 List<> 等类型进行测试。

输出效果：

public  void TestA ()
public override void TestB ()
public override void TestC ()
public  void TestD ()
public  (Boolean,Boolean) TestE ()
public  String TestF<T> ( T t )
public  String TestG (in String a ,ref String aa ,out String b , String c = 666 )
public  String TestH (params String[] d )

完整代码已上传到码云，点击查看 解析方法与参数 。

2.1.5 构造函数

构造函数的话，没有返回类型，也没有重写，获取参数方法的部分，

因为有很多跟 2.1.4 重复的代码，因此这里不再赘述，代码已经上传到码云，可以参考 解析构造函数 。

2.1.6 属性

正常来说呢，这样写属性是可以的，但是过多的修饰符对属性来说是没意义的。

    public class MyClass
    {
        public int a { get; set; }
        internal int b { get; set; }
        protected int c { get; set; }
        protected internal int d { get; set; }
        private int e { get; set; }
        public  static float f { get; set; } = 1;
    }

PropertyInfo 没有像 FieldInfo 那么丰富的判断修饰符的属性。

但是呢，获取到属性的方法，则可以获取访问修饰符。

获取访问修饰符

跟获取方法的访问修饰符一样，稍微调整以下即可。

        public static string GetVisibility(PropertyInfo property)
        {
            MethodInfo method = property.GetGetMethod();
            return
                method.IsPublic ? "public" :
                method.IsPrivate ? "private" :
                method.IsAssembly ? "internal" :
                method.IsFamily ? "protected" :
                method.IsFamilyOrAssembly ? "protected internal" :
                null;
        }

获取重写关键字

            // virtual override  abstract new
            public static string IsOver(Type type, PropertyInfo property)
            {
                MethodInfo method = property.GetGetMethod(true);
                // 没有相应的信息，说明没有使用以上关键字修饰
                if (!method.IsHideBySig)
                    return string.Empty;

                // 是否抽象方法
                if (method.IsAbstract)
                    return "abstract";

                // virtual、override、实现接口的方法
                if (method.IsVirtual)
                {
                    // 实现接口的方法
                    if (method.IsFinal)
                        return string.Empty;
                    // 没有被重写，则为 virtual
                    if (method.Equals(method.GetBaseDefinition()))
                        return "virtual";
                    else
                        return "override";
                }
                // new
                else
                {
                    // 如果是当前类型中定义的方法，则只是一个普通的方法
                    if (type == method.DeclaringType)
                        return string.Empty;

                    return "new";
                }
            }

解析属性构造器

            // 解析属性的构造器
            public static string GetConstructor(PropertyInfo property)
            {
                string str = "{ ";
                if (property.CanRead)
                    str += "get; ";
                if (property.CanWrite)
                    str += "set; ";
                str += "}";
                return str;
            }

反射是无法直接拿到属性的默认值的，详细请参考 https://www.ojit.com/article/3058539。

以上，测试代码，可以到码云查看 解析属性

2.1.7 事件

本节沿用 2.1.4 中解析方法的所有函数。

定义委托和事件如下

    public delegate void DeTest();
    public abstract class A
    {
        public abstract event DeTest TestA;
    }
    public abstract class B : A
    {
        public virtual event DeTest TestB;
        public event DeTest TestC;
    }
    public class MyClass : B
    {
        public override event DeTest TestA;
        public override event DeTest TestB;
        new public event DeTest TestC;
    }

解析事件过程

            Type type = typeof(MyClass);
            EventInfo[] events = type.GetEvents(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly | BindingFlags.Instance);
            foreach (var item in events)
            {
                MethodInfo method = item.GetAddMethod();
                StringBuilder builder = new StringBuilder();
                builder.Append(GetVisibility(method) + " ");
                builder.Append(method.IsStatic ? "static " : string.Empty);
                builder.Append(IsOver(type, method) + " ");
                builder.Append("event ");
                builder.Append(item.EventHandlerType.Name + " ");
                builder.Append(item.Name + ";");
                Console.WriteLine(builder.ToString());
            }

解析过程是非常简单的。

2.1.8 索引器

我们定义一个类型和索引器如下

    public class MyClass
    {
        private string[] MyArray;
        public MyClass()
        {
            MyArray = new string[] { "a", "b", "c", "d", "e" };
        }
        // 这里不处理 search
        public string this[int index,string search]
        {
            get
            {
                return MyArray[index];
            }
            set
            {
                MyArray[index] = value;
            }
        }
    }

索引器在编译时，会生成属性和方法，所以使用反射获取属性时，会把索引器生成的属性包含在内。

构造器会自动生成一个 public string Item { get; set; } 的属性。

本节使用 2.1.6 中解析属性的代码。

将属性获取方法优化如下，会区分输出类型中的属性和构造器。

            Type type = typeof(MyClass);
            PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Instance);

            foreach (PropertyInfo item in properties)
            {
                StringBuilder builder = new StringBuilder();
                builder.Append(GetVisibility(item) + " ");
                builder.Append(item.GetGetMethod(true).IsStatic ? "static " : string.Empty);
                builder.Append(IsOver(type, item) + " ");
                builder.Append(item.PropertyType + " ");
                if (item.Name == "Item")
                {
                    builder.Append("this[");
                    ParameterInfo[] paras = item.GetIndexParameters();
                    int length = paras.Length - 1;
                    for (int i = 0; i <= length; i++)
                    {
                        builder.Append(paras[i].ParameterType.Name + " " + paras[i].Name);

                        if (i < length)
                            builder.Append(",");
                    }
                    builder.Append("]");
                }
                else
                {
                    builder.Append(item.Name + " ");
                    builder.Append(GetConstructor(item));
                }

                Console.WriteLine(builder.ToString());
            }

2.1.9 获取特性

类型、方法、属性、字段等，都可以使用特性修饰，我们要通过反射获取特性后，还要将特性结果还原出程序员写代码时设置的值。

代码如下

        /// <summary>
        /// 解析输出类型、方法、属性、字段等特性
        /// </summary>
        /// <param name="attrs"></param>
        /// <returns></returns>
        public static string[] GetAttrs(IList<CustomAttributeData> attrs)
        {
            List<string> attrResult = new List<string>(); ;
            foreach (var item in attrs)
            {
                Type attrType = item.GetType();
                string str = "[";
                str += item.AttributeType.Name;
                // 构造函数中的值
                IList<CustomAttributeTypedArgument> customs = item.ConstructorArguments;
                // 属性的值
                IList<CustomAttributeNamedArgument> arguments = item.NamedArguments;

                // 没有任何值
                if (customs.Count == 0 && arguments.Count == 0)
                {
                    attrResult.Add(str + "]");
                    continue;
                }
                str += "(";
                if (customs.Count != 0)
                {
                    str += string.Join(",", customs.ToArray());
                }
                if (customs.Count != 0 && arguments.Count != 0)
                    str += ",";

                if (arguments.Count != 0)
                {
                    str += string.Join(",", arguments.ToArray());
                }
                str += ")";
                attrResult.Add(str);
            }
            return attrResult.ToArray();
        }

调用：

            Type type = typeof(List<>);
            string[] list = GetAttrs(type.GetCustomAttributesData());
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }

调用时，将 Type 改成 MethodInfo 等。

输出：

[SerializableAttribute]
[DebuggerDisplayAttribute("Count = {Count}")
[NullableAttribute((Byte)0)
[DebuggerTypeProxyAttribute(typeof(System.Collections.Generic.ICollectionDebugView`1))
[NullableContextAttribute((Byte)1)
[DefaultMemberAttribute("Item")
[TypeForwardedFromAttribute("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")

2.2 委托

这里使用 2.1.4 中，解析方法的代码。

委托中，会有很多个方法，其中有个 invoke 方法，对应定义委托时的各种信息。

        /// <summary>
        /// 解析委托，包括嵌套类型中的委托
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public static string GetDelegateInfo(Type type)
        {
            if (!type.IsSubclassOf(typeof(Delegate)))
                return null;

            string str = "";
            MethodInfo method = type.GetMethod("Invoke");

            if (type.IsNested)
                str += GetVisibility(method);
            else
                str += (type.IsPublic ? "public" : "internal") + " ";
            str += type.IsSealed && type.IsAbstract ? "static " : string.Empty;
            str += "delegate ";
            str += GetReturn(method) + " ";
            str += type.Name;
            str += "(";
            str += GetParams(method);
            str += ")";

            return str;
        }

2.3 接口

上面已经解析类、抽象类、委托等，可以使用同样的方法解析接口，然后接着解析接口的属性、方法。

这里不再赘述。

2.4 可空类型

判断一个类型是否为可空类型时，可以先判断是否为泛型。

可空类型和泛型方法都可以使用 IsGenericType 属性判断。

GetGenericTypeDefinition 方法可以获取泛型未绑定参数的版本。

最后判断类型是否为 typeof(Nullable<>) ，即可完成整体解析。

        /// <summary>
        /// 获取可空类型名称
        /// </summary>
        /// <returns></returns>
        public static string GetAbleNullName(Type type)
        {
            if (!type.IsGenericType)
                return type.Name;

            if (type.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                Type nullType = type.GetGenericArguments().FirstOrDefault();
                return nullType.Name + "?";
            }
            return type.Name;
        }

C#反射与特性(九)：全网最全-解析反射