JiShe.CollectBus/modules/JiShe.CollectBus.Kafka/Internal/ReflectionHelper.cs

using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace JiShe.CollectBus.Kafka.Internal
{
    /// <summary>
    /// 反射辅助类
    /// </summary>
    public static class ReflectionHelper
    {
        /// <summary>
        ///集合类型
        ///Item1：参数类型
        ///Item2：集合元素类型
        /// </summary>
        public static Tuple<Type,Type?> GetParameterTypeInfo(this MethodInfo method, int parameterIndex=0)
        {
            // 参数校验
            if (method == null) throw new ArgumentNullException(nameof(method));
            var parameters = method.GetParameters();
            if (parameterIndex < 0 || parameterIndex >= parameters.Length)
                throw new ArgumentOutOfRangeException(nameof(parameterIndex));

            ParameterInfo param = parameters[parameterIndex];
            Type paramType = param.ParameterType;
            Type? elementType = null;

            // 判断是否是集合类型（排除字符串）
            if (paramType != typeof(string) && IsEnumerableType(paramType))
            {
                elementType = GetEnumerableElementType(paramType);
            }

            return Tuple.Create(paramType, elementType);        
            
        }

        /// <summary>
        /// 判断是否是集合类型（排除字符串）
        /// </summary>
        public static bool IsEnumerableType(this Type type)
        {
            return type.IsArray
                || (type.IsGenericType && type.GetInterfaces()
                    .Any(t => t.IsGenericType
                           && t.GetGenericTypeDefinition() == typeof(IEnumerable<>)))
                || type.GetInterfaces().Any(t => t == typeof(System.Collections.IEnumerable));
        }

        /// <summary>
        /// 获取集合元素的类型
        /// </summary>
        public static Type? GetEnumerableElementType(this Type type)
        {
            // 处理数组类型
            if (type.IsArray)
                return type.GetElementType();

            // 处理直接实现IEnumerable<T>的类型（如IEnumerable<int>本身）
            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>))
                return type.GetGenericArguments()[0];

            // 处理通过接口实现IEnumerable<T>的泛型集合（如List<T>）
            var genericEnumerable = type.GetInterfaces()
                .FirstOrDefault(t => t.IsGenericType
                                  && t.GetGenericTypeDefinition() == typeof(IEnumerable<>));
            if (genericEnumerable != null)
                return genericEnumerable.GetGenericArguments()[0];

            // 处理非泛型集合类型（如 ArrayList）
            if (typeof(IEnumerable).IsAssignableFrom(type) && type == typeof(ArrayList))
                return typeof(ArrayList); 
            // 返回null表示无法确定元素类型
            return null;
        }


        // <summary>
        /// 判断是否使用强转换
        /// </summary>
        /// <param name="targetType">目标类型</param>
        /// <returns></returns>
        public static bool IsConvertType(this Type targetType)
        {
            // 处理可空类型
            Type underlyingType = Nullable.GetUnderlyingType(targetType) ?? targetType;
            // 情况1：值类型或基元类型（如 int、DateTime）
            if (underlyingType.IsValueType || underlyingType.IsPrimitive)
                return true;
            // 情况2：字符串类型直接赋值
            else if (underlyingType == typeof(string))
                return true;
            
            // 情况3：枚举类型处理
            //else if (underlyingType.IsEnum)
            //{
            //    if (Enum.IsDefined(underlyingType, msg))
            //    {
            //        convertedValue = Enum.Parse(underlyingType, msg.ToString());
            //        return true;
            //    }
            //    return false;
            //}
            return false;
        }
    }
}