• 【Unity】升级版·Excel数据解析，自动创建对应C#类，自动创建ScriptableObject生成类，自动序列化Asset文件

    实现功能：

    • 自动创建继承ScriptableObject的C#数据类，每条Excel的数据，都有对应的字段的Get函数； 

     

    • 自动创建每个Excel的Asset生成类和生成函数，用于自动生成Asset文件

    • 使用Asset生成类自动序列化Excel数据到Asset文件，可直接在项目运行时加载使用

    实现原理：

    Excel配置格式：

    • 第1行对应特殊标记（可以设置有效性，指定要创建的文件）
    • 第2行对应中文说明（作为第3行字段的注释）
    • 第3行对应字段名称（自动创建的字段名称）
    • 第4行对应字段类型（自动创建的字段类型，与字段名称一一对应）
    • 第5行及以后对应字段值（所有数据，以行为单位解析、保存数据）
    • 第一列固定字段为"id"，是代码中索引每行数据的Key

    Excel注释操作：

    • 字段名称行，每个字段单元格内容前加"//"，可以注释该字段，不会解析生成到C#类；
    • 第一列的单元格内容前加"//"，可以注释一行数据，不会保存到Asset文件中；
    • 注释可以用于添加说明行，或剔除指定无用数据。

    生成的C#类格式：

    行数据类，对应每一行数据：

    1. [Serializable]
    2. public class TestConfigExcelItem : ExcelItemBase
    3. {
    4. 	/// <summary>
    5. 	/// 数据id
    6. 	/// </summary>>
    7. 	public int id;
    8. 	/// <summary>
    9. 	/// 字符串
    10. 	/// </summary>>
    11. 	public string testString;
    12. 	/// <summary>
    13. 	/// Int
    14. 	/// </summary>>
    15. 	public int testInt;
    16. 	/// <summary>
    17. 	/// Float
    18. 	/// </summary>>
    19. 	public float testFloat;
    20. }

    完整数据类，包含所有行的数据、初始化函数、Get函数：

    1. public class TestConfigExcelData : ExcelDataBase<TestConfigExcelItem>
    2. {
    3. 	public TestConfigExcelItem[] items;
    4.  
    5. 	public Dictionary<int,TestConfigExcelItem> itemDic = new Dictionary<int,TestConfigExcelItem>();
    6.  
    7. 	public void Init()
    8. 	{
    9. 		itemDic.Clear();
    10. 		if(items != null && items.Length > 0)
    11. 		{
    12. 			for(int i = 0; i < items.Length; i++)
    13. 			{
    14. 				itemDic.Add(items[i].id, items[i]);
    15. 			}
    16. 		}
    17. 	}
    18.  
    19. 	public TestConfigExcelItem GetTestConfigExcelItem(int id)
    20. 	{
    21. 		if(itemDic.ContainsKey(id))
    22. 			return itemDic[id];
    23. 		else
    24. 			return null;
    25. 	}
    26. 	#region --- Get Method ---
    27.  
    28. 	public string GetTestString(int id)
    29. 	{
    30. 		var item = GetTestConfigExcelItem(id);
    31. 		if(item == null)
    32. 			return default;
    33. 		return item.testString;
    34. 	}
    35.  
    36. 	// ··· ···
    37.  
    38. 	#endregion
    39. }

    目前支持的数据结构：

    字符串testString字符串数组testStringArray字符串二维数组testStringArray2
    InttestIntInt数组testIntArrayInt二维数组testIntArray2
    FloattestFloatFloat数组testFloatArrayFloat二维数组testFloatArray2
    BooltestBoolBool数组testBoolArrayBool二维数组testBoolArray2
    Enum|枚举名(或枚举值)testEnumEnum数组testEnumArrayEnum二维数组不支持
    Vector2testVector2Vector2数组testVector2ArrayVector2二维数组testVector2Array2
    Vector3testVector3Vector3数组testVector3ArrayVector3二维数组testVector3Array2
    Vector2InttestVector2IntVector2Int数组testVector2IntArrayVector2Int二维数组testVector2IntArray2
    Vector3InttestVector3IntVector3Int数组testVector3IntArrayVector3Int二维数组testVector3IntArray2
    ColortestColorColor数组testColorArrayColor二维数组testColorArray2
    Color32testColor32Color32数组testColor32ArrayColor32二维数组testColor32Array2

    因为Unity不能序列化二维数组，这里改成一维数组+结构体的方式实现：

    1. [Serializable]
    2. public struct StringArr
    3. {
    4.     public string[] array;
    5. }
    6.  
    7. //二维数组表示方式： StringArr[]

    Asset数据文件：

    在自动生成数据的C#类时，会同步生成Asset文件的创建类，用于自动创建Asset文件并序列化数据。

    优点：

    • 数据修改后只需要重新一键生成即可
    • 每个Excel对应一个类，使用灵活，对Excel限制少
    • 自动创建C#类，不需要对每个Excel手动写代码，每条数据对应字段，不需要拆箱装修
    • 自动创建ScriptableObject的Asset文件，自动序列化数据，方便查看，可以手动修改调整，不需要每次改动都在Excel里操作
    • 在游戏内直接读取Asset的ScriptableObject子类，不需要额外操作，业务层直接调取数据字段

    使用方法：

    • 按照标准格式配置Excel
    • 一键生成C#类、Asset文件
    • 项目运行时加载Asset资源，调用Init初始化，Get函数获取对应字段值即可

    完整代码：

    扩展Unity编辑器窗口：

    1. using UnityEngine;
    2. using UnityEditor;
    3. using System.IO;
    4. using System.Collections.Generic;
    5. using System.Linq;
    6.  
    7. public class BuildExcelWindow : EditorWindow
    8. {
    9.     [MenuItem("MyTools/Excel Window",priority = 100)]
    10.     public static void ShowReadExcelWindow()
    11.     {
    12.         BuildExcelWindow window = GetWindow<BuildExcelWindow>(true);
    13.         window.Show();
    14.         window.minSize = new Vector2(475,475);
    15.     }
    16.  
    17.     //Excel读取路径，绝对路径，放在Assets同级路径
    18.     private static string excelReadAbsolutePath;
    19.  
    20.     //自动生成C#类文件路径，绝对路径
    21.     private static string scriptSaveAbsolutePath;
    22.     private static string scriptSaveRelativePath;
    23.     //自动生成Asset文件路径，相对路径
    24.     private static string assetSaveRelativePath;
    25.  
    26.     private List<string> fileNameList = new List<string>();
    27.     private List<string> filePathList = new List<string>();
    28.  
    29.     private void Awake()
    30.     {
    31.         titleContent.text = "Excel配置表读取";
    32.  
    33.         excelReadAbsolutePath = Application.dataPath.Replace("Assets","Excel");
    34.         scriptSaveAbsolutePath = Application.dataPath + CheckEditorPath("/Script/Excel/AutoCreateCSCode");
    35.         scriptSaveRelativePath = CheckEditorPath("Assets/Script/Excel/AutoCreateCSCode");
    36.         assetSaveRelativePath = CheckEditorPath("Assets/AssetData/Excel/AutoCreateAsset");
    37.     }
    38.  
    39.     private void OnEnable()
    40.     {
    41.         RefreshExcelFile();
    42.     }
    43.  
    44.     private void OnDisable()
    45.     {
    46.         fileNameList.Clear();
    47.         filePathList.Clear();
    48.     }
    49.  
    50.     private Vector2 scrollPosition = Vector2.zero;
    51.     private void OnGUI()
    52.     {
    53.         GUILayout.Space(10);
    54.  
    55.         scrollPosition = GUILayout.BeginScrollView(scrollPosition,GUILayout.Width(position.width),GUILayout.Height(position.height));
    56.  
    57.         //展示路径
    58.         GUILayout.BeginHorizontal(GUILayout.Height(20));
    59.         if(GUILayout.Button("Excel读取路径",GUILayout.Width(100)))
    60.         {
    61.             EditorUtility.OpenWithDefaultApp(excelReadAbsolutePath);
    62.             Debug.Log(excelReadAbsolutePath);
    63.         }
    64.         if(GUILayout.Button("Script保存路径",GUILayout.Width(100)))
    65.         {
    66.             SelectObject(scriptSaveRelativePath);
    67.         }
    68.         if(GUILayout.Button("Asset保存路径",GUILayout.Width(100)))
    69.         {
    70.             SelectObject(assetSaveRelativePath);
    71.         }
    72.         GUILayout.EndHorizontal();
    73.  
    74.         GUILayout.Space(5);
    75.  
    76.         //Excel列表
    77.  
    78.         GUILayout.Label("Excel列表：");
    79.         for(int i = 0; i < fileNameList.Count; i++)
    80.         {
    81.             GUILayout.BeginHorizontal("Box",GUILayout.Height(40));
    82.  
    83.             GUILayout.Label($"{i}:","Titlebar Foldout",GUILayout.Width(30),GUILayout.Height(35));
    84.             GUILayout.Box(fileNameList[i],"MeTransitionBlock",GUILayout.MinWidth(200),GUILayout.Height(35));
    85.             GUILayout.Space(10);
    86.  
    87.             //生成CS代码
    88.             if(GUILayout.Button("Create Script",GUILayout.Width(100),GUILayout.Height(30)))
    89.             {
    90.                 ExcelDataReader.ReadOneExcelToCode(filePathList[i],scriptSaveAbsolutePath);
    91.             }
    92.             //生成Asset文件
    93.             if(GUILayout.Button("Create Asset",GUILayout.Width(100),GUILayout.Height(30)))
    94.             {
    95.                 ExcelDataReader.CreateOneExcelAsset(filePathList[i],assetSaveRelativePath);
    96.             }
    97.  
    98.             GUILayout.EndHorizontal();
    99.             GUILayout.Space(5);
    100.         }
    101.         GUILayout.Space(10);
    102.  
    103.         //一键处理所有Excel
    104.  
    105.         GUILayout.Label("一键操作：");
    106.         GUILayout.BeginHorizontal("Box",GUILayout.Height(40));
    107.  
    108.         GUILayout.Label("all","Titlebar Foldout",GUILayout.Width(30),GUILayout.Height(35));
    109.         GUILayout.Box("All Excel","MeTransitionBlock",GUILayout.MinWidth(200),GUILayout.Height(35));
    110.         GUILayout.Space(10);
    111.  
    112.         if(GUILayout.Button("Create Script",GUILayout.Width(100),GUILayout.Height(30)))
    113.         {
    114.             ExcelDataReader.ReadAllExcelToCode(excelReadAbsolutePath,scriptSaveAbsolutePath);
    115.         }
    116.         if(GUILayout.Button("Create Asset",GUILayout.Width(100),GUILayout.Height(30)))
    117.         {
    118.             ExcelDataReader.CreateAllExcelAsset(excelReadAbsolutePath,assetSaveRelativePath);
    119.         }
    120.         GUILayout.EndHorizontal();
    121.  
    122.         //
    123.         GUILayout.Space(20);
    124.         //
    125.         GUILayout.EndScrollView();
    126.     }
    127.  
    128.     //读取指定路径下的Excel文件名
    129.     private void RefreshExcelFile()
    130.     {
    131.         fileNameList.Clear();
    132.         filePathList.Clear();
    133.  
    134.         if(!Directory.Exists(excelReadAbsolutePath))
    135.         {
    136.             Debug.LogError("无效路径：" + excelReadAbsolutePath);
    137.             return;
    138.         }
    139.         string[] excelFileFullPaths = Directory.GetFiles(excelReadAbsolutePath,"*.xlsx");
    140.  
    141.         if(excelFileFullPaths == null || excelFileFullPaths.Length == 0)
    142.         {
    143.             Debug.LogError(excelReadAbsolutePath + "路径下没有找到Excel文件");
    144.             return;
    145.         }
    146.  
    147.         filePathList.AddRange(excelFileFullPaths);
    148.         for(int i = 0; i < filePathList.Count; i++)
    149.         {
    150.             fileNameList.Add(Path.GetFileName(filePathList[i]));
    151.         }
    152.         Debug.Log("找到Excel文件：" + fileNameList.Count + "个");
    153.     }
    154.  
    155.     private void SelectObject(string targetPath)
    156.     {
    157.         Object targetObj = AssetDatabase.LoadAssetAtPath<Object>(targetPath);
    158.         EditorGUIUtility.PingObject(targetObj);
    159.         Selection.activeObject = targetObj;
    160.         Debug.Log(targetPath);
    161.     }
    162.  
    163.     private static string CheckEditorPath(string path)
    164.     {
    165. #if UNITY_EDITOR_WIN
    166.         return path.Replace("/","\\");
    167. #elif UNITY_EDITOR_OSX
    168.         return path.Replace("\\","/");
    169. #else
    170.         return path;
    171. #endif
    172.     }
    173. }

    Excel数据读取类： 

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4. using System.IO;
    5. using Excel;
    6. using System.Reflection;
    7. using System;
    8. using System.Linq;
    9.  
    10. public class ExcelDataReader
    11. {
    12.     //Excel第1行对应特殊标记
    13.     private const int specialSignRow = 0;
    14.     //Excel第2行对应中文说明
    15.     private const int excelNodeRow = 1;
    16.     //Excel第3行对应字段名称
    17.     private const int excelNameRow = 2;
    18.     //Excel第4行对应字段类型
    19.     private const int excelTypeRow = 3;
    20.     //Excel第5行及以后对应字段值
    21.     private const int excelDataRow = 4;
    22.  
    23.     //标记注释行/列
    24.     private const string annotationSign = "//";
    25.  
    26.     #region --- Read Excel ---
    27.  
    28.     //创建Excel对应的C#类
    29.     public static void ReadAllExcelToCode(string allExcelPath,string codeSavePath)
    30.     {
    31.         //读取所有Excel文件
    32.         //指定目录中与指定的搜索模式和选项匹配的文件的完整名称（包含路径）的数组；如果未找到任何文件，则为空数组。
    33.         string[] excelFileFullPaths = Directory.GetFiles(allExcelPath,"*.xlsx");
    34.         if(excelFileFullPaths == null || excelFileFullPaths.Length == 0)
    35.         {
    36.             Debug.Log("Excel file count == 0");
    37.             return;
    38.         }
    39.         //遍历所有Excel，创建C#类
    40.         for(int i = 0; i < excelFileFullPaths.Length; i++)
    41.         {
    42.             ReadOneExcelToCode(excelFileFullPaths[i],codeSavePath);
    43.         }
    44.     }
    45.  
    46.     //创建Excel对应的C#类
    47.     public static void ReadOneExcelToCode(string excelFullPath,string codeSavePath)
    48.     {
    49.         //解析Excel获取中间数据
    50.         ExcelMediumData excelMediumData = CreateClassCodeByExcelPath(excelFullPath);
    51.         if(excelMediumData == null)
    52.         {
    53.             Debug.LogError($"读取Excel失败 : {excelFullPath}");
    54.             return;
    55.         }
    56.         if(!excelMediumData.isValid)
    57.         {
    58.             Debug.LogError($"读取Excel失败，Excel标记失效 : {excelMediumData.excelName}");
    59.             return;
    60.         }
    61.  
    62.         if(!excelMediumData.isCreateCSharp && !excelMediumData.isCreateAssignment)
    63.         {
    64.             Debug.LogError($"读取Excel失败，Excel不允许生成CSCode : {excelMediumData.excelName}");
    65.             return;
    66.         }
    67.  
    68.         //根据数据生成C#脚本
    69.         string classCodeStr = ExcelCodeCreater.CreateCodeStrByExcelData(excelMediumData);
    70.         if(string.IsNullOrEmpty(classCodeStr))
    71.         {
    72.             Debug.LogError($"解析Excel失败 : {excelMediumData.excelName}");
    73.             return;
    74.         }
    75.  
    76.         //检查导出路径
    77.         if(!Directory.Exists(codeSavePath))
    78.             Directory.CreateDirectory(codeSavePath);
    79.         //类名
    80.         string codeFileName = excelMediumData.excelName + "ExcelData";
    81.         //写文件，生成CS类文件
    82.         StreamWriter sw = new StreamWriter($"{codeSavePath}/{codeFileName}.cs");
    83.         sw.WriteLine(classCodeStr);
    84.         sw.Close();
    85.         //
    86.         UnityEditor.AssetDatabase.SaveAssets();
    87.         UnityEditor.AssetDatabase.Refresh();
    88.         //
    89.         Debug.Log($"生成Excel的CS成功 : {excelMediumData.excelName}");
    90.     }
    91.  
    92.     #endregion
    93.  
    94.     #region --- Create Asset ---
    95.  
    96.     //创建Excel对应的Asset数据文件
    97.     public static void CreateAllExcelAsset(string allExcelPath,string assetSavePath)
    98.     {
    99.         //读取所有Excel文件
    100.         //指定目录中与指定的搜索模式和选项匹配的文件的完整名称（包含路径）的数组；如果未找到任何文件，则为空数组。
    101.         string[] excelFileFullPaths = Directory.GetFiles(allExcelPath,"*.xlsx");
    102.         if(excelFileFullPaths == null || excelFileFullPaths.Length == 0)
    103.         {
    104.             Debug.Log("Excel file count == 0");
    105.             return;
    106.         }
    107.         //遍历所有Excel，创建Asset
    108.         for(int i = 0; i < excelFileFullPaths.Length; i++)
    109.         {
    110.             CreateOneExcelAsset(excelFileFullPaths[i],assetSavePath);
    111.         }
    112.     }
    113.  
    114.     //创建Excel对应的Asset数据文件
    115.     public static void CreateOneExcelAsset(string excelFullPath,string assetSavePath)
    116.     {
    117.         //解析Excel获取中间数据
    118.         ExcelMediumData excelMediumData = CreateClassCodeByExcelPath(excelFullPath);
    119.         if(excelMediumData == null)
    120.         {
    121.             Debug.LogError($"读取Excel失败 : {excelFullPath}");
    122.             return;
    123.         }
    124.         if(!excelMediumData.isValid)
    125.         {
    126.             Debug.LogError($"读取Excel失败，Excel标记失效 : {excelMediumData.excelName}");
    127.             return;
    128.         }
    129.  
    130.         if(!excelMediumData.isCreateAsset)
    131.         {
    132.             Debug.LogError($"读取Excel失败，Excel不允许生成Asset : {excelMediumData.excelName}");
    133.             return;
    134.         }
    135.  
    136.         获取当前程序集
    137.         //Assembly assembly = Assembly.GetExecutingAssembly();
    138.         创建类的实例，返回为 object 类型，需要强制类型转换，assembly.CreateInstance("类的完全限定名（即包括命名空间）");
    139.         //object class0bj = assembly.CreateInstance(excelMediumData.excelName + "Assignment",true);
    140.  
    141.         //必须遍历所有程序集来获得类型。当前在Assembly-CSharp-Editor中，目标类型在Assembly-CSharp中，不同程序将无法获取类型
    142.         Type assignmentType = null;
    143.         string assetAssignmentName = excelMediumData.excelName + "AssetAssignment";
    144.         foreach(var asm in AppDomain.CurrentDomain.GetAssemblies())
    145.         {
    146.             //查找目标类型
    147.             Type tempType = asm.GetType(assetAssignmentName);
    148.             if(tempType != null)
    149.             {
    150.                 assignmentType = tempType;
    151.                 break;
    152.             }
    153.         }
    154.         if(assignmentType == null)
    155.         {
    156.             Debug.LogError($"创界Asset失败，未找到Asset生成类 : {excelMediumData.excelName}");
    157.             return;
    158.         }
    159.  
    160.         //反射获取方法
    161.         MethodInfo methodInfo = assignmentType.GetMethod("CreateAsset");
    162.         if(methodInfo == null)
    163.         {
    164.             if(assignmentType == null)
    165.             {
    166.                 Debug.LogError($"创界Asset失败，未找到Asset创建函数 : {excelMediumData.excelName}");
    167.                 return;
    168.             }
    169.         }
    170.  
    171.         methodInfo.Invoke(null,new object[] { excelMediumData,assetSavePath });
    172.         //创建Asset文件成功
    173.         Debug.Log($"生成Excel的Asset成功 : {excelMediumData.excelName}");
    174.     }
    175.  
    176.     #endregion
    177.  
    178.     #region --- private ---
    179.  
    180.     //解析Excel，创建中间数据
    181.     private static ExcelMediumData CreateClassCodeByExcelPath(string excelFileFullPath)
    182.     {
    183.         if(string.IsNullOrEmpty(excelFileFullPath))
    184.             return null;
    185.  
    186.         excelFileFullPath = excelFileFullPath.Replace("\\","/");
    187.         //读取Excel
    188.         FileStream stream = File.Open(excelFileFullPath,FileMode.Open,FileAccess.Read);
    189.         if(stream == null)
    190.             return null;
    191.         //解析Excel
    192.         IExcelDataReader excelReader = ExcelReaderFactory.CreateOpenXmlReader(stream);
    193.         //无效Excel
    194.         if(excelReader == null || !excelReader.IsValid)
    195.         {
    196.             Debug.Log("Invalid excel ： " + excelFileFullPath);
    197.             return null;
    198.         }
    199.  
    200.         Debug.Log("开始解析Excel : " + excelReader.Name);
    201.  
    202.         //记录Excel数据
    203.         ExcelMediumData excelMediumData = new ExcelMediumData();
    204.  
    205.         //Excel名字
    206.         excelMediumData.excelName = excelReader.Name;
    207.  
    208.         //当前遍历的行
    209.         int curRowIndex = 0;
    210.         //开始读取，按行遍历
    211.         while(excelReader.Read())
    212.         {
    213.             //这一行没有读取到数据，视为无效行数据
    214.             if(excelReader.FieldCount <= 0)
    215.             {
    216.                 curRowIndex++;
    217.                 continue;
    218.             }
    219.             //读取每一行的完整数据
    220.             string[] datas = new string[excelReader.FieldCount];
    221.             for(int j = 0; j < excelReader.FieldCount; ++j)
    222.             {
    223.                 //可以直接读取指定类型数据，不过只支持有限数据类型，这里统一读取string，然后再数据转化
    224.                 //excelReader.GetInt32(j); excelReader.GetFloat(j);
    225.  
    226.                 //读取每一个单元格数据
    227.                 datas[j] = excelReader.GetString(j);
    228.             }
    229.  
    230.             switch(curRowIndex)
    231.             {
    232.                 case specialSignRow:
    233.                     //特殊标记行
    234.                     string specialSignStr = datas[0];
    235.                     if(specialSignStr.Length >= 4)
    236.                     {
    237.                         excelMediumData.isValid = specialSignStr[0] == 'T';
    238.                         excelMediumData.isCreateCSharp = specialSignStr[1] == 'T';
    239.                         excelMediumData.isCreateAssignment = specialSignStr[2] == 'T';
    240.                         excelMediumData.isCreateAsset = specialSignStr[3] == 'T';
    241.                     }
    242.                     else
    243.                     {
    244.                         Debug.LogError("未解析到特殊标记");
    245.                     }
    246.                     break;
    247.                 case excelNodeRow:
    248.                     //数据注释行
    249.                     excelMediumData.propertyNodeArray = datas;
    250.                     break;
    251.                 case excelNameRow:
    252.                     //数据名称行
    253.                     excelMediumData.propertyNameArray = datas;
    254.                     //注释列号
    255.                     for(int i = 0; i < datas.Length; i++)
    256.                     {
    257.                         if(string.IsNullOrEmpty(datas[i]) || datas[i].StartsWith(annotationSign))
    258.                             excelMediumData.annotationColList.Add(i);
    259.                     }
    260.                     break;
    261.                 case excelTypeRow:
    262.                     //数据类型行
    263.                     excelMediumData.propertyTypeArray = datas;
    264.                     break;
    265.                 default:
    266.                     //数据内容行
    267.                     excelMediumData.allRowItemList.Add(datas);
    268.                     //注释行号
    269.                     if(string.IsNullOrEmpty(datas[0]) || datas[0].StartsWith(annotationSign))
    270.                         excelMediumData.annotationRowList.Add(excelMediumData.allRowItemList.Count - 1);
    271.                     break;
    272.             }
    273.             //
    274.             curRowIndex++;
    275.         }
    276.  
    277.         if(CheckExcelMediumData(ref excelMediumData))
    278.         {
    279.             Debug.Log("读取Excel成功");
    280.             return excelMediumData;
    281.         }
    282.         else
    283.         {
    284.             Debug.LogError("读取Excel失败");
    285.             return null;
    286.         }
    287.     }
    288.  
    289.     //校验Excel数据
    290.     private static bool CheckExcelMediumData(ref ExcelMediumData mediumData)
    291.     {
    292.         if(mediumData == null)
    293.             return false;
    294.  
    295.         //检查数据有效性
    296.  
    297.         if(!mediumData.isValid)
    298.         {
    299.             Debug.LogError("Excel被标记无效");
    300.             return false;
    301.         }
    302.  
    303.         if(string.IsNullOrEmpty(mediumData.excelName))
    304.         {
    305.             Debug.LogError("Excel名字为空");
    306.             return false;
    307.         }
    308.  
    309.         if(mediumData.propertyNameArray == null || mediumData.propertyNameArray.Length == 0)
    310.         {
    311.             Debug.LogError("未解析到数据名称");
    312.             return false;
    313.         }
    314.         if(mediumData.propertyTypeArray == null || mediumData.propertyTypeArray.Length == 0)
    315.         {
    316.             Debug.LogError("未解析到数据类型");
    317.             return false;
    318.         }
    319.         if(mediumData.propertyNameArray.Length != mediumData.propertyTypeArray.Length)
    320.         {
    321.             Debug.LogError("数据名称与数据类型数量不一致");
    322.             return false;
    323.         }
    324.         if(mediumData.allRowItemList.Count == 0)
    325.         {
    326.             Debug.LogError("数据内容为空");
    327.             return false;
    328.         }
    329.  
    330.         if(mediumData.propertyNameArray[0] != "id")
    331.         {
    332.             Debug.LogError("第一个字段必须是id字段");
    333.             return false;
    334.         }
    335.  
    336.         return true;
    337.     }
    338.  
    339.     #endregion
    340.  
    341. }

    C#代码生成类：

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4. using System.Text;
    5. using System.Linq;
    6. using System;
    7.  
    8. public class ExcelCodeCreater
    9. {
    10.  
    11.     //创建代码，生成数据C#类
    12.     public static string CreateCodeStrByExcelData(ExcelMediumData excelMediumData)
    13.     {
    14.         if(excelMediumData == null)
    15.             return null;
    16.  
    17.         //行数据类名
    18.         string itemClassName = excelMediumData.excelName + "ExcelItem";
    19.         //整体数据类名
    20.         string dataClassName = excelMediumData.excelName + "ExcelData";
    21.  
    22.         //开始生成类
    23.         StringBuilder classSource = new StringBuilder();
    24.         classSource.AppendLine("/*Auto Create, Don't Edit !!!*/");
    25.         classSource.AppendLine();
    26.         //添加引用
    27.         classSource.AppendLine("using UnityEngine;");
    28.         classSource.AppendLine("using System.Collections.Generic;");
    29.         classSource.AppendLine("using System;");
    30.         classSource.AppendLine("using System.IO;");
    31.         classSource.AppendLine();
    32.         //生成CSharp数据类
    33.         if(excelMediumData.isCreateCSharp)
    34.         {
    35.             //生成行数据类，记录每行数据
    36.             classSource.AppendLine(CreateExcelRowItemClass(itemClassName,excelMediumData));
    37.             classSource.AppendLine();
    38.             //生成整体数据类，记录整个Excel的所有行数据
    39.             classSource.AppendLine(CreateExcelAllDataClass(dataClassName,itemClassName,excelMediumData));
    40.             classSource.AppendLine();
    41.         }
    42.         //生成Asset创建类
    43.         if(excelMediumData.isCreateAssignment)
    44.         {
    45.             //生成Asset操作类，用于自动创建Excel对应的Asset文件并赋值
    46.             classSource.AppendLine(CreateExcelAssetClass(excelMediumData));
    47.             classSource.AppendLine();
    48.         }
    49.         //
    50.         return classSource.ToString();
    51.     }
    52.  
    53.     //----------
    54.  
    55.     //生成行数据类
    56.     private static string CreateExcelRowItemClass(string itemClassName,ExcelMediumData excelMediumData)
    57.     {
    58.         //生成Excel行数据类
    59.         StringBuilder classSource = new StringBuilder();
    60.         //类名
    61.         classSource.AppendLine("[Serializable]");
    62.         classSource.AppendLine($"public class {itemClassName} : ExcelItemBase");
    63.         classSource.AppendLine("{");
    64.         //声明所有字段
    65.         for(int i = 0; i < excelMediumData.propertyNameArray.Length; i++)
    66.         {
    67.             //跳过注释字段
    68.             if(excelMediumData.annotationColList.Contains(i))
    69.                 continue;
    70.  
    71.             //添加注释
    72.             if(i < excelMediumData.propertyNodeArray.Length)
    73.             {
    74.                 string propertyNode = excelMediumData.propertyNodeArray[i];
    75.                 if(!string.IsNullOrEmpty(propertyNode))
    76.                 {
    77.                     classSource.AppendLine("\t/// <summary>");
    78.                     classSource.AppendLine($"\t/// {propertyNode}");
    79.                     classSource.AppendLine("\t/// </summary>>");
    80.                 }
    81.             }
    82.  
    83.             //声明行数据类的字段
    84.             string propertyName = excelMediumData.propertyNameArray[i];
    85.             string propertyType = excelMediumData.propertyTypeArray[i];
    86.             string typeStr = GetPropertyType(propertyType);
    87.             classSource.AppendLine($"\tpublic {typeStr} {propertyName};");
    88.         }
    89.         classSource.AppendLine("}");
    90.         return classSource.ToString();
    91.     }
    92.  
    93.     //----------
    94.  
    95.     //生成整体数据类
    96.     private static string CreateExcelAllDataClass(string dataClassName,string itemClassName,ExcelMediumData excelMediumData)
    97.     {
    98.         StringBuilder classSource = new StringBuilder();
    99.         //类名
    100.         classSource.AppendLine($"public class {dataClassName} : ExcelDataBase<{itemClassName}>");
    101.         classSource.AppendLine("{");
    102.         //声明字段，行数据类数组
    103.         classSource.AppendLine($"\tpublic {itemClassName}[] items;");
    104.         classSource.AppendLine();
    105.         //id字段类型
    106.         string idTypeStr = GetPropertyType(excelMediumData.propertyTypeArray[0]);
    107.         //声明字典
    108.         classSource.AppendLine($"\tpublic Dictionary<{idTypeStr},{itemClassName}> itemDic = new Dictionary<{idTypeStr},{itemClassName}>();");
    109.         classSource.AppendLine();
    110.         //字段初始化方法
    111.         classSource.AppendLine("\tpublic void Init()");
    112.         classSource.AppendLine("\t{");
    113.         classSource.AppendLine("\t\titemDic.Clear();");
    114.         classSource.AppendLine("\t\tif(items != null && items.Length > 0)");
    115.         classSource.AppendLine("\t\t{");
    116.         classSource.AppendLine("\t\t\tfor(int i = 0; i < items.Length; i++)");
    117.         classSource.AppendLine("\t\t\t{");
    118.         classSource.AppendLine("\t\t\t\titemDic.Add(items[i].id, items[i]);");
    119.         classSource.AppendLine("\t\t\t}");
    120.         classSource.AppendLine("\t\t}");
    121.         classSource.AppendLine("\t}");
    122.         classSource.AppendLine();
    123.         //字典获取方法
    124.         classSource.AppendLine($"\tpublic {itemClassName} Get{itemClassName}({idTypeStr} id)");
    125.         classSource.AppendLine("\t{");
    126.         classSource.AppendLine("\t\tif(itemDic.ContainsKey(id))");
    127.         classSource.AppendLine("\t\t\treturn itemDic[id];");
    128.         classSource.AppendLine("\t\telse");
    129.         classSource.AppendLine("\t\t\treturn null;");
    130.         classSource.AppendLine("\t}");
    131.  
    132.         //每个字段Get函数
    133.         classSource.AppendLine("\t#region --- Get Method ---");
    134.         classSource.AppendLine();
    135.  
    136.         for(int i = 1; i < excelMediumData.propertyNameArray.Length; i++)
    137.         {
    138.             if(excelMediumData.annotationColList.Contains(i))
    139.                 continue;
    140.             string propertyName = excelMediumData.propertyNameArray[i];
    141.             string propertyType = excelMediumData.propertyTypeArray[i];
    142.             //每个字段Get函数
    143.             classSource.AppendLine(CreateCodePropertyMethod(itemClassName,idTypeStr,propertyName,propertyType));
    144.         }
    145.         classSource.AppendLine("\t#endregion");
    146.         classSource.AppendLine("}");
    147.         return classSource.ToString();
    148.     }
    149.  
    150.     //生成数据字段对应Get方法
    151.     private static string CreateCodePropertyMethod(string itemClassName,string idTypeStr,string propertyName,string propertyType)
    152.     {
    153.         StringBuilder methodBuilder = new StringBuilder();
    154.         string itemNameStr = propertyName.FirstOrDefault().ToString().ToUpper() + propertyName.Substring(1);
    155.         string itemTypeStr = GetPropertyType(propertyType);
    156.         //字段Get函数
    157.         methodBuilder.AppendLine($"\tpublic {itemTypeStr} Get{itemNameStr}({idTypeStr} id)");
    158.         methodBuilder.AppendLine("\t{");
    159.         methodBuilder.AppendLine($"\t\tvar item = Get{itemClassName}(id);");
    160.         methodBuilder.AppendLine("\t\tif(item == null)");
    161.         methodBuilder.AppendLine("\t\t\treturn default;");
    162.         methodBuilder.AppendLine($"\t\treturn item.{propertyName};");
    163.         methodBuilder.AppendLine("\t}");
    164.         //如果是一维数组
    165.         if(propertyType.Contains("[]"))
    166.         {
    167.             //typeStr:int[]或IntArr[] ,返回值:int或IntArr
    168.             //string itemTypeStr1d = GetPropertyType(propertyType.Replace("[]",""));
    169.             string itemTypeStr1d = itemTypeStr.Replace("[]","");
    170.             methodBuilder.AppendLine($"\tpublic {itemTypeStr1d} Get{itemNameStr}({idTypeStr} id, int index)");
    171.             methodBuilder.AppendLine("\t{");
    172.             methodBuilder.AppendLine($"\t\tvar item0 = Get{itemClassName} (id);");
    173.             methodBuilder.AppendLine("\t\tif(item0 == null)");
    174.             methodBuilder.AppendLine("\t\t\treturn default;");
    175.             methodBuilder.AppendLine($"\t\tvar item1 = item0.{propertyName};");
    176.             methodBuilder.AppendLine("\t\tif(item1 == null || index < 0 || index >= item1.Length)");
    177.             methodBuilder.AppendLine("\t\t\treturn default;");
    178.             methodBuilder.AppendLine("\t\treturn item1[index];");
    179.             methodBuilder.AppendLine("\t}");
    180.         }
    181.         //如果是二维数组
    182.         if(propertyType.Contains("[][]"))
    183.         {
    184.             //propertyType:int[][], 返回值:int
    185.             string itemTypeStr1d = GetPropertyType(propertyType.Replace("[][]",""));
    186.             methodBuilder.AppendLine($"\tpublic {itemTypeStr1d} Get{itemNameStr}({idTypeStr} id, int index1, int index2)");
    187.             methodBuilder.AppendLine("\t{");
    188.             methodBuilder.AppendLine($"\t\tvar item0 = Get{itemClassName}(id);");
    189.             methodBuilder.AppendLine("\t\tif(item0 == null)");
    190.             methodBuilder.AppendLine("\t\t\treturn default;");
    191.             methodBuilder.AppendLine($"\t\tvar item1 = item0.{propertyName};");
    192.             methodBuilder.AppendLine("\t\tif(item1 == null || index1 < 0 || index1 >= item1.Length)");
    193.             methodBuilder.AppendLine("\t\t\treturn default;");
    194.             methodBuilder.AppendLine("\t\tvar item2 = item1[index1];");
    195.             methodBuilder.AppendLine("\t\tif(item2.array == null || index2 < 0 || index2 >= item2.array.Length)");
    196.             methodBuilder.AppendLine("\t\t\treturn default;");
    197.             methodBuilder.AppendLine("\t\treturn item2.array[index2];");
    198.             methodBuilder.AppendLine("\t}");
    199.         }
    200.         //
    201.         return methodBuilder.ToString();
    202.     }
    203.  
    204.     //----------
    205.  
    206.     //生成Asset创建类
    207.     private static string CreateExcelAssetClass(ExcelMediumData excelMediumData)
    208.     {
    209.         string itemClassName = excelMediumData.excelName + "ExcelItem";
    210.         string dataClassName = excelMediumData.excelName + "ExcelData";
    211.         string assignmentClassName = excelMediumData.excelName + "AssetAssignment";
    212.  
    213.         StringBuilder classSource = new StringBuilder();
    214.         classSource.AppendLine("#if UNITY_EDITOR");
    215.         //类名
    216.         classSource.AppendLine($"public class {assignmentClassName}");
    217.         classSource.AppendLine("{");
    218.         //方法名
    219.         classSource.AppendLine("\tpublic static bool CreateAsset(ExcelMediumData excelMediumData, string excelAssetPath)");
    220.         //方法体，若有需要可加入try/catch
    221.         classSource.AppendLine("\t{");
    222.         classSource.AppendLine("\t\tvar allRowItemDicList = excelMediumData.GetAllRowItemDicList();");
    223.         classSource.AppendLine("\t\tif(allRowItemDicList == null || allRowItemDicList.Count == 0)");
    224.         classSource.AppendLine("\t\t\treturn false;");
    225.         classSource.AppendLine();
    226.         classSource.AppendLine("\t\tint rowCount = allRowItemDicList.Count;");
    227.         classSource.AppendLine($"\t\t{dataClassName} excelDataAsset = ScriptableObject.CreateInstance<{dataClassName}>();");
    228.         classSource.AppendLine($"\t\texcelDataAsset.items = new {itemClassName}[rowCount];");
    229.         classSource.AppendLine();
    230.         classSource.AppendLine("\t\tfor(int i = 0; i < rowCount; i++)");
    231.         classSource.AppendLine("\t\t{");
    232.         classSource.AppendLine("\t\t\tvar itemRowDic = allRowItemDicList[i];");
    233.         classSource.AppendLine($"\t\t\texcelDataAsset.items[i] = new {itemClassName}();");
    234.  
    235.         for(int i = 0; i < excelMediumData.propertyNameArray.Length; i++)
    236.         {
    237.             if(excelMediumData.annotationColList.Contains(i))
    238.                 continue;
    239.             string propertyName = excelMediumData.propertyNameArray[i];
    240.             string propertyType = excelMediumData.propertyTypeArray[i];
    241.             classSource.Append($"\t\t\texcelDataAsset.items[i].{propertyName} = ");
    242.             classSource.Append(AssignmentCodeProperty(propertyName,propertyType));
    243.             classSource.AppendLine(";");
    244.         }
    245.         classSource.AppendLine("\t\t}");
    246.         classSource.AppendLine("\t\tif(!Directory.Exists(excelAssetPath))");
    247.         classSource.AppendLine("\t\t\tDirectory.CreateDirectory(excelAssetPath);");
    248.         classSource.AppendLine($"\t\tstring fullPath = Path.Combine(excelAssetPath,typeof({dataClassName}).Name) + \".asset\";");
    249.         classSource.AppendLine("\t\tUnityEditor.AssetDatabase.DeleteAsset(fullPath);");
    250.         classSource.AppendLine("\t\tUnityEditor.AssetDatabase.CreateAsset(excelDataAsset,fullPath);");
    251.         classSource.AppendLine("\t\tUnityEditor.AssetDatabase.Refresh();");
    252.         classSource.AppendLine("\t\treturn true;");
    253.         classSource.AppendLine("\t}");
    254.         //          
    255.         classSource.AppendLine("}");
    256.         classSource.AppendLine("#endif");
    257.         return classSource.ToString();
    258.     }
    259.  
    260.     //声明Asset操作类字段
    261.     private static string AssignmentCodeProperty(string propertyName,string propertyType)
    262.     {
    263.         string stringValue = $"itemRowDic[\"{propertyName}\"]";
    264.         string typeStr = GetPropertyType(propertyType);
    265.         switch(typeStr)
    266.         {
    267.             //字段
    268.             case "int":
    269.                 return "StringUtility.StringToInt(" + stringValue + ")";
    270.             case "float":
    271.                 return "StringUtility.StringToFloat(" + stringValue + ")";
    272.             case "bool":
    273.                 return "StringUtility.StringToBool(" + stringValue + ")";
    274.             case "Vector2":
    275.                 return "StringUtility.StringToVector2(" + stringValue + ")";
    276.             case "Vector3":
    277.                 return "StringUtility.StringToVector3(" + stringValue + ")";
    278.             case "Vector2Int":
    279.                 return "StringUtility.StringToVector2Int(" + stringValue + ")";
    280.             case "Vector3Int":
    281.                 return "StringUtility.StringToVector3Int(" + stringValue + ")";
    282.             case "Color":
    283.                 return "StringUtility.StringToColor(" + stringValue + ")";
    284.             case "Color32":
    285.                 return "StringUtility.StringToColor32(" + stringValue + ")";
    286.             case "string":
    287.                 return stringValue;
    288.             //一维
    289.             case "int[]":
    290.                 return "StringUtility.StringToIntArray(" + stringValue + ")";
    291.             case "float[]":
    292.                 return "StringUtility.StringToFloatArray(" + stringValue + ")";
    293.             case "bool[]":
    294.                 return "StringUtility.StringToBoolArray(" + stringValue + ")";
    295.             case "Vector2[]":
    296.                 return "StringUtility.StringToVector2Array(" + stringValue + ")";
    297.             case "Vector3[]":
    298.                 return "StringUtility.StringToVector3Array(" + stringValue + ")";
    299.             case "Vector2Int[]":
    300.                 return "StringUtility.StringToVector2IntArray(" + stringValue + ")";
    301.             case "Vector3Int[]":
    302.                 return "StringUtility.StringToVector3IntArray(" + stringValue + ")";
    303.             case "Color[]":
    304.                 return "StringUtility.StringToColorArray(" + stringValue + ")";
    305.             case "Color32[]":
    306.                 return "StringUtility.StringToColor32Array(" + stringValue + ")";
    307.             case "string[]":
    308.                 return "StringUtility.StringToStringArray(" + stringValue + ")";
    309.             //二维
    310.             case "IntArr[]":
    311.                 return "StringUtility.StringToIntArray2D(" + stringValue + ")";
    312.             case "FloatArr[]":
    313.                 return "StringUtility.StringToFloatArray2D(" + stringValue + ")";
    314.             case "BoolArr[]":
    315.                 return "StringUtility.StringToBoolArray2D(" + stringValue + ")";
    316.             case "Vector2Arr[]":
    317.                 return "StringUtility.StringToVector2Array2D(" + stringValue + ")";
    318.             case "Vector3Arr[]":
    319.                 return "StringUtility.StringToVector3Array2D(" + stringValue + ")";
    320.             case "Vector2IntArr[]":
    321.                 return "StringUtility.StringToVector2IntArray2D(" + stringValue + ")";
    322.             case "Vector3IntArr[]":
    323.                 return "StringUtility.StringToVector3IntArray2D(" + stringValue + ")";
    324.             case "ColorArr[]":
    325.                 return "StringUtility.StringToColorArray2D(" + stringValue + ")";
    326.             case "Color32Arr[]":
    327.                 return "StringUtility.StringToColor32Array2D(" + stringValue + ")";
    328.             case "StringArr[]":
    329.                 return "StringUtility.StringToStringArray2D(" + stringValue + ")";
    330.             default:
    331.                 //枚举
    332.                 if(propertyType.StartsWith("enum"))
    333.                 {
    334.                     string enumType = propertyType.Split('|').FirstOrDefault();
    335.                     string enumName = propertyType.Split('|').LastOrDefault();
    336.                     if(enumType == "enum")
    337.                         return "StringUtility.StringToEnum<" + enumName + ">(" + stringValue + ")";
    338.                     else if(enumType == "enum[]")
    339.                         return "StringUtility.StringToEnumArray<" + enumName + ">(" + stringValue + ")";
    340.                     else if(enumType == "enum[][]")
    341.                         return "StringUtility.StringToEnumArray2D<" + enumName + ">(" + stringValue + ")";
    342.                 }
    343.                 return stringValue;
    344.         }
    345.     }
    346.  
    347.     //判断字段类型
    348.     private static string GetPropertyType(string propertyType)
    349.     {
    350.         string lowerType = propertyType.ToLower();
    351.         switch(lowerType)
    352.         {
    353.             case "int":
    354.                 return "int";
    355.             case "int[]":
    356.                 return "int[]";
    357.             case "int[][]":
    358.                 return "IntArr[]";
    359.             case "float":
    360.                 return "float";
    361.             case "float[]":
    362.                 return "float[]";
    363.             case "float[][]":
    364.                 return "FloatArr[]";
    365.             case "bool":
    366.                 return "bool";
    367.             case "bool[]":
    368.                 return "bool[]";
    369.             case "bool[][]":
    370.                 return "BoolArr[]";
    371.             case "string":
    372.                 return "string";
    373.             case "string[]":
    374.                 return "string[]";
    375.             case "string[][]":
    376.                 return "StringArr[]";
    377.  
    378.             case "vector2":
    379.                 return "Vector2";
    380.             case "vector2[]":
    381.                 return "Vector2[]";
    382.             case "vector2[][]":
    383.                 return "Vector2Arr[]";
    384.             case "vector2int":
    385.                 return "Vector2Int";
    386.             case "vector2int[]":
    387.                 return "Vector2Int[]";
    388.             case "vector2int[][]":
    389.                 return "Vector2IntArr[]";
    390.  
    391.             case "vector3":
    392.                 return "Vector3";
    393.             case "vector3[]":
    394.                 return "Vector3[]";
    395.             case "vector3[][]":
    396.                 return "Vector3Arr[]";
    397.             case "vector3int":
    398.                 return "Vector3Int";
    399.             case "vector3int[]":
    400.                 return "Vector3Int[]";
    401.             case "vector3int[][]":
    402.                 return "Vector3IntArr[]";
    403.  
    404.             case "color":
    405.                 return "Color";
    406.             case "color[]":
    407.                 return "Color[]";
    408.             case "color[][]":
    409.                 return "ColorArr[]";
    410.             case "color32":
    411.                 return "Color32";
    412.             case "color32[]":
    413.                 return "Color32[]";
    414.             case "color32[][]":
    415.                 return "Color32Arr[]";
    416.  
    417.             default:
    418.                 if(propertyType.StartsWith("enum"))
    419.                 {
    420.                     string enumType = propertyType.Split('|').FirstOrDefault();
    421.                     string enumName = propertyType.Split('|').LastOrDefault();
    422.                     switch(enumType)
    423.                     {
    424.                         case "enum":
    425.                             return enumName;
    426.                         case "enum[]":
    427.                             return $"{enumName}[]";
    428.                         case "enum[][]":
    429.                             return $"EnumArr<{enumName}>[]";
    430.                         default:
    431.                             break;
    432.                     }
    433.                 }
    434.                 return "string";
    435.         }
    436.     }
    437.  
    438. }

     Excel数据中间类：

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4.  
    5. //Excel中间数据
    6. public class ExcelMediumData
    7. {
    8.     //Excel名字
    9.     public string excelName;
    10.  
    11.     //Excel是否有效
    12.     public bool isValid = false;
    13.     //是否生成CSharp数据类
    14.     public bool isCreateCSharp = false;
    15.     //是否生成Asset创建类
    16.     public bool isCreateAssignment = false;
    17.     //是否生成Asset文件
    18.     public bool isCreateAsset = false;
    19.  
    20.     //数据注释
    21.     public string[] propertyNodeArray = null;
    22.     //数据名称
    23.     public string[] propertyNameArray = null;
    24.     //数据类型
    25.     public string[] propertyTypeArray = null;
    26.     //List<每行数据内容>
    27.     public List<string[]> allRowItemList = new List<string[]>();
    28.  
    29.     //注释行号
    30.     public List<int> annotationRowList = new List<int>();
    31.     //注释列号
    32.     public List<int> annotationColList = new List<int>();
    33.  
    34.     //List<每行数据>，List<Dictionary<单元格字段名称, 单元格字段值>>
    35.     public List<Dictionary<string,string>> GetAllRowItemDicList()
    36.     {
    37.         if(propertyNameArray == null || propertyNameArray.Length == 0)
    38.             return null;
    39.         if(allRowItemList.Count == 0)
    40.             return null;
    41.  
    42.         List<Dictionary<string,string>> allRowItemDicList = new List<Dictionary<string,string>>(allRowItemList.Count);
    43.  
    44.         for(int i = 0; i < allRowItemList.Count; i++)
    45.         {
    46.             string[] rowArray = allRowItemList[i];
    47.             //跳过空数据
    48.             if(rowArray == null || rowArray.Length == 0)
    49.                 continue;
    50.             //跳过注释数据
    51.             if(annotationRowList.Contains(i))
    52.                 continue;
    53.  
    54.             //每行数据，对应字段名称和字段值
    55.             Dictionary<string,string> rowDic = new Dictionary<string,string>();
    56.             for(int j = 0; j < propertyNameArray.Length; j++)
    57.             {
    58.                 //跳过注释字段
    59.                 if(annotationColList.Contains(j))
    60.                     continue;
    61.  
    62.                 string propertyName = propertyNameArray[j];
    63.                 string propertyValue = j < rowArray.Length ? rowArray[j] : null;
    64.                 rowDic[propertyName] = propertyValue;
    65.             }
    66.             allRowItemDicList.Add(rowDic);
    67.         }
    68.         return allRowItemDicList;
    69.     }
    70.  
    71. }

    Excel数据基类、扩展类：

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4. using System.Linq;
    5. using System;
    6.  
    7. public class ExcelDataBase<T> : ScriptableObject where T : ExcelItemBase
    8. {
    9.  
    10. }
    11.  
    12. public class ExcelItemBase
    13. {
    14.  
    15. }
    16.  
    17.  
    18. [Serializable]
    19. public struct StringArr
    20. {
    21.     public string[] array;
    22. }
    23. [Serializable]
    24. public struct IntArr
    25. {
    26.     public int[] array;
    27. }
    28. [Serializable]
    29. public struct FloatArr
    30. {
    31.     public float[] array;
    32. }
    33. [Serializable]
    34. public struct BoolArr
    35. {
    36.     public bool[] array;
    37. }
    38.  
    39. [Serializable]
    40. public struct Vector2Arr
    41. {
    42.     public Vector2[] array;
    43. }
    44. [Serializable]
    45. public struct Vector3Arr
    46. {
    47.     public Vector3[] array;
    48. }
    49. [Serializable]
    50. public struct Vector2IntArr
    51. {
    52.     public Vector2Int[] array;
    53. }
    54. [Serializable]
    55. public struct Vector3IntArr
    56. {
    57.     public Vector3Int[] array;
    58. }
    59. [Serializable]
    60. public struct ColorArr
    61. {
    62.     public Color[] array;
    63. }
    64. [Serializable]
    65. public struct Color32Arr
    66. {
    67.     public Color32[] array;
    68. }
    69.  
    70. 不支持泛型枚举序列化
    71. //[Serializable]
    72. //public struct EnumArr<T> where T : Enum
    73. //{
    74. //    public T[] array;
    75. //}
    76.

    字符串工具类：

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4. using System.Text.RegularExpressions;
    5. using System;
    6. using System.Text;
    7. using System.Linq;
    8. using System.Runtime.CompilerServices;
    9.  
    10. public static class StringUtility
    11. {
    12.  
    13.     #region --- AddColor ---
    14.  
    15.     public static string AddColor(object obj,Color color)
    16.     {
    17.         return AddColor(obj,color);
    18.     }
    19.     public static string AddColor(this string str,Color color)
    20.     {
    21.         //把颜色转换为16进制字符串，添加到富文本
    22.         return string.Format("<color=#{0}>{1}</color>",ColorUtility.ToHtmlStringRGBA(color),str);
    23.     }
    24.     public static string AddColor(string str1,string str2,Color color)
    25.     {
    26.         return AddColor(str1 + str2,color);
    27.     }
    28.     public static string AddColor(string str1,string str2,string str3,Color color)
    29.     {
    30.         return AddColor(str1 + str2 + str3,color);
    31.     }
    32.  
    33.     #endregion
    34.  
    35.     #region --- string length ---
    36.  
    37.     /// <summary>
    38.     /// 化简字符串长度
    39.     /// </summary>
    40.     /// <param name="targetStr"></param>
    41.     /// <param name="targetLength">目标长度，英文字符==1，中文字符==2</param>
    42.     /// <returns></returns>
    43.     public static string AbbrevStringWithinLength(string targetStr,int targetLength,string abbrevPostfix)
    44.     {
    45.         //C#实际统计：一个中文字符长度==1，英文字符长度==1
    46.         //UI显示要求：一个中文字符长度==2，英文字符长度==1
    47.  
    48.         //校验参数
    49.         if(string.IsNullOrEmpty(targetStr) || targetLength <= 0)
    50.             return targetStr;
    51.         //字符串长度 * 2 <= 目标长度，即使是全中文也在长度范围内
    52.         if(targetStr.Length * 2 <= targetLength)
    53.             return targetStr;
    54.         //遍历字符
    55.         char[] chars = targetStr.ToCharArray();
    56.         int curLen = 0;
    57.         for(int i = 0; i < chars.Length; i++)
    58.         {
    59.             //累加字符串长度
    60.             if(chars[i] >= 0x4e00 && chars[i] <= 0x9fbb)
    61.                 curLen += 2;
    62.             else
    63.                 curLen += 1;
    64.  
    65.             //如果当前位置累计长度超过目标长度，取0~i-1，即Substring(0,i)
    66.             if(curLen > targetLength)
    67.                 return targetStr.Substring(0,i) + abbrevPostfix;
    68.         }
    69.         return targetStr;
    70.     }
    71.  
    72.     #endregion
    73.  
    74.     #region --- String To Array ---
    75.  
    76.     //string
    77.  
    78.     public static byte StringToByte(string valueStr)
    79.     {
    80.         byte value;
    81.         if(byte.TryParse(valueStr,out value))
    82.             return value;
    83.         else
    84.             return 0;
    85.     }
    86.  
    87.     public static string[] StringToStringArray(string valueStr,char splitSign = '|')
    88.     {
    89.         if(string.IsNullOrEmpty(valueStr))
    90.             return null;
    91.         return valueStr.Split(splitSign);
    92.     }
    93.  
    94.     public static StringArr[] StringToStringArray2D(string valueStr,char splitSign1 = '&',char splitSign2 = '|')
    95.     {
    96.         if(string.IsNullOrEmpty(valueStr))
    97.             return null;
    98.         string[] strArr1 = valueStr.Split(splitSign1);
    99.         if(strArr1.Length == 0)
    100.             return null;
    101.  
    102.         StringArr[] arrArr = new StringArr[strArr1.Length];
    103.         for(int i = 0; i < strArr1.Length; i++)
    104.         {
    105.             arrArr[i] = new StringArr()
    106.             {
    107.                 array = strArr1[i].Split(splitSign2)
    108.             };
    109.  
    110.         }
    111.         return arrArr;
    112.     }
    113.  
    114.     //int
    115.  
    116.     public static int StringToInt(string valueStr)
    117.     {
    118.         int value;
    119.         if(int.TryParse(valueStr,out value))
    120.             return value;
    121.         else
    122.             return 0;
    123.     }
    124.  
    125.     public static int[] StringToIntArray(string valueStr,char splitSign = '|')
    126.     {
    127.         if(string.IsNullOrEmpty(valueStr))
    128.             return null;
    129.  
    130.         string[] valueArr = valueStr.Split(splitSign);
    131.         if(valueArr == null || valueArr.Length == 0)
    132.             return null;
    133.  
    134.         int[] intArr = new int[valueArr.Length];
    135.         for(int i = 0; i < valueArr.Length; i++)
    136.         {
    137.             intArr[i] = StringToInt(valueArr[i]);
    138.         }
    139.         return intArr;
    140.     }
    141.  
    142.     public static IntArr[] StringToIntArray2D(string valueStr,char splitSign1 = '&',char splitSign2 = '|')
    143.     {
    144.         if(string.IsNullOrEmpty(valueStr))
    145.             return null;
    146.         string[] strArr1 = valueStr.Split(splitSign1);
    147.         if(strArr1.Length == 0)
    148.             return null;
    149.  
    150.         IntArr[] arrArr = new IntArr[strArr1.Length];
    151.         for(int i = 0; i < strArr1.Length; i++)
    152.         {
    153.             arrArr[i] = new IntArr()
    154.             {
    155.                 array = StringToIntArray(strArr1[i],splitSign2)
    156.             };
    157.  
    158.         }
    159.         return arrArr;
    160.     }
    161.  
    162.     //float
    163.  
    164.     public static float StringToFloat(string valueStr)
    165.     {
    166.         float value;
    167.         if(float.TryParse(valueStr,out value))
    168.             return value;
    169.         else
    170.             return 0;
    171.     }
    172.  
    173.     public static float[] StringToFloatArray(string valueStr,char splitSign = '|')
    174.     {
    175.         if(string.IsNullOrEmpty(valueStr))
    176.             return null;
    177.  
    178.         string[] valueArr = valueStr.Split(splitSign);
    179.         if(valueArr == null || valueArr.Length == 0)
    180.             return null;
    181.  
    182.         float[] floatArr = new float[valueArr.Length];
    183.         for(int i = 0; i < valueArr.Length; i++)
    184.         {
    185.             floatArr[i] = StringToFloat(valueArr[i]);
    186.         }
    187.         return floatArr;
    188.     }
    189.  
    190.     public static FloatArr[] StringToFloatArray2D(string valueStr,char splitSign1 = '&',char splitSign2 = '|')
    191.     {
    192.         if(string.IsNullOrEmpty(valueStr))
    193.             return null;
    194.         string[] strArr1 = valueStr.Split(splitSign1);
    195.         if(strArr1.Length == 0)
    196.             return null;
    197.  
    198.         FloatArr[] arrArr = new FloatArr[strArr1.Length];
    199.         for(int i = 0; i < strArr1.Length; i++)
    200.         {
    201.             arrArr[i] = new FloatArr()
    202.             {
    203.                 array = StringToFloatArray(strArr1[i],splitSign2)
    204.             };
    205.  
    206.         }
    207.         return arrArr;
    208.     }
    209.  
    210.     //bool
    211.  
    212.     public static bool StringToBool(string valueStr)
    213.     {
    214.         bool value;
    215.         if(bool.TryParse(valueStr,out value))
    216.             return value;
    217.         else
    218.             return false;
    219.     }
    220.  
    221.     public static bool[] StringToBoolArray(string valueStr,char splitSign = '|')
    222.     {
    223.         if(string.IsNullOrEmpty(valueStr))
    224.             return null;
    225.  
    226.         string[] valueArr = valueStr.Split(splitSign);
    227.         if(valueArr == null || valueArr.Length == 0)
    228.             return null;
    229.  
    230.         bool[] boolArr = new bool[valueArr.Length];
    231.         for(int i = 0; i < valueArr.Length; i++)
    232.         {
    233.             boolArr[i] = StringToBool(valueArr[i]);
    234.         }
    235.         return boolArr;
    236.     }
    237.  
    238.     public static BoolArr[] StringToBoolArray2D(string valueStr,char splitSign1 = '&',char splitSign2 = '|')
    239.     {
    240.         if(string.IsNullOrEmpty(valueStr))
    241.             return null;
    242.         string[] strArr1 = valueStr.Split(splitSign1);
    243.         if(strArr1.Length == 0)
    244.             return null;
    245.  
    246.         BoolArr[] arrArr = new BoolArr[strArr1.Length];
    247.         for(int i = 0; i < strArr1.Length; i++)
    248.         {
    249.             arrArr[i] = new BoolArr()
    250.             {
    251.                 array = StringToBoolArray(strArr1[i],splitSign2)
    252.             };
    253.  
    254.         }
    255.         return arrArr;
    256.     }
    257.  
    258.     //enum
    259.  
    260.     public static T StringToEnum<T>(string valueStr) where T : Enum
    261.     {
    262.         if(string.IsNullOrEmpty(valueStr))
    263.             return (T)default;
    264.  
    265.         //先校验字符串是否为枚举值
    266.         int intValue;
    267.         if(int.TryParse(valueStr,out intValue))
    268.         {
    269.             if(Enum.IsDefined(typeof(T),intValue))
    270.                 return (T)Enum.ToObject(typeof(T),intValue);
    271.         }
    272.         //如果不是枚举值，当做枚举名处理
    273.         try
    274.         {
    275.             T t = (T)Enum.Parse(typeof(T),valueStr);
    276.             if(Enum.IsDefined(typeof(T),t))
    277.                 return t;
    278.         }
    279.         catch(Exception e)
    280.         {
    281.             Debug.LogError(e);
    282.         }
    283.         Debug.LogError(string.Format("解析枚举错误 {0} : {1}",typeof(T),valueStr));
    284.         return (T)default;
    285.     }
    286.  
    287.     public static T[] StringToEnumArray<T>(string valueStr,char splitSign = '|') where T : Enum
    288.     {
    289.         if(string.IsNullOrEmpty(valueStr))
    290.             return null;
    291.  
    292.         string[] valueArr = valueStr.Split(splitSign);
    293.         if(valueArr == null || valueArr.Length == 0)
    294.             return null;
    295.  
    296.         T[] enumArr = new T[valueArr.Length];
    297.         for(int i = 0; i < valueArr.Length; i++)
    298.         {
    299.             enumArr[i] = StringToEnum<T>(valueArr[i]);
    300.         }
    301.         return enumArr;
    302.     }
    303.  
    304.     不支持泛型枚举序列化
    305.     //public static EnumArr<T>[] StringToEnumArray2D<T>(string valueStr,char splitSign1 = '&',char splitSign2 = '|') where T : Enum
    306.     //{
    307.     //    if(string.IsNullOrEmpty(valueStr))
    308.     //        return null;
    309.     //    string[] strArr1 = valueStr.Split(splitSign1);
    310.     //    if(strArr1.Length == 0)
    311.     //        return null;
    312.  
    313.     //    EnumArr<T>[] arrArr = new EnumArr<T>[strArr1.Length];
    314.     //    for(int i = 0; i < strArr1.Length; i++)
    315.     //    {
    316.     //        arrArr[i] = new EnumArr<T>()
    317.     //        {
    318.     //            array = StringToEnumArray<T>(strArr1[i],splitSign2)
    319.     //        };
    320.  
    321.     //    }
    322.     //    return arrArr;
    323.     //}
    324.  
    325.     //vector2
    326.  
    327.     public static Vector2 StringToVector2(string valueStr,char splitSign = ',')
    328.     {
    329.         Vector2 value = Vector2.zero;
    330.         if(!string.IsNullOrEmpty(valueStr))
    331.         {
    332.             string[] stringArray = valueStr.Split(splitSign);
    333.             if(stringArray != null && stringArray.Length >= 2)
    334.             {
    335.                 value.x = StringToFloat(stringArray[0]);
    336.                 value.y = StringToFloat(stringArray[1]);
    337.                 return value;
    338.             }
    339.         }
    340.         Debug.LogWarning("String to Vector2 error");
    341.         return value;
    342.     }
    343.  
    344.     public static Vector2[] StringToVector2Array(string valueStr,char splitSign = '|')
    345.     {
    346.         if(string.IsNullOrEmpty(valueStr))
    347.             return null;
    348.  
    349.         string[] stringArray = valueStr.Split(splitSign);
    350.         if(stringArray == null || stringArray.Length == 0)
    351.             return null;
    352.  
    353.         Vector2[] vector2s = new Vector2[stringArray.Length];
    354.         for(int i = 0; i < stringArray.Length; i++)
    355.         {
    356.             vector2s[i] = StringToVector2(stringArray[i]);
    357.         }
    358.         return vector2s;
    359.     }
    360.  
    361.     public static Vector2Arr[] StringToVector2Array2D(string valueStr,char splitSign1 = '&',char splitSign2 = '|')
    362.     {
    363.         if(string.IsNullOrEmpty(valueStr))
    364.             return null;
    365.         string[] strArr1 = valueStr.Split(splitSign1);
    366.         if(strArr1.Length == 0)
    367.             return null;
    368.  
    369.         Vector2Arr[] arrArr = new Vector2Arr[strArr1.Length];
    370.         for(int i = 0; i < strArr1.Length; i++)
    371.         {
    372.             arrArr[i] = new Vector2Arr()
    373.             {
    374.                 array = StringToVector2Array(strArr1[i],splitSign2)
    375.             };
    376.         }
    377.         return arrArr;
    378.     }
    379.  
    380.     //vector3
    381.  
    382.     public static Vector3 StringToVector3(string valueStr,char splitSign = ',')
    383.     {
    384.         Vector3 value = Vector3.zero;
    385.         if(!string.IsNullOrEmpty(valueStr))
    386.         {
    387.             string[] stringArray = valueStr.Split(splitSign);
    388.             if(stringArray.Length >= 3)
    389.             {
    390.                 value.x = StringToFloat(stringArray[0]);
    391.                 value.y = StringToFloat(stringArray[1]);
    392.                 value.z = StringToFloat(stringArray[2]);
    393.                 return value;
    394.             }
    395.         }
    396.         Debug.LogWarning("String to Vector3 error");
    397.         return value;
    398.     }
    399.  
    400.     public static Vector3[] StringToVector3Array(string valueStr,char splitSign = '|')
    401.     {
    402.         if(string.IsNullOrEmpty(valueStr))
    403.             return null;
    404.  
    405.         string[] stringArray = valueStr.Split(splitSign);
    406.         if(stringArray == null || stringArray.Length == 0)
    407.             return null;
    408.  
    409.         Vector3[] vector3s = new Vector3[stringArray.Length];
    410.         for(int i = 0; i < stringArray.Length; i++)
    411.         {
    412.             vector3s[i] = StringToVector3(stringArray[i]);
    413.         }
    414.         return vector3s;
    415.     }
    416.  
    417.     public static Vector3Arr[] StringToVector3Array2D(string valueStr,char splitSign1 = '&',char splitSign2 = '|')
    418.     {
    419.         if(string.IsNullOrEmpty(valueStr))
    420.             return null;
    421.         string[] strArr1 = valueStr.Split(splitSign1);
    422.         if(strArr1.Length == 0)
    423.             return null;
    424.  
    425.         Vector3Arr[] arrArr = new Vector3Arr[strArr1.Length];
    426.         for(int i = 0; i < strArr1.Length; i++)
    427.         {
    428.             arrArr[i] = new Vector3Arr()
    429.             {
    430.                 array = StringToVector3Array(strArr1[i],splitSign2)
    431.             };
    432.         }
    433.         return arrArr;
    434.     }
    435.  
    436.     //vector2Int
    437.  
    438.     public static Vector2Int StringToVector2Int(string valueStr,char splitSign = ',')
    439.     {
    440.         Vector2Int value = Vector2Int.zero;
    441.         if(!string.IsNullOrEmpty(valueStr))
    442.         {
    443.             string[] stringArray = valueStr.Split(splitSign);
    444.             if(stringArray != null && stringArray.Length >= 2)
    445.             {
    446.                 value.x = StringToInt(stringArray[0]);
    447.                 value.y = StringToInt(stringArray[1]);
    448.                 return value;
    449.             }
    450.         }
    451.         Debug.LogWarning("String to Vector2Int error");
    452.         return value;
    453.     }
    454.  
    455.     public static Vector2Int[] StringToVector2IntArray(string valueStr,char splitSign = '|')
    456.     {
    457.         if(string.IsNullOrEmpty(valueStr))
    458.             return null;
    459.  
    460.         string[] stringArray = valueStr.Split(splitSign);
    461.         if(stringArray == null || stringArray.Length == 0)
    462.             return null;
    463.  
    464.         Vector2Int[] vector2Ints = new Vector2Int[stringArray.Length];
    465.         for(int i = 0; i < stringArray.Length; i++)
    466.         {
    467.             vector2Ints[i] = StringToVector2Int(stringArray[i]);
    468.         }
    469.         return vector2Ints;
    470.     }
    471.  
    472.     public static Vector2IntArr[] StringToVector2IntArray2D(string valueStr,char splitSign1 = '&',char splitSign2 = '|')
    473.     {
    474.         if(string.IsNullOrEmpty(valueStr))
    475.             return null;
    476.         string[] strArr1 = valueStr.Split(splitSign1);
    477.         if(strArr1.Length == 0)
    478.             return null;
    479.  
    480.         Vector2IntArr[] arrArr = new Vector2IntArr[strArr1.Length];
    481.         for(int i = 0; i < strArr1.Length; i++)
    482.         {
    483.             arrArr[i] = new Vector2IntArr()
    484.             {
    485.                 array = StringToVector2IntArray(strArr1[i],splitSign2)
    486.             };
    487.         }
    488.         return arrArr;
    489.     }
    490.  
    491.     //vector3Int
    492.  
    493.     public static Vector3Int StringToVector3Int(string valueStr,char splitSign = ',')
    494.     {
    495.         Vector3Int value = Vector3Int.zero;
    496.         if(!string.IsNullOrEmpty(valueStr))
    497.         {
    498.             string[] stringArray = valueStr.Split(splitSign);
    499.             if(stringArray.Length >= 3)
    500.             {
    501.                 value.x = StringToInt(stringArray[0]);
    502.                 value.y = StringToInt(stringArray[1]);
    503.                 value.z = StringToInt(stringArray[2]);
    504.                 return value;
    505.             }
    506.         }
    507.         Debug.LogWarning("String to Vector3 error");
    508.         return value;
    509.     }
    510.  
    511.     public static Vector3Int[] StringToVector3IntArray(string valueStr,char splitSign = '|')
    512.     {
    513.         if(string.IsNullOrEmpty(valueStr))
    514.             return null;
    515.  
    516.         string[] stringArray = valueStr.Split(splitSign);
    517.         if(stringArray == null || stringArray.Length == 0)
    518.             return null;
    519.  
    520.         Vector3Int[] vector3Ints = new Vector3Int[stringArray.Length];
    521.         for(int i = 0; i < stringArray.Length; i++)
    522.         {
    523.             vector3Ints[i] = StringToVector3Int(stringArray[i]);
    524.         }
    525.         return vector3Ints;
    526.     }
    527.  
    528.     public static Vector3IntArr[] StringToVector3IntArray2D(string valueStr,char splitSign1 = '&',char splitSign2 = '|')
    529.     {
    530.         if(string.IsNullOrEmpty(valueStr))
    531.             return null;
    532.         string[] strArr1 = valueStr.Split(splitSign1);
    533.         if(strArr1.Length == 0)
    534.             return null;
    535.  
    536.         Vector3IntArr[] arrArr = new Vector3IntArr[strArr1.Length];
    537.         for(int i = 0; i < strArr1.Length; i++)
    538.         {
    539.             arrArr[i] = new Vector3IntArr()
    540.             {
    541.                 array = StringToVector3IntArray(strArr1[i],splitSign2)
    542.             };
    543.         }
    544.         return arrArr;
    545.     }
    546.  
    547.     //color
    548.  
    549.     public static Color StringToColor(string valueStr,char splitSign = ',')
    550.     {
    551.         if(string.IsNullOrEmpty(valueStr))
    552.             return Color.white;
    553.  
    554.         string[] stringArray = valueStr.Split(splitSign);
    555.         if(stringArray.Length < 3)
    556.             return Color.white;
    557.  
    558.         Color color = new Color()
    559.         {
    560.             r = StringToFloat(stringArray[0]),
    561.             g = StringToFloat(stringArray[1]),
    562.             b = StringToFloat(stringArray[2]),
    563.             a = stringArray.Length < 4 ? 1 : StringToFloat(stringArray[3])
    564.         };
    565.         return color;
    566.     }
    567.     public static Color32 StringToColor32(string valueStr,char splitSign = ',')
    568.     {
    569.         if(string.IsNullOrEmpty(valueStr))
    570.             return Color.white;
    571.  
    572.         string[] stringArray = valueStr.Split(splitSign);
    573.         if(stringArray.Length < 3)
    574.             return Color.white;
    575.  
    576.         Color32 color = new Color32()
    577.         {
    578.             r = StringToByte(stringArray[0]),
    579.             g = StringToByte(stringArray[1]),
    580.             b = StringToByte(stringArray[2]),
    581.             a = stringArray.Length < 4 ? (byte)1 : StringToByte(stringArray[3])
    582.         };
    583.         return color;
    584.     }
    585.  
    586.     public static Color[] StringToColorArray(string valueStr,char splitSign = '|')
    587.     {
    588.         if(string.IsNullOrEmpty(valueStr))
    589.             return null;
    590.  
    591.         string[] stringArray = valueStr.Split(splitSign);
    592.         if(stringArray == null || stringArray.Length == 0)
    593.             return null;
    594.  
    595.         Color[] colors = new Color[stringArray.Length];
    596.         for(int i = 0; i < stringArray.Length; i++)
    597.         {
    598.             colors[i] = StringToColor(stringArray[i]);
    599.         }
    600.         return colors;
    601.     }
    602.  
    603.     public static Color32[] StringToColor32Array(string valueStr,char splitSign = '|')
    604.     {
    605.         if(string.IsNullOrEmpty(valueStr))
    606.             return null;
    607.  
    608.         string[] stringArray = valueStr.Split(splitSign);
    609.         if(stringArray == null || stringArray.Length == 0)
    610.             return null;
    611.  
    612.         Color32[] colors = new Color32[stringArray.Length];
    613.         for(int i = 0; i < stringArray.Length; i++)
    614.         {
    615.             colors[i] = StringToColor32(stringArray[i]);
    616.         }
    617.         return colors;
    618.     }
    619.  
    620.     public static ColorArr[] StringToColorArray2D(string valueStr,char splitSign1 = '&',char splitSign2 = '|')
    621.     {
    622.         if(string.IsNullOrEmpty(valueStr))
    623.             return null;
    624.         string[] strArr1 = valueStr.Split(splitSign1);
    625.         if(strArr1.Length == 0)
    626.             return null;
    627.  
    628.         ColorArr[] arrArr = new ColorArr[strArr1.Length];
    629.         for(int i = 0; i < strArr1.Length; i++)
    630.         {
    631.             arrArr[i] = new ColorArr()
    632.             {
    633.                 array = StringToColorArray(strArr1[i],splitSign2)
    634.             };
    635.         }
    636.         return arrArr;
    637.     }
    638.     public static Color32Arr[] StringToColor32Array2D(string valueStr,char splitSign1 = '&',char splitSign2 = '|')
    639.     {
    640.         if(string.IsNullOrEmpty(valueStr))
    641.             return null;
    642.         string[] strArr1 = valueStr.Split(splitSign1);
    643.         if(strArr1.Length == 0)
    644.             return null;
    645.  
    646.         Color32Arr[] arrArr = new Color32Arr[strArr1.Length];
    647.         for(int i = 0; i < strArr1.Length; i++)
    648.         {
    649.             arrArr[i] = new Color32Arr()
    650.             {
    651.                 array = StringToColor32Array(strArr1[i],splitSign2)
    652.             };
    653.         }
    654.         return arrArr;
    655.     }
    656.  
    657.     #endregion
    658.  
    659.     #region MyRegion
    660.  
    661.     public static string GetRandomString(int length)
    662.     {
    663.         StringBuilder builder = new StringBuilder();
    664.         string abc = "abcdefghijklmnopqrstuvwxyzo0123456789QWERTYUIOPASDFGHJKLZXCCVBMN";
    665.         for(int i = 0; i < length; i++)
    666.         {
    667.             builder.Append(abc[UnityEngine.Random.Range(0,abc.Length - 1)]);
    668.         }
    669.         return builder.ToString();
    670.     }
    671.  
    672.     public static string Join<T>(T[] arr,string join = ",")
    673.     {
    674.         if(arr == null || arr.Length == 0)
    675.             return null;
    676.  
    677.         StringBuilder builder = new StringBuilder();
    678.         for(int i = 0; i < arr.Length; i++)
    679.         {
    680.             builder.Append(arr[i]);
    681.             if(i < arr.Length - 1)
    682.                 builder.Append(join);
    683.         }
    684.         return builder.ToString();
    685.     }
    686.  
    687.     /// <summary>
    688.     /// 中文逗号转英文逗号
    689.     /// </summary>
    690.     /// <param name="input"></param>
    691.     /// <returns></returns>
    692.     public static string ToDBC(string input)
    693.     {
    694.         char[] c = input.ToCharArray();
    695.         for(int i = 0; i < c.Length; i++)
    696.         {
    697.             if(c[i] == 12288)
    698.             {
    699.                 c[i] = (char)32;
    700.                 continue;
    701.             }
    702.             if(c[i] > 65280 && c[i] < 65375)
    703.                 c[i] = (char)(c[i] - 65248);
    704.         }
    705.         return new string(c);
    706.     }
    707.  
    708.     /// <summary>
    709.     /// 字符转 ascii 码 
    710.     /// </summary>
    711.     /// <param name="character"></param>
    712.     /// <returns></returns>
    713.     public static int Asc(string character)
    714.     {
    715.         if(character.Length == 1)
    716.         {
    717.             System.Text.ASCIIEncoding asciiEncoding = new System.Text.ASCIIEncoding();
    718.             int intAsciiCode = (int)asciiEncoding.GetBytes(character)[0];
    719.             return (intAsciiCode);
    720.         }
    721.         Debug.LogError("Character is not valid.");
    722.         return -1;
    723.     }
    724.  
    725.     /// <summary>
    726.     /// ascii码转字符
    727.     /// </summary>
    728.     /// <param name="asciiCode"></param>
    729.     /// <returns></returns>
    730.     public static string Chr(int asciiCode)
    731.     {
    732.         if(asciiCode >= 0 && asciiCode <= 255)
    733.         {
    734.             System.Text.ASCIIEncoding asciiEncoding = new System.Text.ASCIIEncoding();
    735.             byte[] byteArray = new byte[] { (byte)asciiCode };
    736.             string strCharacter = asciiEncoding.GetString(byteArray);
    737.             return (strCharacter);
    738.         }
    739.         Debug.LogError("ASCII Code is not valid.");
    740.         return string.Empty;
    741.     }
    742.  
    743.     /// <summary>
    744.     /// 过滤掉表情符号
    745.     /// </summary>
    746.     /// <returns>The emoji.</returns>
    747.     /// <param name="str">String.</param>
    748.     public static string FilterEmoji(string str)
    749.     {
    750.         List<string> patten = new List<string>() { @"\p{Cs}",@"\p{Co}",@"\p{Cn}",@"[\u2702-\u27B0]" };
    751.         for(int i = 0; i < patten.Count; i++)
    752.         {
    753.             str = Regex.Replace(str,patten[i],"");//屏蔽emoji   
    754.         }
    755.         return str;
    756.     }
    757.  
    758.     /// <summary>
    759.     /// 过滤掉表情符号
    760.     /// </summary>
    761.     /// <returns>The emoji.</returns>
    762.     /// <param name="str">String.</param>
    763.     public static bool IsFilterEmoji(string str)
    764.     {
    765.         bool bEmoji = false;
    766.         List<string> patten = new List<string>() { @"\p{Cs}",@"\p{Co}",@"\p{Cn}",@"[\u2702-\u27B0]" };
    767.         for(int i = 0; i < patten.Count; i++)
    768.         {
    769.             bEmoji = Regex.IsMatch(str,patten[i]);
    770.             if(bEmoji)
    771.             {
    772.                 break;
    773.             }
    774.         }
    775.         return bEmoji;
    776.     }
    777.  
    778.     #endregion
    779.  
    780.     #region StringObjectDictionaryExtensions
    781.  
    782.     /// <summary>
    783.     /// 针对字典中包含以下键值进行结构：mctid0=xxx;mccount0=1,mctid1=kn2,mccount=2。将其前缀去掉，数字后缀变为键，如{后缀,(去掉前后缀的键,值)}，注意后缀可能是空字符串即没有后缀
    784.     /// </summary>
    785.     /// <param name="dic"></param>
    786.     /// <param name="prefix">前缀，可以是空引用或空字符串，都表示没有前缀。</param>
    787.     [MethodImpl(MethodImplOptions.AggressiveInlining)]
    788.     public static IEnumerable<IGrouping<string,(string, object)>> GetValuesWithoutPrefix(this IReadOnlyDictionary<string,object> dic,string prefix = null)
    789.     {
    790.         //prefix ??= string.Empty;
    791.         prefix = prefix ?? string.Empty;
    792.  
    793.         var coll = from tmp in dic.Where(c => c.Key.StartsWith(prefix)) //仅针对指定前缀的键值
    794.                    let p3 = tmp.Key.Get3Segment(prefix)
    795.                    group (p3.Item2, tmp.Value) by p3.Item3;
    796.         return coll;
    797.     }
    798.  
    799.     /// <summary>
    800.     /// 分解字符串为三段，前缀，词根，数字后缀(字符串形式)。
    801.     /// </summary>
    802.     /// <param name="str"></param>
    803.     /// <param name="prefix">前缀，可以是空引用或空字符串，都表示没有前缀。</param>
    804.     /// <returns></returns>
    805.     [MethodImpl(MethodImplOptions.AggressiveInlining)]
    806.     public static (string, string, string) Get3Segment(this string str,string prefix = null)
    807.     {
    808.         //prefix ??= string.Empty;
    809.         prefix = prefix ?? string.Empty;
    810.  
    811.         //最后十进制数字尾串的长度
    812.         int suffixLen = Enumerable.Reverse(str).TakeWhile(c => char.IsDigit(c)).Count();
    813.         //获取十进制数字后缀
    814.         //string suufix = str[^suffixLen..];     //^suffixLen：倒序下标；suffixLen..：从指定位置开始直到末尾
    815.         string suufix = str.Substring(str.Length - suffixLen);
    816.  
    817.         //return (prefix, str[prefix.Length..^suufix.Length], suufix);
    818.         string middle = str.Substring(prefix.Length,str.Length - prefix.Length - suufix.Length);
    819.         return (prefix, middle, suufix);
    820.     }
    821.  
    822.     #endregion
    823.  
    824. }

    Demo链接：

    【Unity】升级版·Excel数据解析，自动创建C#类，自动创建ScriptableObject生成类，自动序列化Asset-Unity3D文档类资源-CSDN下载Excel数据解析，自动创建对应C#类，自动创建ScriptableObject生成类，自动序列化A更多下载资源、学习资料请访问CSDN下载频道.https://download.csdn.net/download/qq_39108767/85913988

  • 相关阅读:
    徐建鸿：深耕中医康养的“托钵行者”
    【PHP】麻醉临床信息系统
    Java反应式编程（1）
    Vue-中央事件总线（bus）
    尚硅谷ES6复习总结上（64th）
    计算机毕业设计Java汉服服装租赁系统(源码+系统+mysql数据库+lw文档)
    【php学习笔记】文件系统---制作备忘录和修改配置文件
    机器学习笔记之贝叶斯线性回归(三)预测任务推导过程
    使用serverless超低成本快速部署开源项目
    Windows-Oracle11g 安装详解-含Navicate远程连接配置 -本地监听设置及更换navicate环境指向的oci.dll
  • 原文地址：https://blog.csdn.net/qq_39108767/article/details/125608062