简介

TypeUtil工具类可以帮助开发者更方便地进行类型操作和转换，提高开发效率和代码可读性。

方法简要说明：

• IsNullable<T>()：判断类型是否是可空类型。
• IsEnum<T>()：判断类型是否是枚举类型。
• GetGenericArguments<T>()：获取泛型类型的参数类型。
• GetProperties<T>()：获取类型的所有属性。
• GetFields<T>()：获取类型的所有字段。
• GetMethods<T>()：获取类型的所有方法。
• GetEvents<T>()：获取类型的所有事件。
• GetMembers<T>()：获取类型的所有成员。
• GetConstructors<T>()：获取类型的所有构造函数。
• ImplementsInterface<T, TInterface>()：判断类型是否实现了指定的接口。
• InheritsFrom<T, TBase>()：判断类型是否继承了指定的基类。
• CreateInstance<T>()：创建指定类型的实例。
• CreateInstance<T>(params object[] args)：创建指定类型的实例（带参数）。
• GetEnumValues<T>()：获取枚举类型的所有值。
• ConvertFromString<T>(string value)：将字符串转换为指定类型的值。
• ConvertToString<T>(T value)：将值转换为指定类型的字符串。

EasyTool.TypeUtil 类

静态工具类 TypeUtil，是一个大而全的泛型类型工具类，包含了常见的类型判断、属性、字段、方法、事件、构造函数等类型操作和转换。这个工具类可以帮助开发者更方便地进行类型相关的操作和转换，提高开发效率和代码可读性。

具体来说，TypeUtil提供的功能包括：

• 判断类型是否是可空类型。
• 判断类型是否是枚举类型。
• 获取泛型类型的参数类型。
• 获取类型的所有属性、字段、方法、事件、构造函数等成员。
• 判断类型是否实现了指定的接口。
• 判断类型是否继承了指定的基类。
• 创建指定类型的实例。
• 获取枚举类型的所有值。
• 将字符串转换为指定类型的值。
• 将值转换为指定类型的字符串。

开发者可以根据具体需求选择适合的方法来完成相应的类型操作和转换。

IsNullable-判断类型是否是可空类型

/// <summary>
/// 判断类型是否是可空类型
/// </summary>
/// <typeparam name="T">要判断的类型</typeparam>
/// <returns>是否是可空类型</returns>
public static bool IsNullable<T>() where T : struct

IsEnum-判断类型是否是枚举类型

/// <summary>
/// 判断类型是否是枚举类型
/// </summary>
/// <typeparam name="T">要判断的类型</typeparam>
/// <returns>是否是枚举类型</returns>
public static bool IsEnum<T>()

GetGenericArguments-获取泛型类型的参数类型

/// <summary>
/// 获取泛型类型的参数类型
/// </summary>
/// <typeparam name="T">要获取参数类型的泛型类型</typeparam>
/// <returns>泛型类型的参数类型数组</returns>
public static Type[] GetGenericArguments<T>()

GetProperties-获取类型的所有属性

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

GetFields-获取类型的所有字段

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

GetMethods-获取类型的所有方法

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

GetEvents-获取类型的所有事件

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

GetMembers-获取类型的所有属性、字段、方法和事件

/// <summary>
/// 获取类型的所有属性、字段、方法和事件
/// </summary>
/// <typeparam name="T">要获取成员的类型</typeparam>
/// <returns>成员数组</returns>
public static MemberInfo[] GetMembers<T>()

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

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

ImplementsInterface-判断类型是否实现了指定的接口

/// <summary>
/// 判断类型是否实现了指定的接口
/// </summary>
/// <typeparam name="T">要判断的类型</typeparam>
/// <typeparam name="TInterface">要判断的接口类型</typeparam>
/// <returns>是否实现了指定的接口</returns>
public static bool ImplementsInterface<T, TInterface>()

InheritsFrom-判断类型是否继承了指定的基类

/// <summary>
/// 判断类型是否继承了指定的基类
/// </summary>
/// <typeparam name="T">要判断的类型</typeparam>
/// <typeparam name="TBase">要判断的基类类型</typeparam>
/// <returns>是否继承了指定的基类</returns>
public static bool InheritsFrom<T, TBase>()

CreateInstance-创建指定类型的实例

/// <summary>
/// 创建指定类型的实例
/// </summary>
/// <typeparam name="T">要创建实例的类型</typeparam>
/// <returns>类型的实例</returns>
public static T CreateInstance<T>()

/// <summary>
/// 创建指定类型的实例
/// </summary>
/// <typeparam name="T">要创建实例的类型</typeparam>
/// <param name="args">构造函数的参数</param>
/// <returns>类型的实例</returns>
public static T CreateInstance<T>(params object[] args)

GetEnumValues-获取枚举类型的所有值

/// <summary>
/// 获取枚举类型的所有值
/// </summary>
/// <typeparam name="T">枚举类型</typeparam>
/// <returns>枚举类型的所有值</returns>
public static IEnumerable<T> GetEnumValues<T>()

ConvertFromString-将字符串转换为指定类型的值

/// <summary>
/// 将字符串转换为指定类型的值
/// </summary>
/// <typeparam name="T">要转换的类型</typeparam>
/// <param name="value">要转换的字符串</param>
/// <returns>转换后的值</returns>
public static T ConvertFromString<T>(string value)

ConvertToString-将值转换为指定类型的字符串

/// <summary>
/// 将值转换为指定类型的字符串
/// </summary>
/// <typeparam name="T">要转换的类型</typeparam>
/// <param name="value">要转换的值</param>
/// <returns>转换后的字符串</returns>
public static string ConvertToString<T>(T value)

使用示例

以下是一个大而全的泛型类型工具类TypeUtil的C#源码和使用示例。这个工具类包含了常见的类型判断、属性、字段、方法、事件、构造函数等类型操作和转换，可以帮助开发者更方便地操作和处理类型相关的问题。

// 判断类型是否是可空类型
bool isNullable = TypeUtil.IsNullable<int?>(); // true

// 判断类型是否是枚举类型
bool isEnum = TypeUtil.IsEnum<MyEnum>(); // true

// 获取泛型类型的参数类型
Type[] genericArguments = TypeUtil.GetGenericArguments<List<int>>();

// 获取类型的所有属性
PropertyInfo[] properties = TypeUtil.GetProperties<MyClass>();

// 获取类型的所有字段
FieldInfo[] fields = TypeUtil.GetFields<MyClass>();

// 获取类型的所有方法
MethodInfo[] methods = TypeUtil.GetMethods<MyClass>();

// 获取类型的所有事件
EventInfo[] events = TypeUtil.GetEvents<MyClass>();

// 获取类型的所有成员
MemberInfo[] members = TypeUtil.GetMembers<MyClass>();

// 获取类型的所有构造函数
ConstructorInfo[] constructors = TypeUtil.GetConstructors<MyClass>();

// 判断类型是否实现了指定的接口
bool implementsInterface = TypeUtil.ImplementsInterface<MyClass, IDisposable>(); // true

// 判断类型是否继承了指定的基类
bool inheritsFrom = TypeUtil.InheritsFrom<MyClass, MyBaseClass>(); // true

// 创建类型的实例
MyClass instance = TypeUtil.CreateInstance<MyClass>();

// 创建类型的实例（带参数）
MyClass instanceWithArgs = TypeUtil.CreateInstance<MyClass>("param1", "param2");

// 获取枚举类型的所有值
IEnumerable<MyEnum> enumValues = TypeUtil.GetEnumValues<MyEnum>();

// 将字符串转换为指定类型的值
int intValue = TypeUtil.ConvertFromString<int>("123");

// 将值转换为指定类型的字符串
string stringValue = TypeUtil.ConvertToString(123); // "123"

// 示例类
public class MyClass : MyBaseClass, IDisposable
{
    public string MyProperty { get; set; }
    public int MyField;
    public void MyMethod() { }
    public event EventHandler MyEvent;
    public void Dispose() { }
    public MyClass() { }
    public MyClass(string param1, string param2) { }
}

// 示例枚举
public enum MyEnum
{
    Value1,
    Value2,
    Value3
}

// 示例基类
public class MyBaseClass
{
    public void MyBaseMethod() { }
}