/// <summary>
/// 获取基础List里面的所有值
/// </summary>
/// <returns></returns>
private static string GetSpliteBaseList(object data, VarClass varClass)
{
string str = "";
if (string.IsNullOrEmpty(varClass.SplitStr))
{
Debug.LogError("基础List的分隔符为空！");
return(str);
}
object dataList = GetMemberValue(data, varClass.Name);
int listCount = System.Convert.ToInt32(dataList.GetType().InvokeMember("get_Count",
BindingFlags.Default | BindingFlags.InvokeMethod, null, dataList, new object[] { }));
for (int i = 0; i < listCount; i++)
{
object item = dataList.GetType().InvokeMember("get_Item", BindingFlags.Default | BindingFlags.InvokeMethod,
null, dataList, new object[] { i });
str += item.ToString();
if (i != listCount - 1)
{
str += varClass.SplitStr.Replace("\\n", "\n").Replace("\\r", "\r");
}
}
return(str);
}
/// <summary>
/// 解析基本类型列表，结合成字符串返回
/// </summary>
/// <param name="obj"></param>
/// <param name="varClass"></param>
/// <returns></returns>
private static string GetSpliteBaseList(object obj, VarClass varClass)
{
string str = "";
if (string.IsNullOrEmpty(varClass.SplitStr))
{
Debug.LogError("字符分隔符为空，请检查:" + varClass.Name);
return(str);
}
int listCount = System.Convert.ToInt32(obj.GetType().InvokeMember("get_Count", BindingFlags.Default | BindingFlags.InvokeMethod, null,
obj, new object[] { }));
for (int i = 0; i < listCount; i++)
{
object item = obj.GetType().InvokeMember("get_Item", BindingFlags.Default | BindingFlags.InvokeMethod, null,
obj, new object[] { i });
if (i != listCount - 1)
{
str += item.ToString() + varClass.SplitStr;
}
else
{
str += item.ToString();
}
}
return(str);
}
public InnerClass()
{
VarClass c = new VarClass();
Console.WriteLine(c.privateID);
Console.WriteLine(c.publicID);
}
public OuterClass()
{
VarClass c = new VarClass();
Console.WriteLine(c.privateID); // Compile Error
Console.WriteLine(c.publicID);
}
/// <summary>
/// List类型转化成分隔的字符串
/// </summary>
/// <param name="data"></param>
/// <param name="varClass"></param>
/// <returns></returns>
private static string GetSplitStrList(object data, VarClass varClass, SheetClass sheetClass)
{
if (string.IsNullOrEmpty(varClass.SplitStr) || string.IsNullOrEmpty(sheetClass.SplitStr))
{
Debug.LogError("GetSplitStrList: List分隔符为空");
return(null);
}
object dataList = GetMemberValue(data, varClass.Name);
int count = Convert.ToInt32(dataList.GetType().GetProperty("Count").GetValue(dataList));
string str = "";
for (int i = 0; i < count; i++)
{
object value = dataList.GetType().GetProperty("Item").GetValue(dataList, new object[] { i });
for (int j = 0; j < sheetClass.VarList.Count; j++)
{
VarClass curVarClass = sheetClass.VarList[j];
object varValue = GetMemberValue(value, curVarClass.Name);
str += varValue.ToString();
if (j != sheetClass.VarList.Count - 1)
{
str += sheetClass.SplitStr;
}
}
if (i != count - 1)
{
str += varClass.SplitStr;
}
}
return(str);
}
/// <summary>
/// 集合数据转类
/// </summary>
/// <param name="addItem"></param>
/// <param name="sheetClass"></param>
/// <param name="value"></param>
private static void SetSplitClass(object addItem, SheetClass sheetClass, string value)
{
if (string.IsNullOrEmpty(value))
{
Debug.Log("SetSplitClass(): Excel里面自定义list的列里有空值！" + sheetClass.Name);
return;
}
string[] strArray = value.Split(new string[] { sheetClass.ParentVar.SplitStr }, StringSplitOptions.None);
object tempClass = CreateClass(sheetClass.Name);
//集合数据的list
object list = CreateList(tempClass.GetType());
for (int i = 0; i < strArray.Length; i++)
{
string[] itemValue = strArray[i].Trim().Split(new string[] { sheetClass.SplitStr }, StringSplitOptions.None);
object item = CreateClass(sheetClass.Name);
for (int j = 0; j < itemValue.Length; j++)
{
//集合数据的元素
VarClass curVar = sheetClass.VarList[j];
SetMemberValue(item, curVar.Name, curVar.Type, itemValue[j].Trim());
}
list.GetType().InvokeMember("Add", BindingFlags.Default | BindingFlags.InvokeMethod, null, list, new object[] { item });
}
addItem.GetType().GetProperty(sheetClass.ParentVar.Name).SetValue(addItem, list);
}
/// <summary>
/// 获取本身是一个类的列表，但是数据比较少；（没办法确定父级结构的）
/// </summary>
/// <returns></returns>
private static string GetSplitStrList(object data, VarClass varClass, SheetClass sheetClass)
{
string split = varClass.SplitStr;
string classSplit = sheetClass.SplitStr;
string str = "";
if (string.IsNullOrEmpty(split) || string.IsNullOrEmpty(classSplit))
{
Debug.LogError("类的列类分隔符或变量分隔符为空！！！");
return(str);
}
object dataList = GetMemberValue(data, varClass.Name);
int listCount = System.Convert.ToInt32(dataList.GetType().InvokeMember("get_Count", BindingFlags.Default | BindingFlags.InvokeMethod, null, dataList, new object[] { }));
for (int i = 0; i < listCount; i++)
{
object item = dataList.GetType().InvokeMember("get_Item", BindingFlags.Default | BindingFlags.InvokeMethod, null, dataList, new object[] { i });
for (int j = 0; j < sheetClass.VarList.Count; j++)
{
object value = GetMemberValue(item, sheetClass.VarList[j].Name);
str += value.ToString();
if (j != sheetClass.VarList.Count - 1)
{
str += classSplit.Replace("\\n", "\n").Replace("\\r", "\r");
}
}
if (i != listCount - 1)
{
str += split.Replace("\\n", "\n").Replace("\\r", "\r");
}
}
return(str);
}
/// <summary>
/// 将数据转换为类
/// </summary>
/// <param name="objClass"></param>
/// <param name="sheetClass"></param>
/// <param name="sheetData"></param>
/// <param name="allSheetClassDic"></param>
/// <param name="allSheetDataDic"></param>
private static void ReadDataToClass(object objClass, SheetClass sheetClass, SheetData sheetData,
Dictionary <string, SheetClass> allSheetClassDic, Dictionary <string, SheetData> allSheetDataDic, object keyValue)
{
object item = CreatClass(sheetClass.Name);//获取列表变量类型
object list = CreateList(item.GetType());
for (int i = 0; i < sheetData.AllData.Count; i++)
{
if (keyValue != null && !string.IsNullOrEmpty(sheetData.AllData[i].parentValue))
{
if (sheetData.AllData[i].parentValue != keyValue.ToString())
{
continue;
}
}
object addItem = CreatClass(sheetClass.Name);
for (int j = 0; j < sheetClass.VarList.Count; j++)
{
VarClass varClass = sheetClass.VarList[j];
if (varClass.Type == "list" && string.IsNullOrEmpty(varClass.SplitStr))
{
ReadDataToClass(addItem, allSheetClassDic[varClass.ListSheetName],
allSheetDataDic[GetSheetName(varClass.ListSheetName)], allSheetClassDic, allSheetDataDic,
GetMemberValue(addItem, sheetClass.MainKey));
}
else if (varClass.Type == "list")
{
string value = sheetData.AllData[i].RowDataDic[sheetData.AllName[j]];
SetSplitClass(addItem, allSheetClassDic[varClass.ListSheetName], value);
}
else if (varClass.Type == "listStr" || varClass.Type == "listFloat" ||
varClass.Type == "listInt" || varClass.Type == "listBool")
{
string value = sheetData.AllData[i].RowDataDic[sheetData.AllName[j]];
SetSplitBaseClass(addItem, varClass, value);
}
else
{
string value = sheetData.AllData[i].RowDataDic[sheetData.AllName[j]];
if (string.IsNullOrEmpty(value) && !string.IsNullOrEmpty(varClass.DeafultValue))
{
value = varClass.DeafultValue;
}
else if (string.IsNullOrEmpty(value))
{
Debug.Log("表格中有空数据或者该属性的DeafultValue在reg中未配置" + varClass.Name);
}
SetValue(addItem, sheetData.AllName[j], value, sheetData.AllType[j]);
}
}
list.GetType().InvokeMember("Add", BindingFlags.Default | BindingFlags.InvokeMethod, null, list,
new object[] { addItem });
}
objClass.GetType().GetProperty(sheetClass.ParentVar.Name).SetValue(objClass, list);
}
/// <summary>
/// 设置基础List的值
/// </summary>
/// <param name="item"></param>
/// <param name="varClass"></param>
/// <param name="value"></param>
private static void SetBaseListValue(object item, VarClass varClass, string value)
{
string type = varClass.Type.Substring(varClass.Type.LastIndexOf("[") + 1).Replace("]", "");
object list = CreateList(type);
object[] values = value.Split(System.Convert.ToChar(varClass.SplitStr));
for (int i = 0; i < values.Length; i++)
{
//list.GetType().InvokeMember("Add", BindingFlags.Default | BindingFlags.InvokeMethod, null, list, new object[] { values[i] });
Type classListType = list.GetType();
BindingFlags flag = BindingFlags.Instance | BindingFlags.Public;
MethodInfo methodInfo = classListType.GetMethod("Add", flag);
methodInfo.Invoke(list, new object[] { ConvertType(values[i], type) });//相当于List<T>调用Add方法
}
item.GetType().GetProperty(varClass.Name).SetValue(item, list);
}
/// <summary>
/// 设置基础类型列表
/// </summary>
/// <param name="addItem"></param>
/// <param name="varClass"></param>
/// <param name="value"></param>
private static void SetSplitBaseClass(object obj, VarClass varClass, string value)
{
Type type = null;
switch (varClass.Type)
{
case "listStr":
type = typeof(string);
break;
case "listInt":
type = typeof(int);
break;
case "listFloat":
type = typeof(float);
break;
case "listBool":
type = typeof(bool);
break;
}
if (type == null)
{
return;
}
object list = CreateList(type);
string[] rowArr = value.Split(new string[] { varClass.SplitStr }, StringSplitOptions.None);
for (int i = 0; i < rowArr.Length; i++)
{
object addItem = rowArr[i].Trim();
try
{
list.GetType().InvokeMember("Add", BindingFlags.Default | BindingFlags.InvokeMethod, null, list,
new object[] { addItem });
}
catch (Exception e)
{
Debug.Log(varClass.ListSheetName + "里" + varClass.Name + "列表添加失败，请具体数值是" + addItem);
}
}
obj.GetType().GetProperty(varClass.Name).SetValue(obj, list);
}
/// <summary>
/// 读取Excel信息到类
/// </summary>
/// <param name="objClass">类对象</param>
/// <param name="sheetClass"></param>
/// <param name="sheetData"></param>
/// <param name="allSheetDict"></param>
/// <param name="sheetDataDict"></param>
private static void ReadDataToClass(object objClass, SheetClass sheetClass, SheetData sheetData, Dictionary <string, SheetClass> allSheetDict,
Dictionary <string, SheetData> sheetDataDict, object keyValue)
{
object list = CreateList(sheetClass.Name);
for (int i = 0; i < sheetData.AllRowData.Count; i++)
{
Type type = GetType(sheetClass.Name);
object addItem = System.Activator.CreateInstance(type);
if (keyValue != null && !string.IsNullOrEmpty(sheetData.AllRowData[i].ForeignValue))
{
if (sheetData.AllRowData[i].ForeignValue != keyValue.ToString())
{
continue;
}
}
for (int j = 0; j < sheetClass.VarList.Count; j++)
{
VarClass varClass = sheetClass.VarList[j];
if (varClass.Type == "list")
{
ReadDataToClass(addItem, allSheetDict[varClass.ListSheetName], sheetDataDict[varClass.ListSheetName], allSheetDict,
sheetDataDict, GetMemberValue(addItem, sheetClass.MainKey));
}
else if (varClass.Type.Contains("list"))
{
string value = sheetData.AllRowData[i].RowDataDict[sheetData.AllName[j]];
SetBaseListValue(addItem, varClass, value);
}
else
{
string value = sheetData.AllRowData[i].RowDataDict[sheetData.AllName[j]];
if (string.IsNullOrEmpty(value) && !string.IsNullOrEmpty(varClass.DeafultValue))
{
value = varClass.DeafultValue;
}
SetValue(addItem.GetType().GetProperty(sheetData.AllName[j]), addItem, value, sheetData.AllType[j]);
}
}
list.GetType().InvokeMember("Add", BindingFlags.Default | BindingFlags.InvokeMethod, null, list, new object[] { addItem });
}
objClass.GetType().GetProperty(sheetClass.ParentVar.Name).SetValue(objClass, list);
}
/// <summary>
/// Xml基础类型转Class
/// </summary>
/// <param name="addItem"></param>
/// <param name="varClass"></param>
/// <param name="value"></param>
private static void SetSplitBaseClass(object addItem, VarClass varClass, string value)
{
Type type = null;
string varType = varClass.Type;
switch (varType)
{
case "listStr":
type = typeof(string);
break;
case "listInt":
type = typeof(int);
break;
case "listBool":
type = typeof(bool);
break;
case "listFloat":
type = typeof(float);
break;
}
string[] strArray = value.Split(new string[] { varClass.SplitStr }, StringSplitOptions.None);
if (type != null)
{
object list = CreateList(type);
for (int i = 0; i < strArray.Length; i++)
{
string tempValue = strArray[i];
if (tempValue == null)
{
Debug.LogWarning("SetSplitBaseClass():" + varClass.SheetName + " 中" + varClass.Name + " 数据为空 检查是否配置正确");
}
else
{
list.GetType().InvokeMember("Add", BindingFlags.Default | BindingFlags.InvokeMethod, null, list, new object[] { tempValue });
}
}
addItem.GetType().GetProperty(varClass.Name).SetValue(addItem, list);
}
}
/// <summary>
/// 将列表中的特殊类转换为字符串返回
/// </summary>
/// <param name="obj"></param>
/// <param name="sheet"></param>
/// <param name="varClass"></param>
/// <returns></returns>
private static string GetSpliteClassList(object obj, SheetClass sheet, VarClass varClass)
{
string str = "";
if (string.IsNullOrEmpty(varClass.SplitStr) || string.IsNullOrEmpty(varClass.Col))
{
Debug.LogError("字符分隔符或列名为空，请检查:" + varClass.Name);
return(str);
}
int listCount = System.Convert.ToInt32(obj.GetType().InvokeMember("get_Count", BindingFlags.Default | BindingFlags.InvokeMethod, null,
obj, new object[] { }));
for (int i = 0; i < listCount; i++)
{
object item = obj.GetType().InvokeMember("get_Item", BindingFlags.Default | BindingFlags.InvokeMethod, null,
obj, new object[] { i });
string tempStr = "";
for (int j = 0; j < sheet.VarList.Count; j++)
{
if (j != sheet.VarList.Count - 1)
{
tempStr += GetMemberValue(item, sheet.VarList[j].Name) + sheet.SplitStr;
}
else
{
tempStr += GetMemberValue(item, sheet.VarList[j].Name);
}
}
tempStr = tempStr.Replace("\\n", "\n").Replace("\\r", "\r");
if (i != listCount - 1)
{
str += tempStr + varClass.SplitStr;
}
else
{
str += tempStr;
}
}
str = str.Replace("\\n", "\n");
return(str);
}
/// <summary>
/// 解析xml配置
/// </summary>
/// <param name="attrElement"></param>
public static void ReadXmlNode(int depth, XmlElement attrElement, Dictionary <string, SheetClass> allSheetClassDic, SheetClass parentSheet)
{
VarClass attrVar = new VarClass()
{
Name = attrElement.GetAttribute("name"),
Col = attrElement.GetAttribute("col"),
Type = attrElement.GetAttribute("type"),
DeafultValue = attrElement.GetAttribute("defaultValue"),
Foregin = attrElement.GetAttribute("foregin"),
SplitStr = attrElement.GetAttribute("split"),
};
if (parentSheet != null)
{
parentSheet.VarList.Add(attrVar);
attrVar.ParentSheet = parentSheet;
}
if (attrElement.GetAttribute("type") == "list")
{
XmlElement listElement = attrElement.FirstChild as XmlElement;
SheetClass sheet = new SheetClass();
sheet.Name = listElement.GetAttribute("name");
sheet.SheetName = listElement.GetAttribute("sheetname");
sheet.MainKey = listElement.GetAttribute("mainKey");
sheet.SplitStr = listElement.GetAttribute("split");
sheet.ParentVar = attrVar;
sheet.Depth = depth;
if (!string.IsNullOrEmpty(sheet.SheetName))
{
if (!allSheetClassDic.ContainsKey(ParseDicKey(sheet)))
{
foreach (XmlElement itemElement in listElement.ChildNodes)
{
ReadXmlNode(++depth, itemElement, allSheetClassDic, sheet);
}
allSheetClassDic.Add(ParseDicKey(sheet), sheet);
attrVar.ListSheetName = ParseDicKey(sheet);
}
}
}
}
/// <summary>
/// 基础List赋值
/// </summary>
/// <param name="objClass"></param>
/// <param name="varClass"></param>
/// <param name="value"></param>
private static void SetSplitBaseClass(object objClass, VarClass varClass, string value)
{
Type type = null;
if (varClass.Type == "listStr")
{
type = typeof(string);
}
else if (varClass.Type == "listFloat")
{
type = typeof(float);
}
else if (varClass.Type == "listInt")
{
type = typeof(int);
}
else if (varClass.Type == "listBool")
{
type = typeof(bool);
}
object list = CreateList(type);
string[] rowArray = value.Split(new string[] { varClass.SplitStr }, StringSplitOptions.None);
for (int i = 0; i < rowArray.Length; i++)
{
object addItem = rowArray[i].Trim();
try
{
list.GetType().InvokeMember("Add", BindingFlags.Default | BindingFlags.InvokeMethod, null, list,
new object[] { addItem });
}
catch
{
Debug.Log(varClass.ListSheetName + " 里 " + varClass.Name + " 列表添加失败！具体数值是：" + addItem);
}
}
objClass.GetType().GetProperty(varClass.Name).SetValue(objClass, list);
}
/// <summary>
/// 基础类型List转化成分隔的字符串
/// </summary>
/// <param name="data">Xml转化的类</param>
/// <param name="varClass">varClass信息</param>
/// <returns></returns>
private static string GetSplitBaseList(object data, VarClass varClass)
{
if (string.IsNullOrEmpty(varClass.SplitStr))
{
Debug.LogError("GetSplitBaseList: 基础类型List分隔符为空");
return(null);
}
object dataList = GetMemberValue(data, varClass.Name);
int count = Convert.ToInt32(dataList.GetType().GetProperty("Count").GetValue(dataList));
string str = "";
for (int i = 0; i < count; i++)
{
object value = dataList.GetType().GetProperty("Item").GetValue(dataList, new object[] { i });
str += value.ToString();
if (i != count - 1)
{
str += varClass.SplitStr;
}
}
return(str);
}
/// <summary>
/// 获取基础List的输出字符串
/// </summary>
/// <param name="data"></param>
/// <param name="varClass"></param>
/// <returns></returns>
private static string GetListBaseStr(object data, VarClass varClass)
{
string str = "";
if (string.IsNullOrEmpty(varClass.SplitStr))
{
Debug.LogError("基础List中Split不允许为空！！！");
return(str);
}
object dataList = GetMemberValue(data, varClass.Name);
int listCount = System.Convert.ToInt32(dataList.GetType().InvokeMember("get_Count", BindingFlags.Default | BindingFlags.InvokeMethod, null, dataList, new object[] { }));
for (int i = 0; i < listCount; i++)
{
str += dataList.GetType().InvokeMember("get_Item", BindingFlags.Default | BindingFlags.InvokeMethod, null, dataList, new object[] { i }).ToString();
if (i != listCount - 1)
{
str += varClass.SplitStr;
}
}
return(str);
}
/// <summary>
/// 递归读取配置
/// </summary>
/// <param name="xe"></param>
private static void ReadXmlNode(XmlElement xmlElement, Dictionary <string, SheetClass> allSheetClassDic, int depth)
{
depth++;
foreach (XmlNode node in xmlElement.ChildNodes)
{
XmlElement xe = (XmlElement)node;
if (xe.GetAttribute("type") == "list")
{
XmlElement listEle = (XmlElement)node.FirstChild;
VarClass parentVar = new VarClass()
{
Name = xe.GetAttribute("name"),
Type = xe.GetAttribute("type"),
Col = xe.GetAttribute("col"),
DeafultValue = xe.GetAttribute("defaultValue"),
Foregin = xe.GetAttribute("foregin"),
SplitStr = xe.GetAttribute("split"),
};
if (parentVar.Type == "list")
{
parentVar.ListName = ((XmlElement)xe.FirstChild).GetAttribute("name");
parentVar.ListSheetName = ((XmlElement)xe.FirstChild).GetAttribute("sheetname");
}
SheetClass sheetClass = new SheetClass()
{
Name = listEle.GetAttribute("name"),
SheetName = listEle.GetAttribute("sheetname"),
SplitStr = listEle.GetAttribute("split"),
MainKey = listEle.GetAttribute("mainKey"),
ParentVar = parentVar,
Depth = depth,
};
if (!string.IsNullOrEmpty(sheetClass.SheetName))
{
if (!allSheetClassDic.ContainsKey(sheetClass.SheetName))
{
//获取该类下面所有变量
foreach (XmlNode insideNode in listEle.ChildNodes)
{
XmlElement insideXe = (XmlElement)insideNode;
VarClass varClass = new VarClass()
{
Name = insideXe.GetAttribute("name"),
Type = insideXe.GetAttribute("type"),
Col = insideXe.GetAttribute("col"),
DeafultValue = insideXe.GetAttribute("defaultValue"),
Foregin = insideXe.GetAttribute("foregin"),
SplitStr = insideXe.GetAttribute("split"),
};
if (varClass.Type == "list")
{
varClass.ListName = ((XmlElement)insideXe.FirstChild).GetAttribute("name");
varClass.ListSheetName = ((XmlElement)insideXe.FirstChild).GetAttribute("sheetname");
}
sheetClass.VarList.Add(varClass);
}
allSheetClassDic.Add(sheetClass.SheetName, sheetClass);
}
}
ReadXmlNode(listEle, allSheetClassDic, depth);
}
}
}
private static void ExcelToXml(string name)
{
string className = "";
string from = "";
string to = "";
//储存所有变量 sheet名 SheetClass
Dictionary <string, SheetClass> allSheetClassDic = ReadReg(name, ref className, ref from, ref to);
//储存所有data sheet名 sheetdata
Dictionary <string, SheetData> allSheetDataDic = new Dictionary <string, SheetData>();
string excelPath = EXCEL_DATA_PATH + from;
// string xmlPath = XML_DATA_PATH+to;
//读取excel文件
try{
using (FileStream fs = new FileStream(excelPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (ExcelPackage package = new ExcelPackage(fs)){
ExcelWorksheets workSheets = package.Workbook.Worksheets;
for (int i = 1; i <= workSheets.Count; i++)
{
ExcelWorksheet workSheet = workSheets[i];
int colCount = workSheet.Dimension.End.Column;
int rowCount = workSheet.Dimension.End.Row;
SheetData sheetData = new SheetData();//储存这一页的信息
//Reg中sheet的信息
SheetClass sheetClass = allSheetClassDic[workSheet.Name];
for (int j = 0; j < sheetClass.VarList.Count; j++)
{
VarClass curVarClass = sheetClass.VarList[j];
//储存 变量名 类型
sheetData.AllName.Add(curVarClass.Name);
sheetData.AllType.Add(curVarClass.Type);
}
//读取excel中的数据
//第一行是标题 所以跳过
for (int row = 1; row < rowCount; row++)
{
RowData data = new RowData();
int col = 0;
//如果这页sheet是外键数据 则第一列对应mainKey 数据从第二列开始
if (string.IsNullOrEmpty(sheetClass.SplitStr) && !string.IsNullOrEmpty(sheetClass.ParentVar.Foreign))
{
data.ParentKey = workSheet.Cells[row + 1, 1].Value.ToString().Trim();
col = 1;
}
for (; col < colCount; col++)
{
//每一行的信息
ExcelRange range = workSheet.Cells[row + 1, col + 1];
string colName = workSheet.Cells[1, col + 1].Value.ToString();
string value = range.Value != null?range.Value.ToString().Trim() : "";
data.RowDataDic.Add(GetNameFormCol(sheetClass.VarList, colName), value);
}
sheetData.AllRowData.Add(data);
}
allSheetDataDic.Add(workSheet.Name, sheetData);
}
}
}
catch (System.Exception e) {
Debug.LogError("XmlToExcel:Excel写入错误 " + e);
return;
}
//创建类 并赋值
object objClass = CreateClass(className);
List <string> outKeyList = new List <string>();
foreach (var item in allSheetClassDic)
{
SheetClass sheetClass = item.Value;
if (sheetClass.Depth == 1)
{
outKeyList.Add(item.Key);
}
}
for (int i = 0; i < outKeyList.Count; i++)
{
string key = outKeyList[i];
ReadDataToClass(objClass, allSheetClassDic[key], allSheetDataDic[key], allSheetClassDic, allSheetDataDic);
}
string xmlPath = XML_DATA_PATH + name + ".xml";
object obj = BinarySerializeOpt.XmlSerialize(xmlPath, objClass);
//转成二进制
// BinarySerializeOpt.BinarySerialize(BINARY_DATA_PATH, obj);
Debug.Log("Excel转Xml完成！" + from + "-->" + to);
AssetDatabase.Refresh();
}
/// <summary>
/// 递归读取类里面的数据
/// </summary>
/// <param name="data"></param>
/// <param name="sheetClass"></param>
/// <param name="allSheetClassDic"></param>
/// <param name="sheetDataDic"></param>
private static void ReadData(object data, SheetClass sheetClass, Dictionary <string, SheetClass> allSheetClassDic, Dictionary <string, SheetData> sheetDataDic, string mainKey)
{
List <VarClass> varList = sheetClass.VarList;
VarClass varClass = sheetClass.ParentVar;
object dataList = GetMemberValue(data, varClass.Name);
int listCount = System.Convert.ToInt32(dataList.GetType().InvokeMember("get_Count", BindingFlags.Default | BindingFlags.InvokeMethod, null, dataList, new object[] { }));
SheetData sheetData = new SheetData();
if (!string.IsNullOrEmpty(varClass.Foregin))
{
sheetData.AllName.Add(varClass.Foregin);
sheetData.AllType.Add(varClass.Type);
}
for (int i = 0; i < varList.Count; i++)
{
if (!string.IsNullOrEmpty(varList[i].Col))
{
sheetData.AllName.Add(varList[i].Col);
sheetData.AllType.Add(varList[i].Type);
}
}
string tempKey = mainKey;
for (int i = 0; i < listCount; i++)
{
object item = dataList.GetType().InvokeMember("get_Item", BindingFlags.Default | BindingFlags.InvokeMethod, null, dataList, new object[] { i });
RowData rowData = new RowData();
if (!string.IsNullOrEmpty(varClass.Foregin) && !string.IsNullOrEmpty(tempKey))
{
rowData.RowDataDic.Add(varClass.Foregin, tempKey);
}
if (!string.IsNullOrEmpty(sheetClass.MainKey))
{
mainKey = GetMemberValue(item, sheetClass.MainKey).ToString();
}
for (int j = 0; j < varList.Count; j++)
{
if (varList[j].Type == "list" && string.IsNullOrEmpty(varList[j].SplitStr))
{
SheetClass tempSheetClass = allSheetClassDic[varList[j].ListSheetName];
ReadData(item, tempSheetClass, allSheetClassDic, sheetDataDic, mainKey);
}
else if (varList[j].Type == "list")
{
SheetClass tempSheetClass = allSheetClassDic[varList[j].ListSheetName];
string value = GetSplitStrList(item, varList[j], tempSheetClass);
rowData.RowDataDic.Add(varList[j].Col, value);
}
else if (varList[j].Type == "listStr" || varList[j].Type == "listFloat" || varList[j].Type == "listInt" || varList[j].Type == "listBool")
{
string value = GetSpliteBaseList(item, varList[j]);
rowData.RowDataDic.Add(varList[j].Col, value);
}
else
{
object value = GetMemberValue(item, varList[j].Name);
if (varList != null)
{
rowData.RowDataDic.Add(varList[j].Col, value.ToString());
}
else
{
Debug.LogError(varList[j].Name + "反射出来为空！");
}
}
}
string key = varClass.ListSheetName;
if (sheetDataDic.ContainsKey(key))
{
sheetDataDic[key].AllData.Add(rowData);
}
else
{
sheetData.AllData.Add(rowData);
sheetDataDic.Add(key, sheetData);
}
}
}
/// <summary>
/// XmlToExcel 将sheetClass数据读取到类
/// </summary>
/// <param name="data">Xml转化的类</param>
/// <param name="sheetClass">需要读取的sheetClass</param>
/// <param name="allSheetClassDic">读取</param>
/// <param name="allSheetDataDic">储存</param>
private static void ReadData(object data, SheetClass sheetClass, Dictionary <string, SheetClass> allSheetClassDic, Dictionary <string, SheetData> allSheetDataDic, string mainKey = "")
{
VarClass parentClass = sheetClass.ParentVar;
string name = parentClass.Name;
//外部主体
object dataList = GetMemberValue(data, name);
int count = Convert.ToInt32(dataList.GetType().GetProperty("Count").GetValue(dataList));
List <VarClass> varList = sheetClass.VarList;//sheet下所有的variable
//储存name和type
SheetData sheetData = new SheetData();
if (!string.IsNullOrEmpty(parentClass.Foreign))
{
sheetData.AllName.Add(parentClass.Foreign);
sheetData.AllType.Add(parentClass.Type);
}
for (int i = 0; i < varList.Count; i++)
{
if (!string.IsNullOrEmpty(varList[i].Col))
{
//这里看看是否存 Col
sheetData.AllName.Add(varList[i].Col);
sheetData.AllType.Add(varList[i].Type);
}
}
string tempKey = mainKey;
//储存rowdata
for (int i = 0; i < count; i++)
{
//
object item = dataList.GetType().GetProperty("Item").GetValue(dataList, new object[] { i });
//反射rowdata
RowData rowData = new RowData();
if (!string.IsNullOrEmpty(parentClass.Foreign) && !string.IsNullOrEmpty(tempKey))
{
rowData.RowDataDic.Add(parentClass.Foreign, tempKey);
}
if (!string.IsNullOrEmpty(sheetClass.MainKey))
{
mainKey = GetMemberValue(item, sheetClass.MainKey).ToString();
}
//
for (int j = 0; j < varList.Count; j++)
{
VarClass curVarClass = varList[j];
if (curVarClass.Type == "list")
{
if (string.IsNullOrEmpty(curVarClass.SplitStr))
{
SheetClass temp = allSheetClassDic[curVarClass.SheetName];
ReadData(item, temp, allSheetClassDic, allSheetDataDic, mainKey);
}
else
{
SheetClass temp = allSheetClassDic[curVarClass.SheetName];
string split = GetSplitStrList(item, curVarClass, temp);
rowData.RowDataDic.Add(curVarClass.Col, split);
}
}
//xml基础list类型
else if (XML_BASE_TYPE.Contains(curVarClass.Type))
{
string split = GetSplitBaseList(item, curVarClass);
rowData.RowDataDic.Add(curVarClass.Col, split);
}
else
{
object value = GetMemberValue(item, curVarClass.Name);
if (value != null)
{
rowData.RowDataDic.Add(curVarClass.Col, value.ToString());
}
else
{
Debug.LogError("ReadData ：" + curVarClass.Name + " 反射为空 请检查配置");
}
}
}
//储存进字典(Excel表的sheet)
string key = parentClass.SheetName;
if (allSheetDataDic.ContainsKey(key))
{
allSheetDataDic[key].AllRowData.Add(rowData);
}
else
{
sheetData.AllRowData.Add(rowData);
allSheetDataDic.Add(key, sheetData);
}
}
}
//递归读取xml中的数据
private static void ReadXmlElement(XmlElement xe, Dictionary <string, SheetClass> allSheetClassDic, int depth)
{
depth++;//sheet表的深度
foreach (XmlElement item in xe.ChildNodes)
{
string type = item.GetAttribute("type");
if (type == "list")
{
XmlElement first = (XmlElement)item.FirstChild;
VarClass parentVar = new VarClass()
{
Name = item.GetAttribute("name"),
Type = item.GetAttribute("type"),
Col = item.GetAttribute("col"),
DefaultValue = item.GetAttribute("default"),
Foreign = item.GetAttribute("foreign"),
SplitStr = item.GetAttribute("split"),
};
//如果是list储存 和sheet的关联信息
if (parentVar.Type == "list")
{
parentVar.ListName = first.GetAttribute("name");
parentVar.SheetName = first.GetAttribute("sheetname");
}
string sheetName = first.GetAttribute("sheetname");
if (!string.IsNullOrEmpty(sheetName))
{
if (!allSheetClassDic.ContainsKey(sheetName))
{
//如果未储存的SheetName 则新建一个储存
SheetClass sheetClass = new SheetClass()
{
ParentVar = parentVar,
Name = first.GetAttribute("name"),
SheetName = first.GetAttribute("sheetname"),
MainKey = first.GetAttribute("mainkey"),
SplitStr = first.GetAttribute("split"),
Depth = depth,
};
//遍历包含的变量
foreach (XmlElement xmlEle in first.ChildNodes)
{
VarClass eleVar = new VarClass()
{
Name = xmlEle.GetAttribute("name"),
Type = xmlEle.GetAttribute("type"),
Col = xmlEle.GetAttribute("col"),
DefaultValue = xmlEle.GetAttribute("deafult"),
Foreign = xmlEle.GetAttribute("foreign"),
SplitStr = xmlEle.GetAttribute("split"),
};
//如果是list储存 和sheet的关联信息
if (eleVar.Type == "list")
{
eleVar.ListName = ((XmlElement)xmlEle.FirstChild).GetAttribute("name");
eleVar.SheetName = ((XmlElement)xmlEle.FirstChild).GetAttribute("sheetname");
}
sheetClass.VarList.Add(eleVar); //添加到sheet的变量list
}
allSheetClassDic.Add(sheetName, sheetClass); //储存到sheet字典
}
}
ReadXmlElement(first, allSheetClassDic, depth);
}
}
}
/// <summary>
/// 读取xml配置表中所有节点
/// </summary>
/// <param name="xmlElement"></param>
/// <param name="allSheetDict"></param>
/// <param name="depth"></param>
private static void ReadXmlNode(XmlElement xmlElement, Dictionary <string, SheetClass> allSheetDict, int depth)
{
depth++;
foreach (XmlNode tempNode in xmlElement.ChildNodes)
{
XmlElement tempElement = tempNode as XmlElement;
string type = tempElement.GetAttribute("type");
if (type == "list")
{
XmlElement listEle = tempElement.FirstChild as XmlElement;
VarClass parentVar = new VarClass
{
Name = tempElement.GetAttribute("name"),
Type = tempElement.GetAttribute("type"),
Col = tempElement.GetAttribute("col"),
DeafultValue = tempElement.GetAttribute("defultvalue"),
Foreign = tempElement.GetAttribute("foreign"),
SplitStr = tempElement.GetAttribute("split"),
};
if (parentVar.Type == "list")
{
parentVar.ListName = listEle.GetAttribute("name");
parentVar.ListSheetName = listEle.GetAttribute("sheetname");
}
SheetClass sheet = new SheetClass
{
ParentVar = parentVar,
Name = listEle.GetAttribute("name"),
SheetName = listEle.GetAttribute("sheetname"),
MainKey = listEle.GetAttribute("mainkey"),
SplitStr = listEle.GetAttribute("split"),
Depth = depth,
};
if (!string.IsNullOrEmpty(sheet.SheetName))
{
if (!allSheetDict.ContainsKey(sheet.SheetName))
{
sheet.VarList = new List <VarClass>();
foreach (XmlNode node in listEle.ChildNodes)
{
XmlElement xe = node as XmlElement;
VarClass varClass = new VarClass
{
Name = xe.GetAttribute("name"),
Type = xe.GetAttribute("type"),
Col = xe.GetAttribute("col"),
DeafultValue = xe.GetAttribute("defultvalue"),
Foreign = xe.GetAttribute("foreign"),
SplitStr = xe.GetAttribute("split"),
};
if (varClass.Type == "list")
{
varClass.ListName = ((XmlElement)xe.FirstChild).GetAttribute("name");
varClass.ListSheetName = ((XmlElement)xe.FirstChild).GetAttribute("sheetname");
}
sheet.VarList.Add(varClass);
}
allSheetDict.Add(sheet.SheetName, sheet);
}
}
ReadXmlNode(listEle, allSheetDict, depth);
}
else
{
}
}
}
