devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity读取Excel导出Json，游戏中加载Json生成List＜T＞配置_unityjson转 list

作者：IT小白 | 2024-07-06 22:24:21

赞

踩

unityjson转 list

读取Excel导出Json和对应数据格式Class

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEditor;
  5. using System.IO;
  6. using Excel;
  7. using System.Data;
  8. using System;
  9. using System.Linq;
  10. public class ExcelToJson : Editor
  11. {
  12.     //[MenuItem("TGDTools/ExcelToJson")]
  13.     public static void ReadExcelToJson()
  14.     {
  15.         //目标文件夹
  16.         string sourceDir = string.Format("{0}/../../excelsconfig", Environment.CurrentDirectory);
  17.         if(!Directory.Exists(sourceDir))
  18.         {
  19.             Debug.LogError(string.Format("目标文件夹不存在！:{0}", sourceDir));
  20.             return;
  21.         }
  22.  
  23.         //检查文件
  24.         string sourceFile = string.Format("{0}/测试表.xlsx", sourceDir);
  25.         if (!File.Exists(sourceFile))
  26.         {
  27.             Debug.LogError(string.Format("目标文件不存在！:{0}", sourceFile));
  28.             return;
  29.         }
  30.         //读取源文件
  31.         Dictionary<string, Dictionary<string, object>> holder = new Dictionary<string, Dictionary<string, object>>();
  32.         if (!ReadExcel(sourceFile, holder))
  33.         {
  34.             Debug.LogError(string.Format("读取目标文件失败 : {0}", sourceFile));
  35.             return;
  36.         }
  37.         //检查生成目录
  38.         string targetDir = string.Format("{0}/Assets/Resources/ExcelToJson", Environment.CurrentDirectory);
  39.         if (!Directory.Exists(targetDir))
  40.         {
  41.             Directory.CreateDirectory(targetDir);
  42.             Debug.LogFormat("目标文件夹不存在，创建新目录 : {0}", targetDir);
  43.         }
  44.         //转换格式并保存
  45.         string tablePath = string.Format("{0}/TextExcelToJson.json", targetDir);
  46.         if (File.Exists(tablePath))
  47.         {
  48.             File.Delete(tablePath);
  49.         }
  50.         FileInfo fileInfo = new FileInfo(tablePath);
  51.         using (StreamWriter streamWriter = fileInfo.CreateText())
  52.         {
  53.             streamWriter.Write(LitJson.JsonMapper.ToJson(holder));
  54.             streamWriter.Flush();
  55.             streamWriter.Close();
  56.         }
  57.         AssetDatabase.Refresh();
  58.         Debug.Log("=================== 生成成功!!!");
  59.     }
  60.  
  61.     private static bool ReadExcel(string filePath, Dictionary<string, Dictionary<string, object>> dataHolder)
  62.     {
  63.         try
  64.         {
  65.             EditorUtility.DisplayProgressBar("ReadExcel", filePath, 0);
  66.             //读取文件
  67.             using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite))
  68.             {
  69.                 //创建读取
  70.                 IExcelDataReader dataReader = ExcelReaderFactory.CreateOpenXmlReader(fileStream);
  71.                 //转换格式
  72.                 DataSet dataSet = dataReader.AsDataSet();
  73.                 int index = 0;
  74.                 //遍历页签
  75.                 foreach (DataTable dataTable in dataSet.Tables)
  76.                 {
  77.                     //页签名称
  78.                     string sheetName = dataTable.TableName;
  79.                     //Debug.LogFormat("------------->> sheetName:{0}", sheetName);
  80.                     EditorUtility.DisplayProgressBar("Read Excel Sheet", sheetName, index*1f/ dataSet.Tables.Count);
  81.  
  82.                     index++;
  83.                     //一个页签
  84.                     if (!dataHolder.TryGetValue(sheetName, out Dictionary<string, object> sheetData))
  85.                     {
  86.                         sheetData = new Dictionary<string, object>();
  87.                         dataHolder.Add(sheetName, sheetData);
  88.                     }
  89.                     //读取行
  90.                     DataRowCollection dataRows = dataTable.Rows;
  91.                     //读取列
  92.                     DataColumnCollection dataColumns = dataTable.Columns;
  93.                     //Debug.LogFormat("------------->> dataRows.Count:{0}  dataColumns.Count:{1}", dataRows.Count, dataColumns.Count);
  94.  
  95.                     //遍历
  96.                     for (int i = 1; i < dataColumns.Count; i++)
  97.                     {
  98.                         string name = dataRows[0][i].ToString().Trim();
  99.                         if (!string.IsNullOrEmpty(name))
  100.                         {
  101.                             //Debug.LogFormat("------------->> i:{0}  name:{1}", i, name);
  102.                             for (int j = 1; j < dataRows.Count; j++)
  103.                             {
  104.                                 string key = dataRows[j][0].ToString().Trim();
  105.                                 //Debug.LogFormat("------------->>  j:{0} key:{1}", j, key);
  106.                                 //一行数据
  107.                                 string value = dataRows[j][i].ToString().Trim();
  108.                                 if (!string.IsNullOrEmpty(value))
  109.                                 {
  110.                                     //Debug.LogFormat("------------->>  i:{0} j:{1} value:{2}", i, j, value);
  111.                                     //dataHolder.Add(name, value);
  112.                                     if (!sheetData.TryGetValue(key, out object data))
  113.                                     {
  114.                                         data = new Dictionary<string, string>();
  115.                                         sheetData.Add(key, data);
  116.                                     }
  117.                                         (data as Dictionary<string, string>).Add(name, value);
  118.                                 }
  119.                             }
  120.                         }
  121.                     }
  122.                 }
  123.  
  124.             }
  125.             EditorUtility.ClearProgressBar();
  126.             return true;
  127.         }
  128.         catch (Exception e)
  129.         {
  130.             Debug.LogError(string.Format("读取数据异常 : {0}", e.Message));
  131.         }
  132.         return false;
  133.     }
  134.  
  135.     [MenuItem("TGDTools/ExportExcel")]
  136.     public static void ExportExcel()
  137.     {
  138.         //目标文件夹
  139.         string sourceDir = string.Format("{0}/../../excelsconfig", Environment.CurrentDirectory);
  140.         if (!Directory.Exists(sourceDir))
  141.         {
  142.             Debug.LogError(string.Format("目标文件夹不存在！:{0}", sourceDir));
  143.             return;
  144.         }
  145.         List<string> fileList = RecursivePathGetFiles(sourceDir);
  146.         for(int i=0; i<fileList.Count; i++)
  147.         {
  148.             string fileName = fileList[i];
  149.             
  150.             EditorUtility.DisplayProgressBar("ReadExcel", fileName, i*1f/fileList.Count);
  151.             //检查文件
  152.             if (!File.Exists(fileName))
  153.             {
  154.                 Debug.LogError(string.Format("目标文件不存在！:{0}", fileName));
  155.                 continue;
  156.             }
  157.             ReadExcel(fileName);
  158.         }
  159.         EditorUtility.ClearProgressBar();
  160.         AssetDatabase.Refresh();
  161.         Debug.Log("=================== 生成成功!!!");
  162.     }
  163.  
  164.     private static void ReadExcel(string fileName)
  165.     {
  166.         try
  167.         {
  168.             Debug.LogFormat("------------->>ReadExcel  {0}", fileName);
  169.             //读取文件
  170.             using (FileStream fileStream = File.Open(fileName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite))
  171.             {
  172.                 //创建读取
  173.                 IExcelDataReader dataReader = ExcelReaderFactory.CreateOpenXmlReader(fileStream);
  174.                 //转换格式
  175.                 DataSet dataSet = dataReader.AsDataSet();
  176.                 //读取表（第一个页签）
  177.                 DataTable dataTable = dataSet.Tables[0];
  178.                 CreateClasssFile(dataTable);
  179.                 CreateJsonFile(dataTable);
  180.             }
  181.         }
  182.         catch (Exception e)
  183.         {
  184.             Debug.LogError(string.Format("读取数据异常 : {0}", e.Message));
  185.         }
  186.     }
  187.  
  188.     private static void CreateClasssFile(DataTable dataTable)
  189.     {
  190.         //页签名称
  191.         string sheetName = dataTable.TableName;
  192.         //读取行
  193.         DataRowCollection dataRows = dataTable.Rows;
  194.         //读取列
  195.         DataColumnCollection dataColumns = dataTable.Columns;
  196.  
  197.  
  198.         string text = "using System;\nusing System.Collections.Generic;\nnamespace TGDFramework.Core\n{\n    public class " + sheetName + ("\n    {\n");
  199.         for (int i=0; i<dataColumns.Count; i++)
  200.         {
  201.             string valeName = dataRows[1][i].ToString().Trim();
  202.             string valeType = dataRows[2][i].ToString().Trim();
  203.             if (!string.IsNullOrEmpty(valeName) && !string.IsNullOrEmpty(valeType))
  204.             {
  205.                 string memberStr = string.Format("        public {0} {1};\n", valeType, valeName);
  206.                 Debug.LogFormat("----------------CreateClasssFile------------->>>  {0} {1}", valeType, valeName);
  207.                 text = String.Concat(text, memberStr);
  208.             }
  209.         }
  210.         string tail = "    }\n}\n";
  211.         text = String.Concat(text, tail);
  212.  
  213.         string dir = string.Format("{0}/Assets/Scripts/TGDFramework/ExcelToJson/Table", Environment.CurrentDirectory);
  214.         if (!Directory.Exists(dir))
  215.         {
  216.             Directory.CreateDirectory(dir);
  217.         }
  218.  
  219.         string filePath = string.Format("{0}/{1}.cs", dir, sheetName);
  220.         if (File.Exists(filePath))
  221.         {
  222.             File.Delete(filePath);
  223.         }
  224.         FileInfo fileInfo = new FileInfo(filePath);
  225.         using (StreamWriter streamWriter = fileInfo.CreateText())
  226.         {
  227.             streamWriter.Write(text);
  228.             streamWriter.Flush();
  229.             streamWriter.Close();
  230.         }
  231.         Debug.LogFormat("----------------------------->>>create Class {0} succ!", sheetName);
  232.     }
  233.  
  234.     private static void CreateJsonFile(DataTable dataTable)
  235.     {
  236.         //页签名称
  237.         string sheetName = dataTable.TableName;
  238.         //读取行
  239.         DataRowCollection dataRows = dataTable.Rows;
  240.         //读取列
  241.         DataColumnCollection dataColumns = dataTable.Columns;
  242.  
  243.         List<object> dataHolder = new List<object>();
  244.         //遍历
  245.         for (int i = 3; i < dataRows.Count; i++)
  246.         {
  247.             string keyStr = dataRows[i][0].ToString().Trim();
  248.             if (string.IsNullOrEmpty(keyStr))
  249.             {
  250.                 break;
  251.             }
  252.             int key = int.Parse(keyStr);            
  253.             //Debug.LogFormat("----------------------------->>> key {0}", key);
  254.             Dictionary<object, object> data = new Dictionary<object, object>();
  255.  
  256.             for (int j = 0; j < dataColumns.Count; j++)
  257.             {                
  258.                 string valeName = dataRows[1][j].ToString().Trim();
  259.                 string valeType = dataRows[2][j].ToString().Trim();
  260.  
  261.                 string value = dataRows[i][j].ToString().Trim();
  262.                 //Debug.LogFormat("----------------------------->>> valeType:{0} valeName:{1} value:{2}", valeType, valeName, value);
  263.                 if (!string.IsNullOrEmpty(value))
  264.                 {
  265.                     if (valeType.Equals("int"))
  266.                     {
  267.                         data.Add(valeName, int.Parse(value));
  268.                     }
  269.                     else if (valeType.Equals("string"))
  270.                     {
  271.                         data.Add(valeName, value);
  272.                     }
  273.                     else if (valeType.Equals("List<int>"))
  274.                     {
  275.                         List<int> list = new List<int>();
  276.                         string[] listStr = value.Split('+');
  277.                         foreach(string str in listStr)
  278.                         {
  279.                             list.Add(int.Parse(str));
  280.                         }
  281.                         data.Add(valeName, list);
  282.                     }
  283.                     else if (valeType.Equals("List<string>"))
  284.                     {
  285.                         
  286.                         string[] listStr = value.Split('+');
  287.                         List<string> list = new List<string>(listStr);
  288.                         data.Add(valeName, list);
  289.                     }
  290.                     else if (valeType.Equals("Dictionary<string,string>"))
  291.                     {
  292.                         string[] listStr = value.Split('|');
  293.                         Dictionary<string, string> dic = listStr.ToDictionary(
  294.                                                                             sKey => { /*Debug.Log(sKey);*/ return sKey.Split('+')[0]; }, 
  295.                                                                             sElement => { /*Debug.Log(sElement);*/return sElement.Split('+')[1]; }
  296.                                                                             );
  297.                         data.Add(valeName, dic);
  298.                     }
  299.                 }                              
  300.             }
  301.             dataHolder.Add(data);
  302.         }
  303.         string dir = string.Format("{0}/Assets/Scripts/TGDFramework/ExcelToJson/Json", Environment.CurrentDirectory);
  304.         if (!Directory.Exists(dir))
  305.         {
  306.             Directory.CreateDirectory(dir);
  307.         }
  308.         string filePath = string.Format("{0}/{1}.json", dir, sheetName);
  309.         if (File.Exists(filePath))
  310.         {
  311.             File.Delete(filePath);
  312.         }
  313.         FileInfo fileInfo = new FileInfo(filePath);
  314.         using (StreamWriter streamWriter = fileInfo.CreateText())
  315.         {
  316.             streamWriter.Write(LitJson.JsonMapper.ToJson(dataHolder));
  317.             streamWriter.Flush();
  318.             streamWriter.Close();
  319.         }
  320.         Debug.LogFormat("----------------------------->>>create Json {0} succ!", sheetName);
  321.     }
  322.  
  323.     public static List<string> RecursivePathGetFiles(string path)
  324.     {
  325.         List<string> fileList = new List<string>();
  326.         fileList.Clear();
  327.         RecursivePath(path, fileList);
  328.         return fileList;
  329.     }
  330.  
  331.     private static void RecursivePath(string path, List<string> fileList)
  332.     {
  333.         string[] files = Directory.GetFiles(path);
  334.         string[] dirs = Directory.GetDirectories(path);
  335.  
  336.         int count = files.Length;
  337.         for (int i = 0; i < count; i++)
  338.         {
  339.             string ext = Path.GetExtension(files[i]);
  340.             if (ext.Equals(".mat"))
  341.             {
  342.                 continue;
  343.             }
  344.             fileList.Add(files[i].Replace("\\", "/"));
  345.         }
  346.  
  347.         count = dirs.Length;
  348.         for (int i = 0; i < count; i++)
  349.         {
  350.             RecursivePath(dirs[i], fileList);
  351.         }
  352.     }
  353. }

游戏中读取Json，生成List<T>配置

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using TGDFramework.Core;
  5. using LitJson;
  6. using System.IO;
  7. using System.Linq;
  8.  
  9. namespace TGDFramework.Core
  10. {
  11.     public class LoadJsonData : Singleton<LoadJsonData>
  12.     {
  13.         private Dictionary<string, object> m_TextExcelJson;
  14.         public Dictionary<string, object> TextExcelJson
  15.         {
  16.             get
  17.             {
  18.                 if (m_TextExcelJson == null)
  19.                 {
  20.                     TextAsset textAsset = Resources.Load<TextAsset>("ExcelToJson/TextExcelToJson");
  21.                     if (textAsset != null)
  22.                     {
  23.                         m_TextExcelJson = JsonMapper.ToObject<Dictionary<string, object>>(textAsset.text);
  24.                     }
  25.                 }
  26.                 return m_TextExcelJson;
  27.             }
  28.         }
  29.         private TableData<PTextSheet> mPTextSheetTable;
  30.  
  31.         public void Init()
  32.         {
  33.             Debug.Log(TextExcelJson.ToString());
  34.             
  35.             //LoadJson<P>("TextExcelToJson");
  36.             string dir = string.Format("Assets/Scripts/TGDFramework/ExcelToJson/Json/");
  37.  
  38.             mPTextSheetTable = TableData<PTextSheet>.Instance;
  39.             mPTextSheetTable.LoadData("PTextSheet", dir);
  40.  
  41.             
  42.             PTextSheet data = Instance.GetPExhibitionData().Where(p => p.id == 3).First();
  43.             PTextSheet data1 = mPTextSheetTable.GetDataByKey(4);
  44.             Debug.LogFormat("============>>>  id:{0} name:{1} {2} ", data.id, data.name, data.TestList_int.ToString(), data.TestList_string.ToString());
  45.             foreach(string str in data1.TestList_string)
  46.             {
  47.                 Debug.LogFormat("============>>>  str:{0}", str);
  48.             }
  49.  
  50.             foreach (var item in data1.TestDic_stringString)
  51.             {
  52.                 Debug.LogFormat("============>>>  key:{0}  value:{1}", item.Key, item.Value);
  53.             }
  54.             foreach (var item in data1.TestDic_intintTGD)
  55.             {
  56.                 Debug.LogFormat("============>>>  key:{0}  value:{1}", item.Key, item.Value);
  57.             }
  58.         }
  59.  
  60.         private void LoadJson<T>(string fileName)
  61.         {
  62.             string filePath = string.Format("ExcelToJson/{0}", fileName);
  63.             if (!File.Exists(filePath))
  64.             {
  65.                 return;
  66.             }
  67.             TextAsset tableAsset = Resources.Load<TextAsset>(filePath);
  68.             if (tableAsset == null)
  69.             {
  70.                 return;
  71.             }
  72.  
  73.             
  74.         }
  75.  
  76.         public List<PTextSheet> GetPExhibitionData()
  77.         {
  78.             return mPTextSheetTable.GetDataList();
  79.         }
  80.  
  81.         //public static string GetTableTranslateString<T>(T tableData, string keyName) where T : class
  82.         //{
  83.         //    string fullClassName = tableData.GetType().ToString();
  84.         //    string[] listName = fullClassName.Split('.');
  85.         //    string className = listName[listName.Length - 1];
  86.         //    if (Instance.TextExcelJson.ContainsKey(className))
  87.         //    {
  88.         //        Dictionary<string, Dictionary<string, string>> dataRow = Instance.TextExcelJson[className];
  89.         //        string id = typeof(T).GetField("id").GetValue(tableData).ToString();
  90.         //        if (dataRow.ContainsKey(id))
  91.         //        {
  92.         //            Dictionary<string, string> data = dataRow[id];
  93.         //            string strKey = string.Format("{0}_CN", keyName);
  94.         //            if (data.ContainsKey(strKey))
  95.         //            {
  96.         //                string text = data[strKey];
  97.         //                //Debug.LogFormat("------------------------>>>> text {0} ", text);
  98.         //                return text;
  99.         //            }
  100.         //        }
  101.         //    }
  102.         //    return null;
  103.         //}
  104.     }
  105.  
  106. }
  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using UnityEngine;
  5. using LitJson;
  6. using System.IO;
  7.  
  8. namespace TGDFramework.Core
  9. {
  10.     public sealed class TableData<T> : Singleton<TableData<T>>
  11.     {
  12.         private List<T> mTableDataList;
  13.         private Dictionary<int, T> mTableDataDict;
  14.  
  15.         public TableData()
  16.         {
  17.             mTableDataDict = new Dictionary<int, T>();
  18.         }
  19.  
  20.         public void LoadData(string tableName)
  21.         {
  22.             
  23.             string abVersion = "";
  24.             var assetName = tableName + ".json";
  25.             string tablePath = string.IsNullOrEmpty(abVersion) ? Const.CONFIG_DATA_PATH : Const.CONFIG_DATA_PATH + "-" + abVersion;
  26.             TextAsset tableAsset = (TextAsset)BundleManager.Instance.LoadBundle(tablePath, assetName);
  27.             
  28. #if UNITY_EDITOR
  29.             Debug.Log("load tableName: " + tableName);
  30. #endif
  31.  
  32.             mTableDataList = JsonMapper.ToObject<List<T>>(tableAsset.text);
  33.             for (int i = 0; i < mTableDataList.Count; i++)
  34.             {
  35.                 T item = mTableDataList[i];
  36.                 int primaryKey = int.Parse(typeof(T).GetField("id").GetValue(item).ToString());
  37.                 mTableDataDict[primaryKey] = item;
  38.             }
  39.             
  40.         }
  41.         public void LoadData(string tableName, string dir)
  42.         {
  43.             string path = dir + tableName +".json";
  44.             TextAsset asset = (TextAsset)UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(path);
  45. #if UNITY_EDITOR
  46.             Debug.Log("load tableName: " + path);
  47. #endif
  48.  
  49.             mTableDataList = JsonMapper.ToObject<List<T>>(asset.text);
  50.             for (int i = 0; i < mTableDataList.Count; i++)
  51.             {
  52.                 T item = mTableDataList[i];
  53.                 int primaryKey = int.Parse(typeof(T).GetField("id").GetValue(item).ToString());
  54.                 mTableDataDict[primaryKey] = item;
  55.             }
  56.  
  57.         }
  58.         public List<T> GetDataList()
  59.         {
  60.             return this.mTableDataList;
  61.         }
  62.  
  63.         public T GetDataByKey(int id)
  64.         {
  65.             T data = default(T);
  66.             this.mTableDataDict.TryGetValue(id, out data);
  67.             return data;
  68.         }
  69.     }
  70. }

https://download.csdn.net/download/u012366310/20419625

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/794124
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号