数据的一些转化方法

namespace ArtProjectManagementService
{
    /// <summary>
    /// 自定义扩展方法
    /// </summary>
    public static class ExtensionMethods
    {
        public static bool IsNullOrEmpty(this string? str)
        {
            return string.IsNullOrEmpty(str);
        }

        /// <summary>
        /// 时间转时间戳,默认精确到秒
        /// </summary>
        /// <param name="time">DateTime</param>
        /// <returns></returns>
        public static long ToUnixTimeSeconds(this DateTime time)
        {
            return new DateTimeOffset(time).ToUnixTimeSeconds();
        }

        /// <summary>
        /// 时间转时间戳,默认精确到毫秒
        /// </summary>
        /// <param name="time">DateTime</param>
        /// <returns></returns>
        public static long ToUnixTimeMilliseconds(this DateTime time)
        {
            return new DateTimeOffset(time).ToUnixTimeMilliseconds();
        }

        /// <summary>
        /// 时间戳转时间,精确到秒
        /// </summary>
        /// <param name="unix">时间戳</param>
        /// <returns></returns>
        public static DateTime? FromUnixTimeSeconds(this long unix)
        {
            return DateTimeOffset.FromUnixTimeSeconds(unix).ToLocalTime().DateTime;
        }

        /// <summary>
        /// 时间戳转时间,精确到毫秒
        /// </summary>
        /// <param name="unix">时间戳</param>
        /// <returns></returns>
        public static DateTime? FromUnixTimeMilliseconds(this long unix)
        {
            return DateTimeOffset.FromUnixTimeMilliseconds(unix).ToLocalTime().DateTime;
        }

        /// <summary>
        /// 合并两个字典
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dic">字典</param>
        /// <param name="newDic">新字典</param>
        /// <returns></returns>
        public static Dictionary<string, T> AddOrUpdate<T>(this Dictionary<string, T> dic, IDictionary<string, T> newDic)
        {
            foreach (var key in newDic.Keys)
            {
                if (dic.ContainsKey(key))
                    dic[key] = newDic[key];
                else
                    dic.Add(key, newDic[key]);
            }

            return dic;
        }

        /// <summary>
        /// 合并两个字典
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dic">字典</param>
        /// <param name="newDic">新字典</param>
        public static void AddOrUpdate<T>(this System.Collections.Concurrent.ConcurrentDictionary<string, T> dic, Dictionary<string, T> newDic)
        {
            foreach (var (key, value) in newDic)
            {
                dic.AddOrUpdate(key, value, (key, old) => value);
            }
        }

        /// <summary>
        /// 将对象转成字典
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static IDictionary<string, object> ToDictionary(this object input)
        {
            if (input == null) return default;

            if (input is IDictionary<string, object> dictionary)
                return dictionary;

            if (input is JsonElement jsonElement && jsonElement.ValueKind == JsonValueKind.Object)
            {
                return jsonElement.ToObject() as IDictionary<string, object>;
            }

            var properties = input.GetType().GetProperties();
            var fields = input.GetType().GetFields();
            var members = properties.Cast<MemberInfo>().Concat(fields.Cast<MemberInfo>());
            return members.ToDictionary(m => m.Name, m => GetValue(input, m));
        }

        /// <summary>
        /// 获取成员值
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="member"></param>
        /// <returns></returns>
        static object GetValue(object obj, MemberInfo member)
        {
            if (member is PropertyInfo info)
                return info.GetValue(obj, null);
            if (member is FieldInfo info1)
                return info1.GetValue(obj);
            throw new ArgumentException("Passed member is neither a PropertyInfo nor a FieldInfo.");
        }

        /// <summary>
        /// 将对象转字典类型，其中值返回原始类型 Type 类型
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static IDictionary<string, Tuple<Type, object>> ToDictionaryWithType(this object input)
        {
            if (input == null) return default;

            if (input is IDictionary<string, object> dictionary)
                return dictionary.ToDictionary(
                    kvp => kvp.Key,
                    kvp => kvp.Value == null ?
                        new Tuple<Type, object>(typeof(object), kvp.Value) :
                        new Tuple<Type, object>(kvp.Value.GetType(), kvp.Value)
                );

            var dict = new Dictionary<string, Tuple<Type, object>>();

            // 获取所有属性列表
            foreach (var property in input.GetType().GetProperties())
            {
                dict.Add(property.Name, new Tuple<Type, object>(property.PropertyType, property.GetValue(input, null)));
            }

            // 获取所有成员列表
            foreach (var field in input.GetType().GetFields())
            {
                dict.Add(field.Name, new Tuple<Type, object>(field.FieldType, field.GetValue(input)));
            }

            return dict;
        }
        /// <summary>
        /// 扩展ChangeType来实现 类型的转换
        /// </summary>
        /// <param name="value"></param>
        /// <param name="conversionType"></param>
        /// <returns></returns>
        public static object Convert(this object value, Type conversionType)
        {
            if (value == null || value is DBNull)
                return null;
            if (conversionType.IsInstanceOfType(value))
                return value;
            if (conversionType.IsEnum)
            {
                var s = value as string;
                if (s != null)
                {
                    return Enum.Parse(conversionType, s);
                }
                return Enum.ToObject(conversionType, value);
            }
            var t = Nullable.GetUnderlyingType(conversionType) ?? conversionType;
            return System.Convert.ChangeType(value, t);
        }
        /// <summary>
        /// JsonElement 转 Object
        /// </summary>
        /// <param name="jsonElement"></param>
        /// <param name="ignoreCase">字典对象是否忽略大小 key</param> 
        /// <returns></returns>
        public static object ToObject(this JsonElement jsonElement, bool ignoreCase = false)
        {
            switch (jsonElement.ValueKind)
            {
                case JsonValueKind.String:
                    return jsonElement.GetString();
                case JsonValueKind.Undefined:
                case JsonValueKind.Null:
                    return default;
                case JsonValueKind.Number:
                    return jsonElement.GetDecimal();
                case JsonValueKind.True:
                case JsonValueKind.False:
                    return jsonElement.GetBoolean();
                case JsonValueKind.Object:
                    var enumerateObject = jsonElement.EnumerateObject();
                    var dic = ignoreCase ? new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase) : new Dictionary<string, object>();
                    foreach (var item in enumerateObject)
                    {
                        dic.Add(item.Name, item.Value.ToObject(ignoreCase));
                    }
                    return dic;
                case JsonValueKind.Array:
                    var enumerateArray = jsonElement.EnumerateArray();
                    var list = new List<object>();
                    foreach (var item in enumerateArray)
                    {
                        list.Add(item.ToObject(ignoreCase));
                    }
                    return list;
                default:
                    return default;
            }
        }

        /// <summary>
        /// 根据规则获取新名称
        /// </summary>
        /// <param name="str_arr">已存在的名称列表</param>
        /// <param name="name">名称前缀</param>
        /// <returns></returns>
        internal static string GetNewName(this string[] str_arr, string name)
        {
            if (str_arr.Length == 0) return name;
            for (int i = 1; i <= str_arr.Length; i++)
            {
                string _name = name + i;
                if (!str_arr.Any(x => x == _name))
                    return _name;
            }
            return name + str_arr.Length;
        }

        /// <summary>
        /// 将DataTable 转换成 List
        /// </summary>
        /// <param name="table"></param>
        /// <returns></returns>
        public static List<object> ToDynamicList(this DataTable table)
        {
            return table.ToDynamicList(Array.Empty<string>(), false);
        }

        /// <summary>
        /// 将DataTable 转换成 List
        /// </summary>
        /// <param name="table"></param>
        /// <param name="filterField">字段过滤，filterField 为空 忽略 reverse 参数；返回DataTable中的全部数据</param>
        /// <param name="reverse">[flase 返回FilterField 指定的字段]|[true 返回结果剔除 filterField 指定的字段]</param>
        /// <returns></returns>
        public static List<object> ToDynamicList(this DataTable table, string[] filterField, bool reverse = false)
        {
            var modelList = new List<object>();
            foreach (DataRow row in table.Rows)
            {
                dynamic model = new System.Dynamic.ExpandoObject();
                var dict = (IDictionary<string, object>)model;
                foreach (DataColumn column in table.Columns)
                {
                    if (filterField is null || filterField.Length != 0)
                    {
                        if (reverse == true)
                        {
                            if (!filterField.Contains(column.ColumnName))
                            {
                                dict[column.ColumnName] = row[column];
                            }
                        }
                        else
                        {
                            if (filterField.Contains(column.ColumnName))
                            {
                                dict[column.ColumnName] = row[column];
                            }
                        }
                    }
                    else
                    {
                        dict[column.ColumnName] = row[column];
                    }
                }
                modelList.Add(model);
            }
            return modelList;
        }

        /// <summary>
        /// 写入只读属性
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <typeparam name="TValue"></typeparam>
        /// <param name="memberLambda"></param>
        /// <param name="value"></param>
        public static void SetReadOnlyValue<TEntity, TValue>(this TEntity entity, Expression<Func<TaskFieldEntity, TValue>> memberLambda, TValue value) where TEntity : class, new()
        {
            if (memberLambda.Body is MemberExpression memberSelectorExpression)
            {
                var property = memberSelectorExpression.Member as PropertyInfo;
                if (property != null)
                {
                    property.SetValue(entity, value);
                }
            }
        }

        //public static object ToObject(this JsonElement value)
        //{
        //    return value.ValueKind switch
        //    {
        //        JsonValueKind.String => value.GetString(),
        //        JsonValueKind.Number => value.GetDecimal(),
        //        JsonValueKind.Array => value.Deserialize<IEnumerable<JsonElement>>().Select(x => x.ToObject()),
        //        JsonValueKind.Object => value.Deserialize<Dictionary<string, JsonElement>>().ToDictionary(x => x.Key, y => y.Value.ToObject()),
        //        JsonValueKind.True => true,
        //        JsonValueKind.False => false,
        //        JsonValueKind.Undefined or JsonValueKind.Null => null,
        //        _ => value,
        //    };
        //}

    }
}