RoApp/Assets/Src/Core/DownLoad/ExcelParser.cs

using System;

using System.Collections.Generic;

using System.Reflection;
using System.Text;
using UnityEngine;

namespace Game.Config
{
    public class ExcelParser
    {
        public static T Serializable<T>(string[] fields, string[] data) where T : GameData
        {
            Type type = typeof(T);
            T obj = Activator.CreateInstance<T>();

            int length = fields.Length;
            for (int i = 0; i < length; i++)
            {
                FieldInfo field = type.GetField(fields[i]);
                if (field != null)
                {
                    if (data.Length > i)
                    {
                        object value = GetSetFieldValue(field.FieldType, data[i]);

                        //Debug.Log(value);
                        field.SetValue(obj, value);
                    }
                    else
                    {
                        Debug.LogError("反射失败,检查数据："+ data[0]);
                    }
                }
                else
                {
                    Debug.LogError("反射查找失败,检查数据：" + data[0]);
                }
            }

            return obj;
        }
        public static T Serializable_NotReflection<T>(string[] fields, string[] data) where T : GameData
        {
            Type type = typeof(T);
            T obj = Activator.CreateInstance<T>();

            int length = fields.Length;
            for (int i = 0; i < length; i++)
            {            
                obj.SetFields(fields[i],data[i]);
            }

            return obj;
        }
        public static GameData Serializable(Type type, string[] fields, string[] data)
        {
            GameData obj = (GameData)Activator.CreateInstance(type);

            int length = fields.Length;
            for (int i = 0; i < length; i++)
            {
                FieldInfo field = type.GetField(fields[i]);
                object value = GetSetFieldValue(field.FieldType, data[i]);
                field.SetValue(obj, value);
            }

            return obj;
        }

        public static string[] Deserialize_NoReflection(GameData data, string[] fields)
        {
            int length = fields.Length;
            string[] ret = new string[length];

            for (int i = 0; i < length; i++)
            {
                ret[i] = data.GetFieldValue(fields[i]);
            }

            return ret;
        }
        public static string[] Deserialize(Type type, GameData data, string[] fields)
        {
            int length = fields.Length;
            string[] ret = new string[length];

            for (int i = 0; i < length; i++)
            {
                FieldInfo fieldInfo = type.GetField(fields[i]);

                if (!fieldInfo.FieldType.GetTypeInfo().IsGenericType)
                {
                    ret[i] = fieldInfo.GetValue(data).ToString();
                }
                else
                {
                    ret[i] = GetCompositeValueString(data, fieldInfo);
                }
            }

            return ret;
        }

        private static string GetCompositeValueString(GameData data, FieldInfo fieldInfo)
        {
            StringBuilder ret = new StringBuilder();

            object obj = fieldInfo.GetValue(data);

            Type type = fieldInfo.FieldType.GetGenericTypeDefinition();

            if (type == typeof(List<>))
            {
                GetListValueString(ret, fieldInfo.FieldType, obj);
            }
            else if (type == typeof(Dictionary<,>))
            {
                GetDictionaryValueString(ret, fieldInfo.FieldType, obj);
            }

            return ret.ToString();
        }

        private static void GetDictionaryValueString(StringBuilder stringBuilder, Type fieldType, object obj)
        {
            // 获取Dictionary的Count属性信息
            PropertyInfo countPropertyInfo = fieldType.GetProperty("Count");
            // 获取Dictionary的元素数量
            int count = (int)countPropertyInfo.GetValue(obj);
            // 获取Dictionary的Item属性信息
            PropertyInfo itemPropertyInfo = fieldType.GetProperty("Item");

            PropertyInfo keysPropertyInfo = fieldType.GetProperty("Keys");

            object keys = keysPropertyInfo.GetValue(obj);
            object keyenumerator = keys.GetType().GetMethod("GetEnumerator").Invoke(keys, null);

            Type keyenumeratorType = keyenumerator.GetType();

            MethodInfo keyenumeratorMoveNext = keyenumeratorType.GetMethod("MoveNext");
            PropertyInfo keyenumeratorCurrent = keyenumeratorType.GetProperty("Current");
            int i = 0;
            while ((bool)keyenumeratorMoveNext.Invoke(keyenumerator, null))
            {
                object key = keyenumeratorCurrent.GetValue(keyenumerator);
                object value = itemPropertyInfo.GetValue(obj, new object[] { key });
              
                if (i < count - 1)
                {
                    stringBuilder.AppendFormat("{0}|{1}|",key.ToString(), value.ToString());
                }
                else
                {
                    stringBuilder.AppendFormat("{0}|{1}", key.ToString(), value.ToString());
                }
                i++;
            }

        }

        private static void GetListValueString(StringBuilder stringBuilder, Type fieldType, object obj)
        {
            // 获取List的Count属性信息
            PropertyInfo countPropertyInfo = fieldType.GetProperty("Count");

            // 获取List的Item属性信息
            PropertyInfo itemPropertyInfo = fieldType.GetProperty("Item");

            // 获取List的元素数量
            int count = (int)countPropertyInfo.GetValue(obj);

            // 遍历List并获取存储的数据
            for (int i = 0; i < count; i++)
            {
                // 使用Item属性获取元素
                object value = itemPropertyInfo.GetValue(obj, new object[] { i });
                if (i < count - 1)
                { 
                    stringBuilder.AppendFormat("{0}|", value.ToString()); 
                }
                else
                {
                    stringBuilder.Append(value.ToString());
                }
            }
        }

        public static string[] Deserialize<T>(T data, string[] fields) where T : GameData
        {
            return Deserialize(typeof(T), data, fields);
        }


        public static object GetSetFieldValue(Type fieldType, string value)
        {
            object setvalue = new object();
            switch (fieldType.ToString())
            {
                case "Int32":
                case "System.Int32":
                    setvalue = int.Parse(value);
                    break;
                case "System.Int64":
                case "Int64":
                    setvalue = long.Parse(value);
                    break;
                case "System.UInt64":
                case "UInt64":
                    setvalue = ulong.Parse(value);
                    break;
                case "Single":
                case "System.Single":
                    setvalue = float.Parse(value);
                    break;
                case "System.Double":
                case "Double":
                    setvalue = double.Parse(value);
                    break;
                case "System.Boolean":
                case "Boolean":
                    setvalue = bool.Parse(value);
                    break;
                case "System.String":
                case "String":
                    setvalue = value;
                    break;

                //case "System.Int32": setvalue = int.Parse(value); break;
                // 新加
                default:
                    setvalue = GetSetComPositeTypeFieldValue(setvalue, fieldType, value);
                    break;

            }
            return setvalue;
        }

        public static object GetSetComPositeTypeFieldValue(object obj, Type fieldType, string value)
        {
            Type type = fieldType;

            if (!type.GetTypeInfo().IsGenericType)
            {
                return obj;
            }
            Type genericType = type.GetGenericTypeDefinition();
            string[] datas = value.Split('|');
            if (datas.Length <= 0)
            {
                return obj;
            }
            if (typeof(List<>) == genericType)
            {
                obj = SetListTypeFieldValue(obj, type, datas);
            }
            else if (typeof(Dictionary<,>) == genericType)
            {
                obj = SetDictionaryTypeFieldValue(obj, type, datas);
            }


            return obj;
        }

        private static object SetDictionaryTypeFieldValue(object obj, Type fieldType, string[] values)
        {
            obj = Activator.CreateInstance(fieldType);
            Type[] agtypes = fieldType.GetGenericArguments();

            Type keyType = agtypes[0];
            Type valueType = agtypes[1];

            MethodInfo method = fieldType.GetMethod("Add");
            if (method != null)
            {
                int len = values.Length;
                for (int i = 0; i < len; i += 2)
                {
                    object key = GetSetFieldValue(keyType, values[i]);
                    object value = GetSetFieldValue(valueType, values[i + 1]);
                    method.Invoke(obj, new object[] { key, value });
                }
            }

            return obj;
        }

        private static object SetListTypeFieldValue(object obj, Type fieldType, string[] values)
        {
            obj = Activator.CreateInstance(fieldType);

            Type gatype = fieldType.GetGenericArguments()[0];

            MethodInfo method = fieldType.GetMethod("Add");
            if (method != null)
            {
                int len = values.Length;
                for (int i = 0; i < len; i++)
                {
                    object value = GetSetFieldValue(gatype, values[i]);

                    method.Invoke(obj, new object[] { value });
                }
            }

            return obj;
        }
    }


}