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

using Game.Config;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;

using UnityEngine;


public abstract class GameData
{
    public int ID;
    public abstract string FlieName();
    public virtual bool SetFields(string fieldname, string value)
    {
        bool ret = false;

        if (fieldname == "ID")
        {
            ret = true;
            ID = int.Parse(value);
        }

        return ret;
    }

    public virtual string GetFieldValue(string fieldname)
    {
        string ret = "";
        if (fieldname == "ID")
        {
            ret = ID.ToString();          
        }
        return ret;
    }
}


public abstract class GameData<T> : GameData where T : GameData
    {
        
        protected static Dictionary<int, T> configDatas = new Dictionary<int, T>();
        protected static string[] fields;
        protected static string[] types;
        public override string FlieName()
        {
            return "";
        }


        protected static void Onload(CsvReader csvReader)
        {
            configDatas.Clear();
            string[][] datas = csvReader.RowDatas;
            fields = csvReader.Fields();
            types = csvReader.Types();
            int length = datas.Length;
            for (int i = 2; i < length; i++)
            {
                T data = ExcelParser.Serializable<T>(fields, datas[i]);
                //Debug.Log(data.FlieName() + data.ID);
                configDatas.Add(data.ID, data);
            }
        }
    protected static void Onload_SetField(CsvReader csvReader)
    {
        configDatas.Clear();
        string[][] datas = csvReader.RowDatas;
        fields = csvReader.Fields();
        types = csvReader.Types();
        int length = datas.Length;
        for (int i = 2; i < length; i++)
        {
            T data = ExcelParser.Serializable_NotReflection<T>(fields, datas[i]);
            //Debug.Log(data.FlieName() + data.ID);
            configDatas.Add(data.ID, data);
        }
    }
    public static T GetData(int id)
        {
            T data = null;
            if (configDatas.ContainsKey(id))
                data = configDatas[id];
            return data;
        }

        public static T[] Where(Func<T, bool> func)
        {
            return configDatas.Values.Where(func).ToArray();
        }

        public static T Find(Func<T, bool> func)
        {
            T data = configDatas.Values.Where(func).FirstOrDefault();

            return data;
        }

        public static void Foreach( Action<T> action)
        {
            List<T> datas = AllData();
            int length = datas.Count;

            for (int i = 0; i < length; i++)
            {
                action?.Invoke(datas[i]);
            }
        }

        public static void Clear()
        {
            configDatas.Clear();
            fields = null;
            types = null;
        }

        public static List<T> AllData()
        {
            return configDatas.Values.ToList();
        }

        public void Delete()
        {
            if (configDatas.ContainsKey(ID))
            {
                configDatas.Remove(ID);
            }
        }

        public static void AddNewData(T data)
        {
            int id = GetNextIndex();
            data.ID = id;
            configDatas.Add(id,data);
        }

        public static string WriteToFile(string path = null)
        {
            GameDataFormatInfo info = new GameDataFormatInfo(fields, types);
            Type type = typeof(T);
            T obj = Activator.CreateInstance<T>();
            CsvWriter<T> csvWriter = new CsvWriter<T>(path, obj.FlieName(), configDatas.Values.ToList(), info);
            if (!string.IsNullOrEmpty(path))
            {
                csvWriter.Write();
            }
            return csvWriter.Data;
        }

        public static GameDataFormatInfo GetFormatInfo()
        {
            return new GameDataFormatInfo(fields, types);
        }
        private static int GetNextIndex()
        {

            int max = 0;
            if (configDatas.Count > 0)
            {
                max = configDatas.Keys.OrderBy(x => x).Max();
            }

            return max + 1;
        }
    }
    public enum ConfigMode
    {
        OnAsset,
        OnMemory,
    }

    public class GameDataFormatInfo
    {
        public string[] Fileds;
        public string[] Types;

        public GameDataFormatInfo(string[] fs, string[] ts)
        {
            this.Fileds = fs;
            this.Types = ts;
        }
    }

    //public class GameDatabase : Singleton<GameDatabase>
    //{
    //    private Dictionary<string, GameDataFormatInfo> formatInfos;
    //    private ConfigMode configMode;
    //    private string bundleName;
    //    //public void Init(string bundleName, ConfigMode mode = ConfigMode.OnMemory)
    //    //{
    //    //    configMode = mode;
    //    //    formatInfos = new Dictionary<string, GameDataFormatInfo>();
    //    //    this.bundleName = bundleName;
    //    //    LoadDatabase(new ConfigPathInfo().Paths.ToArray());
    //    //}



    //    //public void LoadDatabase(string[] paths)
    //    //{
    //    //    if (configMode == ConfigMode.OnAsset || paths == null || paths.Length == 0)
    //    //        return;
    //    //    ResourcesManager resmgr = ResourcesManager.Instance;

    //    //    int length = paths.Length;
    //    //    for (int i = 0; i < length; i++)
    //    //    {
    //    //        Debug.Log(paths[i]);
    //    //        int index = i;
    //    //        resmgr.LoadAssetNoDependencisAsync<TextAsset>(paths[index], bundleName, txt =>
    //    //        {
    //    //            string name = FileHelper.GetName(paths[index]);
    //    //            CsvReader csvReader = new CsvReader(name, txt.bytes);
    //    //            Type type = Type.GetType(FileHelper.GetConfigClassFullName(name));

    //    //            MethodInfo methodInfo = type.GetMethod("OnCsvLoad", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
    //    //            methodInfo?.Invoke(null, new object[] { csvReader });

    //    //            formatInfos.Add(name, new GameDataFormatInfo(csvReader.Fields(), csvReader.Types()));
    //    //        });
    //    //    }
    //    //    //resmgr.UnLoad(bundleName);
    //    //}


    //    public static void LoadDataBaseFormMemory<T>(byte[] data) where T: GameData
    //    {
    //        Type type = typeof(T);
    //        CsvReader csvReader = new CsvReader(type.Name, data);
    //        MethodInfo methodInfo = type.GetMethod("OnCsvLoad", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
    //        methodInfo?.Invoke(null, new object[] { csvReader });
    //    }

    //    public GameDataFormatInfo GetGameDataFormatInfo(string name)
    //    {
    //        GameDataFormatInfo ret = null;
    //        if (formatInfos.ContainsKey(name))
    //            ret = formatInfos[name];
    //        return ret;
    //    }

    //    private Dictionary<int, GameData> GetConfigDatas(CsvReader reader)
    //    {
    //        Dictionary<int, GameData> gameDatas = new Dictionary<int, GameData>();

    //        string[][] datas = reader.RowDatas;
    //        string[] fields = reader.Fields();
    //        int length = datas.Length;
    //        for (int i = 2; i < length; i++)
    //        {
    //            GameData gameData = ExcelParser.Serializable(Type.GetType($"Game.Config.{reader.Name}"), fields, datas[i]);
    //            gameDatas.Add(gameData.ID, gameData);
    //        }

    //        return gameDatas;
    //    }
    //}