简介

主要是封装了一些反射的方法，使调用更加方便。下面介绍下这个类中的方法:

• GetClassName: 获取类的完全限定名。
• GetClassNamespace: 获取类的命名空间。
• GetClassHierarchy: 获取类的继承层次结构。
• GetClassMethods: 获取类的所有方法。
• GetClassProperties: 获取类的所有属性。
• GetClassFields: 获取类的所有字段。
• GetClassEvents: 获取类的所有事件。
• GetClassConstructors: 获取类的所有构造函数。
• GetDefaultClassConstructor: 获取类的默认构造函数。
• GetStaticPropertyValue: 获取类的静态属性的值。
• SetStaticPropertyValue: 设置类的静态属性的值。
• GetStaticFieldValue: 获取类的静态字段的值。
• SetStaticFieldValue: 设置类的静态字段的值。
• InvokeStaticMethod: 动态调用类的静态方法。
• InvokeMethod: 动态调用类的实例方法。
• CreateInstance: 动态创建类的实例。
• GetParameterTypes: 获取构造函数参数类型的数组。

EasyTool. 类

静态工具类 ，提供了许多基于反射机制的有用方法，可以帮助开发人员方便地获取和操作 C# 类的信息和属性。这些方法包括获取类的完全限定名、命名空间、继承层次结构、所有方法、所有属性、所有字段、所有事件、所有构造函数和默认构造函数等信息，以及获取和设置类的静态属性和字段的值，动态调用类的静态和实例方法，动态创建类的实例等。这些方法可以极大地简化 C# 类的处理和操作，提高代码的可读性和可维护性。

GetClassName-获取类的完全限定名

/// <summary>
/// 获取类的完全限定名
/// </summary>
/// <param name="type">要获取名称的类</param>
/// <returns>类的完全限定名</returns>
public static string GetClassName(Type type)

GetClassNamespace-获取类的命名空间

/// <summary>
/// 获取类的命名空间
/// </summary>
/// <param name="type">要获取命名空间的类</param>
/// <returns>类的命名空间</returns>
public static string GetClassNamespace(Type type)

GetClassHierarchy-获取类的继承层次结构

/// <summary>
/// 获取类的继承层次结构
/// </summary>
/// <param name="type">要获取继承层次结构的类</param>
/// <returns>类的继承层次结构</returns>
public static Type[] GetClassHierarchy(Type type)

GetClassMethods-要获取方法的类

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

GetClassProperties-要获取属性的类

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

GetClassFields-要获取字段的类

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

GetClassEvents-获取类的所有事件

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

GetClassConstructors-要获取构造函数的类

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

GetDefaultClassConstructor-要获取默认构造函数的类

/// <summary>
/// 获取类的默认构造函数
/// </summary>
/// <param name="type">要获取默认构造函数的类</param>
/// <returns>类的默认构造函数</returns>
public static ConstructorInfo GetDefaultClassConstructor(Type type)

GetStaticPropertyValue-获取类的静态属性的值

/// <summary>
/// 获取类的静态属性的值
/// </summary>
/// <param name="type">要获取静态属性的类</param>
/// <param name="propertyName">要获取的静态属性的名称</param>
/// <returns>静态属性的值</returns>
public static object GetStaticPropertyValue(Type type, string propertyName)

SetStaticPropertyValue-设置类的静态属性的值

/// <summary>
/// 设置类的静态属性的值
/// </summary>
/// <param name="type">要设置静态属性的类</param>
/// <param name="propertyName">要设置的静态属性的名称</param>
/// <param name="value">要设置的静态属性的值</param>
public static void SetStaticPropertyValue(Type type, string propertyName, object value)

GetStaticFieldValue-获取类的静态字段的值

/// <summary>
/// 获取类的静态字段的值
/// </summary>
/// <param name="type">要获取静态字段的类</param>
/// <param name="fieldName">要获取的静态字段的名称</param>
/// <returns>静态字段的值</returns>
public static object GetStaticFieldValue(Type type, string fieldName)

SetStaticFieldValue-设置类的静态字段的值

/// <summary>
/// 设置类的静态字段的值
/// </summary>
/// <param name="type">要设置静态字段的类</param>
/// <param name="fieldName">要设置的静态字段的名称</param>
/// <param name="value">要设置的静态字段的值</param>
public static void SetStaticFieldValue(Type type, string fieldName, object value)

InvokeStaticMethod-动态调用类的静态方法

/// <summary>
/// 动态调用类的静态方法
/// </summary>
/// <param name="type">要调用静态方法的类</param>
/// <param name="methodName">要调用的静态方法的名称</param>
/// <param name="arguments">要传递给静态方法的参数</param>
/// <returns>静态方法的返回值</returns>
public static object InvokeStaticMethod(Type type, string methodName, object[] arguments)

InvokeMethod-动态调用类的实例方法

/// <summary>
/// 动态调用类的实例方法
/// </summary>
/// <param name="instance">要调用实例方法的类实例</param>
/// <param name="methodName">要调用的实例方法的名称</param>
/// <param name="arguments">要传递给实例方法的参数</param>
/// <returns>实例方法的返回值</returns>
public static object InvokeMethod(object instance, string methodName, object[] arguments)

CreateInstance-要创建实例的类

/// <summary>
/// 动态创建类的实例
/// </summary>
/// <param name="type">要创建实例的类</param>
/// <param name="constructorArguments">要传递给构造函数的参数</param>
/// <returns>类的新实例</returns>
public static object CreateInstance(Type type, object[] constructorArguments)

GetParameterTypes-获取构造函数参数类型的数组

/// <summary>
/// 获取构造函数参数类型的数组
/// </summary>
/// <param name="parameters">要获取参数类型的参数数组</param>
/// <returns>参数类型的数组</returns>
private static Type[] GetParameterTypes(object[] parameters)

使用示例

以下代码演示了如何使用 ClassUtil 工具类获取和操作 C# 类的信息和属性。它创建了一个名为 MyClass 的类，该类包含一个实例方法 Add 和一个静态方法 SayHello，以及一个名为 Name 的属性和一个名为 MyStaticField 的静态字段。然后，它使用 ClassUtil 工具类的各种方法获取和操作 MyClass 类的信息和属性，包括获取类的完全限定名、命名空间、继承层次结构、所有方法、所有属性、所有字段、所有事件、所有构造函数和默认构造函数等信息，获取和设置类的静态属性和字段的值，动态调用类的静态和实例方法，动态创建类的实例等。这些方法基于反射机制实现，可以让您方便地处理和操作各种 C# 类。

using System;

public class MyClass
{
    public string Name { get; set; }
    
    public int Add(int x, int y)
    {
        return x + y;
    }
    
    public static string SayHello(string name)
    {
        return $"Hello, {name}!";
    }
}

public class Program
{
    public static void Main()
    {
        Type myClassType = typeof(MyClass);
        
        // 获取类的完全限定名
        string className = ClassUtil.GetClassName(myClassType);
        Console.WriteLine("Class name: " + className);
        
        // 获取类的命名空间
        string classNamespace = ClassUtil.GetClassNamespace(myClassType);
        Console.WriteLine("Class namespace: " + classNamespace);
        
        // 获取类的继承层次结构
        Type[] classHierarchy = ClassUtil.GetClassHierarchy(myClassType);
        Console.WriteLine("Class hierarchy:");
        foreach (Type type in classHierarchy)
        {
            Console.WriteLine("  " + type.FullName);
        }
        
        // 获取类的所有方法
        MethodInfo[] classMethods = ClassUtil.GetClassMethods(myClassType);
        Console.WriteLine("Class methods:");
        foreach (MethodInfo method in classMethods)
        {
            Console.WriteLine("  " + method.Name);
        }
        
        // 获取类的所有属性
        PropertyInfo[] classProperties = ClassUtil.GetClassProperties(myClassType);
        Console.WriteLine("Class properties:");
        foreach (PropertyInfo property in classProperties)
        {
            Console.WriteLine("  " + property.Name);
        }
        
        // 获取类的所有字段
        FieldInfo[] classFields = ClassUtil.GetClassFields(myClassType);
        Console.WriteLine("Class fields:");
        foreach (FieldInfo field in classFields)
        {
            Console.WriteLine("  " + field.Name);
        }
        
        // 获取类的所有事件
        EventInfo[] classEvents = ClassUtil.GetClassEvents(myClassType);
        Console.WriteLine("Class events:");
        foreach (EventInfo eventInfo in classEvents)
        {
            Console.WriteLine("  " + eventInfo.Name);
        }
        
        // 获取类的所有构造函数
        ConstructorInfo[] classConstructors = ClassUtil.GetClassConstructors(myClassType);
        Console.WriteLine("Class constructors:");
        foreach (ConstructorInfo constructor in classConstructors)
        {
            Console.WriteLine("  " + constructor.Name);
        }
        
        // 获取类的默认构造函数
        ConstructorInfo defaultConstructor = ClassUtil.GetDefaultClassConstructor(myClassType);
        Console.WriteLine("Default constructor: " + defaultConstructor.Name);
        
        // 获取类的静态属性的值
        string name = (string) ClassUtil.GetStaticPropertyValue(myClassType, "Name");
        Console.WriteLine("Static property value: " + name);
        
        // 设置类的静态属性的值
        ClassUtil.SetStaticPropertyValue(myClassType, "Name", "John");
        name = (string) ClassUtil.GetStaticPropertyValue(myClassType, "Name");
        Console.WriteLine("Static property value: " + name);
        
        // 获取类的静态字段的值
        object fieldValue = ClassUtil.GetStaticFieldValue(myClassType, "MyStaticField");
        Console.WriteLine("Static field value: " + fieldValue);
        
        // 设置类的静态字段的值
        ClassUtil.SetStaticFieldValue(myClassType, "MyStaticField", 123);
        fieldValue = ClassUtil.GetStaticFieldValue(myClassType, "MyStaticField");
        Console.WriteLine("Static field value:" + fieldValue);

        // 动态调用类的静态方法
        object result = ClassUtil.InvokeStaticMethod(myClassType, "SayHello",   new object[] { "Jack" });
        Console.WriteLine("Static method result: " + result);

        // 动态创建类的实例
        object instance = ClassUtil.CreateInstance(myClassType, new object[]    { });
        MyClass myClass = (MyClass) instance;

        // 动态调用实例方法
        int sum = (int) ClassUtil.InvokeMethod(myClass, "Add", new object[] {   2, 3 });
        Console.WriteLine("Instance method result: " + sum);
}

输出结果

Class name: MyClass
Class namespace: 
Class hierarchy:
  MyClass
  System.Object
Class methods:
  Add
  SayHello
  ToString
  Equals
  GetHashCode
  GetType
  .ctor
Class properties:
  Name
Class fields:
  MyStaticField
Class events:
Class constructors:
  .ctor
  .ctor
  .ctor
Default constructor: .ctor
Static property value: 
Static property value: John
Static field value: 
Static field value: 123
Static method result: Hello, Jack!
Instance method result: 5

参考资料

• C# 反射入门 (opens new window)
• 反射（C# 编程指南） (opens new window)
• C# 反射基础教程 (opens new window)
• C# 反射详解 (opens new window)
• C# 反射：自定义反射工具类 (opens new window)