简介

C#的反射机制，可以让语言变得更加灵活，对对象的操作也更加“动态”，因此在某些情况下，反射可以做到事半功倍的效果。`EasyTool`针对C#的反射机制做了工具化封装，封装包括：

基本操作

• GetType：根据类型名称获取Type对象。
• GetTypes：获取指定程序集中的所有类型。
• GetAssembly：获取指定类型所在的程序集。
• GetAttribute：获取指定类型的指定类型的特性。
• GetAttributes：获取指定类型的指定类型的特性数组。
• GetDefaultValue：获取指定类型的默认值。

类型操作

• GetBaseType：获取类型的基类。
• HasInterface：判断类型是否实现了某个接口。
• GetParameters：获取方法的参数信息。
• GetConstructors：获取类型的所有构造函数。
• GetProperties：获取类型的所有属性。
• GetFields：获取类型的所有字段。
• GetMethods：获取类型的所有方法。
• GetEvents：获取类型的所有事件。
• GetInterfaces：获取类型的所有接口。
• GetPropertyNames：获取类型的所有属性名。
• GetFieldNames：获取类型的所有字段名。
• GetMethodNames：获取类型的所有方法名。
• GetEventNames：获取类型的所有事件名。
• GetInterfaceNames：获取类型的所有接口名。

实例化与调用

• CreateInstance：创建类型的实例。
• InvokeGenericMethod：调用泛型方法。

EasyTool.ReflectUtil 类

静态工具类 ReflectUtil，封装了常用反射操作的工具类。它提供了一系列静态方法，可以方便地获取类型信息、实例化对象、调用方法等。ReflectUtil的功能包括但不限于：

• 根据类型名称获取Type对象。
• 获取指定程序集中的所有类型。
• 获取指定类型所在的程序集。
• 获取指定类型的指定类型的特性。
• 获取指定类型的指定类型的特性数组。
• 获取指定类型的默认值。
• 获取类型的基类。
• 判断类型是否实现了某个接口。
• 获取方法的参数信息。
• 获取类型的所有构造函数、属性、字段、方法、事件和接口。
• 获取类型的所有属性名、字段名、方法名、事件名和接口名。
• 创建类型的实例。
• 调用泛型方法。

使用ReflectUtil可以避免在代码中大量使用反射操作的代码，提高了代码的可读性和可维护性。

GetType-根据类型名称获取Type对象

/// <summary>
/// 根据类型名称获取Type对象
/// </summary>
/// <param name="typeName">类型名称</param>
/// <returns>Type对象</returns>
public static Type GetType(string typeName)

/// <summary>
/// 获取指定程序集中的所有类型
/// </summary>
/// <param name="assembly">程序集</param>
/// <returns>类型数组</returns>
public static Type[] GetTypes(Assembly assembly)

GetAssembly-获取指定类型所在的程序集

/// <summary>
/// 获取指定类型所在的程序集
/// </summary>
/// <param name="type">类型</param>
/// <returns>程序集</returns>
public static Assembly GetAssembly(Type type)

GetAttribute-获取指定类型的指定类型的特性

/// <summary>
/// 获取指定类型的指定类型的特性
/// </summary>
/// <typeparam name="T">特性类型</typeparam>
/// <param name="type">类型</param>
/// <returns>特性对象</returns>
public static T GetAttribute<T>(Type type) where T : Attribute

GetAttributes-获取指定类型的指定类型的特性数组

/// <summary>
/// 获取指定类型的指定类型的特性数组
/// </summary>
/// <typeparam name="T">特性类型</typeparam>
/// <param name="type">类型</param>
/// <returns>特性数组</returns>
public static T[] GetAttributes<T>(Type type) where T : Attribute

GetDefaultValue-获取指定类型的默认值

/// <summary>
/// 获取指定类型的默认值
/// </summary>
/// <param name="type">类型</param>
/// <returns>默认值</returns>
public static object GetDefaultValue(Type type)

GetBaseType-获取类型的基类

/// <summary>
/// 获取类型的基类
/// </summary>
/// <param name="type">类型</param>
/// <returns>基类</returns>
public static Type GetBaseType(Type type)

HasInterface-判断类型是否实现了某个接口

/// <summary>
/// 判断类型是否实现了某个接口
/// </summary>
/// <param name="type">类型</param>
/// <param name="interfaceType">接口类型</param>
/// <returns>是否实现</returns>
public static bool HasInterface(Type type, Type interfaceType)

GetParameters-获取方法的参数信息

/// <summary>
/// 获取方法的参数信息
/// </summary>
/// <param name="method">方法</param>
/// <returns>参数信息数组</returns>
public static ParameterInfo[] GetParameters(MethodInfo method)

ConstructorInfo-获取类型的所有构造函数

/// <summary>
/// 获取类型的所有构造函数
/// </summary>
/// <param name="type">类型</param>
/// <returns>构造函数数组</returns>
public static ConstructorInfo[] GetConstructors(Type type)

GetProperties-获取类型的所有属性

/// <summary>
/// 获取类型的所有属性
/// </summary>
/// <param name="type">类型</param>
/// <returns>属性数组</returns>
public static PropertyInfo[] GetProperties(Type type)

GetFields-获取类型的所有字段

/// <summary>
/// 获取类型的所有字段
/// </summary>
/// <param name="type">类型</param>
/// <returns>字段数组</returns>
public static FieldInfo[] GetFields(Type type)

GetMethods-获取类型的所有方法

/// <summary>
/// 获取类型的所有方法
/// </summary>
/// <param name="type">类型</param>
/// <returns>方法数组</returns>
public static MethodInfo[] GetMethods(Type type)

GetEvents-获取类型的所有事件

/// <summary>
/// 获取类型的所有事件
/// </summary>
/// <param name="type">类型</param>
/// <returns>事件数组</returns>
public static EventInfo[] GetEvents(Type type)

GetInterfaces-获取类型的所有接口

/// <summary>
/// 获取类型的所有接口
/// </summary>
/// <param name="type">类型</param>
/// <returns>接口数组</returns>
public static Type[] GetInterfaces(Type type)

GetPropertyNames-获取类型的所有属性名

/// <summary>
/// 获取类型的所有属性名
/// </summary>
/// <param name="type">类型</param>
/// <returns>属性名数组</returns>
public static string[] GetPropertyNames(Type type)

GetFieldNames-获取类型的所有字段名

/// <summary>
/// 获取类型的所有字段名
/// </summary>
/// <param name="type">类型</param>
/// <returns>字段名数组</returns>
public static string[] GetFieldNames(Type type)

GetMethodNames-获取类型的所有方法名

/// <summary>
/// 获取类型的所有方法名
/// </summary>
/// <param name="type">类型</param>
/// <returns>方法名数组</returns>
public static string[] GetMethodNames(Type type)

GetEventNames-获取类型的所有事件名

/// <summary>
/// 获取类型的所有事件名
/// </summary>
/// <param name="type">类型</param>
/// <returns>事件名数组</returns>
public static string[] GetEventNames(Type type)

GetInterfaceNames-获取类型的所有接口名

/// <summary>
/// 获取类型的所有接口名
/// </summary>
/// <param name="type">类型</param>
/// <returns>接口名数组</returns>
public static string[] GetInterfaceNames(Type type)

CreateInstance-创建类型的实例

/// <summary>
/// 创建类型的实例
/// </summary>
/// <param name="type">类型</param>
/// <param name="args">构造函数参数</param>
/// <returns>实例</returns>
public static object CreateInstance(Type type, params object[] args)

InvokeGenericMethod-调用泛型方法

/// <summary>
/// 调用泛型方法
/// </summary>
/// <param name="obj">调用方法的对象</param>
/// <param name="methodName">方法名</param>
/// <param name="genericType">泛型参数类型</param>
/// <param name="args">方法参数</param>
/// <returns>方法返回值</returns>
public static object InvokeGenericMethod(object obj, string methodName, Type genericType, params object[] args)

使用示例

using System;

public class Person
{
    public string Name { get; set; }
    private int age;

    public Person(string name, int age)
    {
        this.Name = name;
        this.age = age;
    }

    public void SayHello()
    {
        Console.WriteLine($"Hello, my name is {Name}.");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        // 根据类型名称获取Type对象
        Type personType = ReflectUtil.GetType("Person");
        Console.WriteLine(personType); // 输出 "Person"

        // 获取指定程序集中的所有类型
        Type[] types = ReflectUtil.GetTypes(typeof(Program).Assembly);
        foreach (Type type in types)
        {
            Console.WriteLine(type);
        }

        // 获取指定类型所在的程序集
        Assembly assembly = ReflectUtil.GetAssembly(personType);
        Console.WriteLine(assembly.FullName);

        // 获取指定类型的指定类型的特性
        SerializableAttribute attribute = ReflectUtil.GetAttribute<SerializableAttribute>(personType);
        Console.WriteLine(attribute); // 输出 "System.SerializableAttribute"

        // 获取指定类型的指定类型的特性数组
        Attribute[] attributes = ReflectUtil.GetAttributes<Attribute>(personType);
        foreach (Attribute attr in attributes)
        {
            Console.WriteLine(attr);
        }

        // 获取指定类型的默认值
        object defaultValue = ReflectUtil.GetDefaultValue(personType);
        Console.WriteLine(defaultValue); // 输出 "null"

        // 获取类型的基类
        Type baseType = ReflectUtil.GetBaseType(personType);
        Console.WriteLine(baseType); // 输出 "System.Object"

        // 判断类型是否实现了某个接口
        bool hasInterface = ReflectUtil.HasInterface(personType, typeof(IDisposable));
        Console.WriteLine(hasInterface); // 输出 "False"

        // 获取方法的参数信息
        MethodInfo method = personType.GetMethod("SayHello");
        ParameterInfo[] parameters = ReflectUtil.GetParameters(method);
        foreach (ParameterInfo parameter in parameters)
        {
            Console.WriteLine($"{parameter.Name}: {parameter.ParameterType}");
        }

        // 获取类型的所有构造函数、属性、字段、方法、事件和接口
        ConstructorInfo[] constructors = ReflectUtil.GetConstructors(personType);
        PropertyInfo[] properties = ReflectUtil.GetProperties(personType);
        FieldInfo[] fields = ReflectUtil.GetFields(personType);
        MethodInfo[] methods = ReflectUtil.GetMethods(personType);
        EventInfo[] events = ReflectUtil.GetEvents(personType);
        Type[] interfaces = ReflectUtil.GetInterfaces(personType);

        // 获取类型的所有属性名、字段名、方法名、事件名和接口名
        string[] propertyNames = ReflectUtil.GetPropertyNames(personType);
        string[] fieldNames = ReflectUtil.GetFieldNames(personType);
        string[] methodNames = ReflectUtil.GetMethodNames(personType);
        string[] eventNames = ReflectUtil.GetEventNames(personType);
        string[] interfaceNames = ReflectUtil.GetInterfaceNames(personType);

        // 创建类型的实例
        object person = ReflectUtil.CreateInstance(personType, "Alice", 25);
        Console.WriteLine(person.GetType()); // 输出 "Person"

        // 调用泛型方法
        object[] argsArray = new object[] { 1, 2, 3 };
        object result = ReflectUtil.InvokeGenericMethod(new List<int>(), "AddRange", typeof(int), argsArray);
    }
}