public static void ReadLangData()
{
if (IsLang)
{
GetParamValue();
string errorString = null;
LangData = TxtConfigReader.ParseTxtConfigFile(LangPath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
AppLog.LogErrorAndExit(errorString);
}
}
}
/// <summary>
/// 将翻译后的字典读取文件中
/// </summary>
public static void GetLanguageDictData()
{
if (ExcelFolder.TheLanguage != "")
{
string errorString = null;
string MoreLanguagePath = FileModule.CombinePath(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, "Language");;
string TheLanguageDicPath = FileModule.CombinePath(MoreLanguagePath, "Language" + ExcelFolder.TheLanguage);
string TheLanguageDicFile = FileModule.CombinePath(TheLanguageDicPath, ExcelFolder.TheLanguage + "_dict.txt");
if (!File.Exists(TheLanguageDicFile))
{
return;
}
LanguageDictData = TxtConfigReader.ParseTxtConfigFile(TheLanguageDicFile, "\t", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
AppLog.LogErrorAndExit(errorString);
}
}
}
public MainForm()
{
InitializeComponent();
tbFormat.Text = "tableString[在这里填写格式定义]";
// 导入lang文件内容
if (File.Exists("lang.txt"))
{
string errorString = null;
AppValues.LangData = TxtConfigReader.ParseTxtConfigFile("lang.txt", ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
errorString = "lang.txt文件中存在错误，请修正后重新运行，程序被迫退出" + System.Environment.NewLine + errorString;
MessageBox.Show(errorString, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
Environment.Exit(0);
}
}
else
{
MessageBox.Show("未找到本程序所在目录下的lang.txt文件，将无法使用lang数据类型", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
public static void ReadConfig()
{
GetParamValue();
if (File.Exists(AppConfig.ConfigPath))
{
string errorString = null;
AppValues.ConfigData = TxtConfigReader.ParseTxtConfigFile(AppConfig.ConfigPath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
AppLog.LogErrorAndExit(errorString);
}
}
else
{
AppLog.LogWarning(string.Format("警告：找不到本工具所在路径下的{0}配置文件，请确定是否真的不需要自定义配置", AppConfig.ConfigPath));
}
//检查datetime类型，并初始化
// 读取部分配置项并进行检查
const string ERROR_STRING_FORMAT = "配置项\"{0}\"所设置的值\"{1}\"非法：{2}\n";
StringBuilder errorStringBuilder = new StringBuilder();
string tempErrorString = null;
if (AppValues.ConfigData.ContainsKey(DateTimeValue.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT))
{
DateTimeValue.DefaultDateInputFormat = AppValues.ConfigData[DateTimeValue.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT].Trim();
if (TableCheckHelper.CheckDateInputDefine(DateTimeValue.DefaultDateInputFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, DateTimeValue.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT, DateTimeValue.DefaultDateInputFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(DateTimeValue.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT))
{
DateTimeValue.DefaultTimeInputFormat = AppValues.ConfigData[DateTimeValue.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(DateTimeValue.DefaultTimeInputFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, DateTimeValue.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT, DateTimeValue.DefaultTimeInputFormat, tempErrorString);
}
}
//if (AppValues.ConfigData.ContainsKey(DateTimeValue.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT))
//{
// DateTimeValue.DefaultDateInputFormat = AppValues.ConfigData[DateTimeValue.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT].Trim();
// if (TableCheckHelper.CheckDateInputDefine(DateTimeValue.DefaultDateInputFormat, out tempErrorString) == false)
// errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, DateTimeValue.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT, DateTimeValue.DefaultDateInputFormat, tempErrorString);
//}
//if (AppValues.ConfigData.ContainsKey(LuaStruct.DefaultDateToExportFormatKey))
//{
// LuaStruct.DefaultDateToExportFormat = AppValues.ConfigData[LuaStruct.DefaultDateToExportFormatKey].Trim();
// if (TableCheckHelper.CheckDateToLuaDefine(LuaStruct.DefaultDateToExportFormat, out tempErrorString) == false)
// errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, LuaStruct.DefaultDateToExportFormatKey, LuaStruct.DefaultDateToExportFormat, tempErrorString);
//}
//if (AppValues.ConfigData.ContainsKey(MySQLStruct.DefaultDateToExportFormatKey))
//{
// MySQLStruct.DefaultDateToExportFormat = AppValues.ConfigData[MySQLStruct.DefaultDateToExportFormatKey].Trim();
// if (TableCheckHelper.CheckDateToDatabaseDefine(MySQLStruct.DefaultDateToExportFormat, out tempErrorString) == false)
// errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, MySQLStruct.DefaultDateToExportFormatKey, MySQLStruct.DefaultDateToExportFormat, tempErrorString);
//}
//if (AppValues.ConfigData.ContainsKey(DateTimeValue.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT))
//{
// DateTimeValue.DefaultTimeInputFormat = AppValues.ConfigData[DateTimeValue.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT].Trim();
// if (TableCheckHelper.CheckTimeDefine(DateTimeValue.DefaultTimeInputFormat, out tempErrorString) == false)
// errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, DateTimeValue.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT, DateTimeValue.DefaultTimeInputFormat, tempErrorString);
//}
//if (AppValues.ConfigData.ContainsKey(LuaStruct.DefaultTimeToExportFormatKey))
//{
// LuaStruct.DefaultTimeToExportFormat = AppValues.ConfigData[LuaStruct.DefaultTimeToExportFormatKey].Trim();
// if (TableCheckHelper.CheckTimeDefine(LuaStruct.DefaultTimeToExportFormat, out tempErrorString) == false)
// errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, LuaStruct.DefaultTimeToExportFormatKey, LuaStruct.DefaultTimeToExportFormat, tempErrorString);
//}
//if (AppValues.ConfigData.ContainsKey(MySQLStruct.DefaultTimeToExportFormatKey))
//{
// MySQLStruct.DefaultTimeToExportFormat = AppValues.ConfigData[MySQLStruct.DefaultTimeToExportFormatKey].Trim();
// if (TableCheckHelper.CheckTimeDefine(MySQLStruct.DefaultTimeToExportFormat, out tempErrorString) == false)
// errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, MySQLStruct.DefaultTimeToExportFormatKey, MySQLStruct.DefaultTimeToExportFormat, tempErrorString);
//}
string errorConfigString = errorStringBuilder.ToString();
if (!string.IsNullOrEmpty(errorConfigString))
{
errorConfigString = string.Concat("配置文件中存在以下错误，请修正后重试\n", errorConfigString);
AppLog.LogErrorAndExit(errorConfigString);
}
}
/// <summary>
/// 传入参数中，第1个必须为Excel表格所在目录，第2个必须为存放导出lua文件的目录，第3个参数为项目Client目录的路径（无需文件存在型检查规则则填-noClient），第4个参数为必须为lang文件路径（没有填-noLang）
/// 可附加参数有：
/// 1) -columnInfo（在生成lua文件的最上方用注释形式显示列信息，默认不开启）
/// 2) -unchecked（不对表格进行查错，不推荐使用）
/// 3) -printEmptyStringWhenLangNotMatching（当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串即xx = ""，默认为输出nil）
/// 4) -exportMySQL（将表格数据导出到MySQL数据库中，默认不导出）
/// 5) -part（后面在英文小括号内声明本次要导出的Excel文件名，用|分隔，未声明的文件将被本工具忽略）
/// 6) -allowedNullNumber（允许int、long、float型字段下填写空值，默认不允许）
/// 7) 声明要将指定的Excel表导出为csv文件需要以下2个参数：
/// -exportCsv（后面在英文小括号内声明本次要额外导出csv文件的Excel文件名，用|分隔。注意如果-part参数中未指定本次要导出某个Excel表，即便声明要导出csv文件也不会生效）
/// -exportCsvParam（可声明导出csv文件的参数）
/// 8) 声明要将指定的Excel表导出为json文件需要以下2个参数：
/// -exportJson（后面在英文小括号内声明本次要额外导出json文件的Excel文件名，用|分隔。注意如果-part参数中未指定本次要导出某个Excel表，即便声明要导出json文件也不会生效）
/// -exportJsonParam（可声明导出json文件的参数）
/// </summary>
static void Main(string[] args)
{
// 检查第1个参数（Excel表格所在目录）是否正确
if (args.Length < 1)
{
Utils.LogErrorAndExit("错误：未输入Excel表格所在目录");
}
if (!Directory.Exists(args[0]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的Excel表格所在目录不存在，路径为{0}", args[0]));
}
AppValues.ExcelFolderPath = Path.GetFullPath(args[0]);
Utils.Log(string.Format("选择的Excel所在路径：{0}", AppValues.ExcelFolderPath));
// 记录目录中存在的所有Excel文件名（注意不能直接用File.Exists判断某个字符串代表的文件名是否存在，因为Windows会忽略声明的Excel文件名与实际文件名的大小写差异）
List <string> existExcelFilePaths = new List <string>(Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"));
List <string> existExcelFileNames = new List <string>();
foreach (string filePath in existExcelFilePaths)
{
existExcelFileNames.Add(Path.GetFileNameWithoutExtension(filePath));
}
// 检查第2个参数（存放导出lua文件的目录）是否正确
if (args.Length < 2)
{
Utils.LogErrorAndExit("错误：未输入要将生成lua文件存放的路径");
}
if (!Directory.Exists(args[1]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的lua文件导出路径不存在，路径为{0}", args[1]));
}
AppValues.ExportLuaFilePath = Path.GetFullPath(args[1]);
Utils.Log(string.Format("选择的lua文件导出路径：{0}", AppValues.ExportLuaFilePath));
// 检查第3个参数（项目Client目录的路径）是否正确
if (args.Length < 3)
{
Utils.LogErrorAndExit("错误：未输入项目Client目录的路径，如果不需要请输入参数-noClient");
}
if (AppValues.NO_CLIENT_PATH_STRING.Equals(args[2], StringComparison.CurrentCultureIgnoreCase))
{
Utils.LogWarning("警告：你选择了不指定Client文件夹路径，则本工具无法检查表格中填写的图片路径等对应的文件是否存在");
AppValues.ClientPath = null;
}
else if (Directory.Exists(args[2]))
{
AppValues.ClientPath = Path.GetFullPath(args[2]);
Utils.Log(string.Format("Client目录完整路径：{0}", AppValues.ClientPath));
}
else
{
Utils.LogErrorAndExit(string.Format("错误：请检查输入的Client路径是否正确{0}", args[2]));
}
// 检查第4个参数（lang文件路径）是否正确
if (args.Length < 4)
{
Utils.LogErrorAndExit("错误：未输入lang文件路径或未声明不含lang文件（使用-noLang）");
}
if (AppValues.NO_LANG_PARAM_STRING.Equals(args[3], StringComparison.CurrentCultureIgnoreCase))
{
AppValues.LangFilePath = null;
Utils.Log("选择的lang文件路径：无");
}
else if (File.Exists(args[3]))
{
AppValues.LangFilePath = Path.GetFullPath(args[3]);
Utils.Log(string.Format("选择的lang文件路径：{0}", AppValues.LangFilePath));
// 解析lang文件
string errorString = null;
AppValues.LangData = TxtConfigReader.ParseTxtConfigFile(AppValues.LangFilePath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：输入的lang文件不存在，路径为{0}", args[3]));
}
// 检查其他参数
for (int i = 4; i < args.Length; ++i)
{
string param = args[i];
if (param.Equals(AppValues.UNCHECKED_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsNeedCheck = false;
Utils.LogWarning("警告：你选择了不进行表格检查，请务必自己保证表格的正确性");
}
else if (param.Equals(AppValues.NEED_COLUMN_INFO_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsNeedColumnInfo = true;
Utils.LogWarning("你选择了在生成的lua文件最上方用注释形式显示列信息");
}
else if (param.Equals(AppValues.LANG_NOT_MATCHING_PRINT_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsPrintEmptyStringWhenLangNotMatching = true;
Utils.LogWarning("你选择了当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串");
}
else if (param.Equals(AppValues.EXPORT_MYSQL_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsExportMySQL = true;
Utils.LogWarning("你选择了导出表格数据到MySQL数据库");
}
else if (param.StartsWith(AppValues.PART_EXPORT_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
// 解析声明的本次要导出的Excel名
string errorString = null;
string[] fileNames = Utils.GetExcelFileNames(param, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：声明导出部分Excel表格的参数{0}后{1}", AppValues.PART_EXPORT_PARAM_STRING, errorString));
}
else
{
foreach (string fileName in fileNames)
{
AppValues.exportTableNames.Add(fileName.Trim());
}
// 检查指定导出的Excel文件是否存在
foreach (string exportExcelFileName in AppValues.exportTableNames)
{
if (!existExcelFileNames.Contains(exportExcelFileName))
{
Utils.LogErrorAndExit(string.Format("要求导出的Excel文件（{0}）不存在，请检查后重试并注意区分大小写", Utils.CombinePath(AppValues.ExcelFolderPath, string.Concat(exportExcelFileName, ".xlsx"))));
}
}
Utils.LogWarning(string.Format("警告：本次将仅检查并导出以下Excel文件：\n{0}\n", Utils.CombineString(AppValues.exportTableNames, ", ")));
}
}
// 注意：-exportCsv与-exportCsvParam均以-exportCsv开头，故要先判断-exportCsvParam分支。这里将-exportCsvParam的解析放到-exportCsv的解析之中是为了只有声明了进行csv文件导出时才解析导出参数
else if (param.StartsWith(AppValues.EXPORT_CSV_PARAM_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
else if (param.StartsWith(AppValues.EXPORT_CSV_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
// 首先解析并判断配置的csv文件导出参数是否正确
string exportCsvParamString = null;
for (int j = 4; j < args.Length; ++j)
{
string tempParam = args[j];
if (tempParam.StartsWith(AppValues.EXPORT_CSV_PARAM_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
exportCsvParamString = tempParam;
break;
}
}
if (exportCsvParamString != null)
{
int leftBracketIndex = exportCsvParamString.IndexOf('(');
int rightBracketIndex = exportCsvParamString.LastIndexOf(')');
if (leftBracketIndex == -1 || rightBracketIndex == -1 || leftBracketIndex > rightBracketIndex)
{
Utils.LogErrorAndExit(string.Format("错误：声明导出csv文件的参数{0}后必须在英文小括号内声明各个具体参数", AppValues.EXPORT_CSV_PARAM_PARAM_STRING));
}
else
{
string paramString = exportCsvParamString.Substring(leftBracketIndex + 1, rightBracketIndex - leftBracketIndex - 1);
// 通过|分隔各个参数，但因为用户设置的csv文件中的字段分隔符本身可能为|，本工具采用\|配置进行转义，故需要自行从头遍历查找真正的参数分隔符
// 记录参数分隔符的下标位置
List <int> splitParamCharIndex = new List <int>();
for (int index = 0; index < paramString.Length; ++index)
{
char c = paramString[index];
if (c == '|' && (index < 1 || (index > 1 && paramString[index - 1] != '\\')))
{
splitParamCharIndex.Add(index);
}
}
// 通过识别的参数分隔符，分隔各个参数
List <string> paramStringList = new List <string>();
int lastSplitParamChatIndex = -1;
foreach (int index in splitParamCharIndex)
{
paramStringList.Add(paramString.Substring(lastSplitParamChatIndex + 1, index - lastSplitParamChatIndex - 1));
lastSplitParamChatIndex = index;
}
// 解析各个具体参数
foreach (string oneParamString in paramStringList)
{
if (string.IsNullOrEmpty(oneParamString))
{
continue;
}
string[] keyAndValue = oneParamString.Split(new char[] { '=' });
if (keyAndValue.Length != 2)
{
Utils.LogErrorAndExit(string.Format("声明的{0}参数下属的参数字符串{1}错误，参数名和配置值之间应用=分隔", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, oneParamString));
}
else
{
string key = keyAndValue[0].Trim();
string value = keyAndValue[1];
if (AppValues.EXPORT_CSV_PARAM_EXPORT_PATH_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
// 检查导出路径是否存在
if (!Directory.Exists(value))
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的csv文件导出路径不存在", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.EXPORT_CSV_PARAM_EXPORT_PATH_PARAM_STRING));
}
else
{
AppValues.exportCsvPath = value;
}
}
else if (AppValues.EXPORT_CSV_PARAM_EXTENSION_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
value = value.Trim();
if (string.IsNullOrEmpty(value))
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的导出csv文件的扩展名不允许为空", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.EXPORT_CSV_PARAM_EXTENSION_PARAM_STRING));
}
if (value.StartsWith("."))
{
value = value.Substring(1);
}
AppValues.exportCsvExtension = value;
}
else if (AppValues.EXPORT_CSV_PARAM_SPLIT_STRING_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
value = value.Replace("\\|", "|");
AppValues.exportCsvSplitString = value;
}
else if (AppValues.EXPORT_CSV_PARAM_IS_EXPORT_COLUMN_NAME_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
value = value.Trim();
if ("true".Equals(value, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.exportCsvIsExportColumnName = true;
}
else if ("false".Equals(value, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.exportCsvIsExportColumnName = false;
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的值错误，必须为true或false", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.EXPORT_CSV_PARAM_IS_EXPORT_COLUMN_NAME_PARAM_STRING));
}
}
else if (AppValues.EXPORT_CSV_PARAM_IS_EXPORT_COLUMN_DATA_TYPE_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
value = value.Trim();
if ("true".Equals(value, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.exportCsvIsExportColumnDataType = true;
}
else if ("false".Equals(value, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.exportCsvIsExportColumnDataType = false;
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的值错误，必须为true或false", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.EXPORT_CSV_PARAM_IS_EXPORT_COLUMN_DATA_TYPE_PARAM_STRING));
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}非法", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, key));
}
}
}
// 要求必须含有exportPath参数
if (AppValues.exportCsvPath == null)
{
Utils.LogErrorAndExit(string.Format("错误：声明要额外导出指定Excel文件为csv文件，就必须同时在{0}参数下声明用于配置csv文件导出路径的参数{1}", AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.EXPORT_CSV_PARAM_EXPORT_PATH_PARAM_STRING));
}
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明要额外导出指定Excel文件为csv文件，就必须同时声明用于配置csv文件导出参数的{0}", AppValues.EXPORT_CSV_PARAM_PARAM_STRING));
}
// 解析配置的要额外导出csv文件的Excel文件名
string errorString = null;
string[] fileNames = Utils.GetExcelFileNames(param, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：声明额外导出为csv文件的参数{0}后{1}", AppValues.EXPORT_CSV_PARAM_STRING, errorString));
}
else
{
// 检查指定导出的Excel文件是否存在
foreach (string fileName in fileNames)
{
if (!existExcelFileNames.Contains(fileName))
{
Utils.LogErrorAndExit(string.Format("要求额外导出为csv文件的Excel表（{0}）不存在，请检查后重试并注意区分大小写", Utils.CombinePath(AppValues.exportCsvPath, string.Concat(fileName, ".xlsx"))));
}
else
{
AppValues.exportCsvTableNames.Add(fileName);
}
}
}
}
// 注意：-exportJson与-exportJsonParam均以-exportJson开头，故要先判断-exportJsonParam分支。这里将-exportJsonParam的解析放到-exportJson的解析之中是为了只有声明了进行json文件导出时才解析导出参数
else if (param.StartsWith(AppValues.EXPORT_JSON_PARAM_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
else if (param.StartsWith(AppValues.EXPORT_JSON_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
// 首先解析并判断配置的json文件导出参数是否正确
string exportJsonParamString = null;
for (int j = 4; j < args.Length; ++j)
{
string tempParam = args[j];
if (tempParam.StartsWith(AppValues.EXPORT_JSON_PARAM_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
exportJsonParamString = tempParam;
break;
}
}
if (exportJsonParamString != null)
{
int leftBracketIndex = exportJsonParamString.IndexOf('(');
int rightBracketIndex = exportJsonParamString.LastIndexOf(')');
if (leftBracketIndex == -1 || rightBracketIndex == -1 || leftBracketIndex > rightBracketIndex)
{
Utils.LogErrorAndExit(string.Format("错误：声明导出json文件的参数{0}后必须在英文小括号内声明各个具体参数", AppValues.EXPORT_JSON_PARAM_PARAM_STRING));
}
else
{
string paramString = exportJsonParamString.Substring(leftBracketIndex + 1, rightBracketIndex - leftBracketIndex - 1);
// 通过|分隔各个参数
string[] paramStringList = paramString.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
// 解析各个具体参数
foreach (string oneParamString in paramStringList)
{
string[] keyAndValue = oneParamString.Split(new char[] { '=' });
if (keyAndValue.Length != 2)
{
Utils.LogErrorAndExit(string.Format("声明的{0}参数下属的参数字符串{1}错误，参数名和配置值之间应用=分隔", AppValues.EXPORT_JSON_PARAM_PARAM_STRING, oneParamString));
}
else
{
string key = keyAndValue[0].Trim();
string value = keyAndValue[1];
if (AppValues.EXPORT_JSON_PARAM_EXPORT_PATH_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
// 检查导出路径是否存在
if (!Directory.Exists(value))
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的json文件导出路径不存在", AppValues.EXPORT_JSON_PARAM_PARAM_STRING, AppValues.EXPORT_JSON_PARAM_EXPORT_PATH_PARAM_STRING));
}
else
{
AppValues.exportJsonPath = value;
}
}
else if (AppValues.EXPORT_JSON_PARAM_EXTENSION_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
value = value.Trim();
if (string.IsNullOrEmpty(value))
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的导出json文件的扩展名不允许为空", AppValues.EXPORT_JSON_PARAM_PARAM_STRING, AppValues.EXPORT_JSON_PARAM_EXTENSION_PARAM_STRING));
}
if (value.StartsWith("."))
{
value = value.Substring(1);
}
AppValues.exportJsonExtension = value;
}
else if (AppValues.EXPORT_JSON_PARAM_IS_FORMAT_PARAM_STRING.Equals(key, StringComparison.CurrentCultureIgnoreCase))
{
value = value.Trim();
if ("true".Equals(value, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.exportJsonIsFormat = true;
}
else if ("false".Equals(value, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.exportJsonIsFormat = false;
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}所配置的值错误，必须为true或false", AppValues.EXPORT_JSON_PARAM_PARAM_STRING, AppValues.EXPORT_JSON_PARAM_IS_FORMAT_PARAM_STRING));
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明的{0}参数下属的参数{1}非法", AppValues.EXPORT_JSON_PARAM_PARAM_STRING, key));
}
}
}
// 要求必须含有exportPath参数
if (AppValues.exportJsonPath == null)
{
Utils.LogErrorAndExit(string.Format("错误：声明要额外导出指定Excel文件为json文件，就必须同时在{0}参数下声明用于配置json文件导出路径的参数{1}", AppValues.EXPORT_JSON_PARAM_PARAM_STRING, AppValues.EXPORT_JSON_PARAM_EXPORT_PATH_PARAM_STRING));
}
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：声明要额外导出指定Excel文件为json文件，就必须同时声明用于配置json文件导出参数的{0}", AppValues.EXPORT_JSON_PARAM_PARAM_STRING));
}
// 解析配置的要额外导出json文件的Excel文件名
string errorString = null;
string[] fileNames = Utils.GetExcelFileNames(param, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：声明额外导出为json文件的参数{0}后{1}", AppValues.EXPORT_JSON_PARAM_STRING, errorString));
}
else
{
// 检查指定导出的Excel文件是否存在
foreach (string fileName in fileNames)
{
if (!existExcelFileNames.Contains(fileName))
{
Utils.LogErrorAndExit(string.Format("要求额外导出为json文件的Excel表（{0}）不存在，请检查后重试并注意区分大小写", Utils.CombinePath(AppValues.exportJsonPath, string.Concat(fileName, ".xlsx"))));
}
else
{
AppValues.exportJsonTableNames.Add(fileName);
}
}
}
}
else if (param.StartsWith(AppValues.ALLOWED_NULL_NUMBER_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsAllowedNullNumber = true;
Utils.LogWarning("警告：你选择了允许int、long、float字段中存在空值，建议为逻辑上不允许为空的数值型字段声明使用notEmpty检查规则");
}
else
{
Utils.LogErrorAndExit(string.Format("错误：未知的指令参数{0}", param));
}
}
// 如果未指定导出部分Excel文件，则全部导出
if (AppValues.exportTableNames.Count == 0)
{
foreach (string filePath in Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"))
{
string fileName = Path.GetFileNameWithoutExtension(filePath);
if (fileName.StartsWith(AppValues.EXCEL_TEMP_FILE_FILE_NAME_START_STRING))
{
Utils.LogWarning(string.Format("目录中的{0}文件为Excel自动生成的临时文件，将被忽略处理", filePath));
}
else
{
AppValues.exportTableNames.Add(Path.GetFileNameWithoutExtension(filePath));
}
}
}
// 如果声明要额外导出为csv文件的Excel表本身在本次被忽略，需要进行警告
List <string> warnExportCsvTableNames = new List <string>();
foreach (string exportCsvTableName in AppValues.exportCsvTableNames)
{
if (!AppValues.exportTableNames.Contains(exportCsvTableName))
{
warnExportCsvTableNames.Add(exportCsvTableName);
}
}
if (warnExportCsvTableNames.Count > 0)
{
Utils.LogWarning(string.Format("警告：以下Excel表声明为要额外导出为csv文件，但在{0}参数中未声明本次要对其进行导出，本工具将不对这些表格执行导出csv文件的操作\n{1}", AppValues.PART_EXPORT_PARAM_STRING, Utils.CombineString(warnExportCsvTableNames, ", ")));
foreach (string tableName in warnExportCsvTableNames)
{
AppValues.exportCsvTableNames.Remove(tableName);
}
}
if (AppValues.exportCsvTableNames.Count > 0)
{
Utils.Log(string.Format("本次将以下Excel表额外导出为csv文件：\n{0}\n", Utils.CombineString(AppValues.exportCsvTableNames, ", ")));
}
// 如果声明要额外导出为json文件的Excel表本身在本次被忽略，需要进行警告
List <string> warnExportJsonTableNames = new List <string>();
foreach (string exportJsonTableName in AppValues.exportJsonTableNames)
{
if (!AppValues.exportTableNames.Contains(exportJsonTableName))
{
warnExportJsonTableNames.Add(exportJsonTableName);
}
}
if (warnExportJsonTableNames.Count > 0)
{
Utils.LogWarning(string.Format("警告：以下Excel表声明为要额外导出为json文件，但在{0}参数中未声明本次要对其进行导出，本工具将不对这些表格执行导出json文件的操作\n{1}", AppValues.PART_EXPORT_PARAM_STRING, Utils.CombineString(warnExportJsonTableNames, ", ")));
foreach (string tableName in warnExportJsonTableNames)
{
AppValues.exportJsonTableNames.Remove(tableName);
}
}
if (AppValues.exportJsonTableNames.Count > 0)
{
Utils.Log(string.Format("本次将以下Excel表额外导出为json文件：\n{0}\n", Utils.CombineString(AppValues.exportJsonTableNames, ", ")));
}
// 解析本工具所在目录下的config文件
string configFilePath = Utils.CombinePath(AppValues.PROGRAM_FOLDER_PATH, AppValues.CONFIG_FILE_NAME);
if (File.Exists(configFilePath))
{
string errorString = null;
AppValues.ConfigData = TxtConfigReader.ParseTxtConfigFile(configFilePath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogWarning(string.Format("警告：找不到本工具所在路径下的{0}配置文件，请确定是否真的不需要自定义配置", AppValues.CONFIG_FILE_NAME));
}
// 读取部分配置项并进行检查
const string ERROR_STRING_FORMAT = "配置项\"{0}\"所设置的值\"{1}\"非法：{2}\n";
StringBuilder errorStringBuilder = new StringBuilder();
string tempErrorString = null;
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT))
{
AppValues.DefaultDateInputFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT].Trim();
if (TableCheckHelper.CheckDateInputDefine(AppValues.DefaultDateInputFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT, AppValues.DefaultDateInputFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_LUA_FORMAT))
{
AppValues.DefaultDateToLuaFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_LUA_FORMAT].Trim();
if (TableCheckHelper.CheckDateToLuaDefine(AppValues.DefaultDateToLuaFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_LUA_FORMAT, AppValues.DefaultDateToLuaFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_DATABASE_FORMAT))
{
AppValues.DefaultDateToDatabaseFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_DATABASE_FORMAT].Trim();
if (TableCheckHelper.CheckDateToDatabaseDefine(AppValues.DefaultDateToDatabaseFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_DATABASE_FORMAT, AppValues.DefaultDateToDatabaseFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT))
{
AppValues.DefaultTimeInputFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(AppValues.DefaultTimeInputFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT, AppValues.DefaultTimeInputFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_LUA_FORMAT))
{
AppValues.DefaultTimeToLuaFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_LUA_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(AppValues.DefaultTimeToLuaFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_LUA_FORMAT, AppValues.DefaultTimeToLuaFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_DATABASE_FORMAT))
{
AppValues.DefaultTimeToDatabaseFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_DATABASE_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(AppValues.DefaultTimeToDatabaseFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_DATABASE_FORMAT, AppValues.DefaultTimeToDatabaseFormat, tempErrorString);
}
}
string errorConfigString = errorStringBuilder.ToString();
if (!string.IsNullOrEmpty(errorConfigString))
{
errorConfigString = string.Concat("配置文件中存在以下错误，请修正后重试\n", errorConfigString);
Utils.LogErrorAndExit(errorConfigString);
}
// 读取给定的Excel所在目录下的所有Excel文件，然后解析成本工具所需的数据结构
Utils.Log("开始解析Excel所在目录下的所有Excel文件：");
Stopwatch stopwatch = new Stopwatch();
foreach (string filePath in Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"))
{
string fileName = Path.GetFileNameWithoutExtension(filePath);
if (fileName.StartsWith(AppValues.EXCEL_TEMP_FILE_FILE_NAME_START_STRING))
{
continue;
}
Utils.Log(string.Format("解析表格\"{0}\"：", fileName), ConsoleColor.Green);
stopwatch.Reset();
stopwatch.Start();
string errorString = null;
DataSet ds = XlsxReader.ReadXlsxFile(filePath, out errorString);
stopwatch.Stop();
Utils.Log(string.Format("成功，耗时：{0}毫秒", stopwatch.ElapsedMilliseconds));
if (string.IsNullOrEmpty(errorString))
{
TableInfo tableInfo = TableAnalyzeHelper.AnalyzeTable(ds.Tables[AppValues.EXCEL_DATA_SHEET_NAME], fileName, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：解析{0}失败\n{1}", filePath, errorString));
}
else
{
// 如果有表格配置进行解析
if (ds.Tables[AppValues.EXCEL_CONFIG_SHEET_NAME] != null)
{
tableInfo.TableConfig = TableAnalyzeHelper.GetTableConfig(ds.Tables[AppValues.EXCEL_CONFIG_SHEET_NAME], out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("错误：解析表格{0}的配置失败\n{1}", fileName, errorString));
}
}
AppValues.TableInfo.Add(tableInfo.TableName, tableInfo);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：读取{0}失败\n{1}", filePath, errorString));
}
}
// 进行表格检查
bool isTableAllRight = true;
if (AppValues.IsNeedCheck == true)
{
Utils.Log("\n下面开始进行表格检查：");
foreach (string tableName in AppValues.exportTableNames)
{
TableInfo tableInfo = AppValues.TableInfo[tableName];
string errorString = null;
Utils.Log(string.Format("检查表格\"{0}\"：", tableInfo.TableName), ConsoleColor.Green);
TableCheckHelper.CheckTable(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogError(errorString);
isTableAllRight = false;
}
else
{
Utils.Log("正确");
}
}
}
if (isTableAllRight == true)
{
Utils.Log("\n表格检查完毕，没有发现错误，开始导出为lua文件\n");
// 进行表格导出
foreach (string tableName in AppValues.exportTableNames)
{
TableInfo tableInfo = AppValues.TableInfo[tableName];
string errorString = null;
Utils.Log(string.Format("导出表格\"{0}\"：", tableInfo.TableName), ConsoleColor.Green);
bool isNeedExportOriginalTable = true;
// 判断是否设置了特殊导出规则
if (tableInfo.TableConfig != null && tableInfo.TableConfig.ContainsKey(AppValues.CONFIG_NAME_EXPORT))
{
List <string> inputParams = tableInfo.TableConfig[AppValues.CONFIG_NAME_EXPORT];
if (inputParams.Contains(AppValues.CONFIG_PARAM_NOT_EXPORT_ORIGINAL_TABLE))
{
isNeedExportOriginalTable = false;
if (inputParams.Count == 1)
{
Utils.LogWarning(string.Format("警告：你设置了不对表格\"{0}\"按默认方式进行导出，而又没有指定任何其他自定义导出规则，本工具对此表格不进行任何导出，请确认是否真要如此", tableInfo.TableName));
}
else
{
Utils.Log("你设置了不对此表进行默认规则导出");
}
}
// 执行设置的特殊导出规则
foreach (string param in inputParams)
{
if (!AppValues.CONFIG_PARAM_NOT_EXPORT_ORIGINAL_TABLE.Equals(param, StringComparison.CurrentCultureIgnoreCase))
{
Utils.Log(string.Format("对此表格按\"{0}\"自定义规则进行导出：", param));
TableExportToLuaHelper.SpecialExportTableToLua(tableInfo, param, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("导出失败：\n{0}\n", errorString));
}
else
{
Utils.Log("成功");
}
}
}
}
// 对表格按默认方式导出（除非通过参数设置不执行此操作）
if (isNeedExportOriginalTable == true)
{
TableExportToLuaHelper.ExportTableToLua(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(errorString);
}
else
{
Utils.Log("按默认方式导出成功");
}
}
// 判断是否要额外导出为csv文件
if (AppValues.exportCsvTableNames.Contains(tableName))
{
TableExportToCsvHelper.ExportTableToCsv(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(errorString);
}
else
{
Utils.Log("额外导出为csv文件成功");
}
}
// 判断是否要额外导出为json文件
if (AppValues.exportJsonTableNames.Contains(tableName))
{
TableExportToJsonHelper.ExportTableToJson(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(errorString);
}
else
{
Utils.Log("额外导出为json文件成功");
}
}
}
Utils.Log("\n导出lua文件完毕\n");
// 进行数据库导出
if (AppValues.IsExportMySQL == true)
{
Utils.Log("\n导出表格数据到MySQL数据库\n");
string errorString = null;
TableExportToMySQLHelper.ConnectToDatabase(out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("无法连接至MySQL数据库：{0}\n导出至MySQL数据库被迫中止，请修正错误后重试\n", errorString));
}
foreach (string tableName in AppValues.exportTableNames)
{
TableInfo tableInfo = AppValues.TableInfo[tableName];
TableExportToMySQLHelper.ExportTableToDatabase(tableInfo, out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("导出失败：{0}\n导出至MySQL数据库被迫中止，请修正错误后重试\n", errorString));
}
}
Utils.Log("\n导出到数据库完毕\n");
}
}
else
{
Utils.LogError("\n表格检查完毕，但存在上面所列错误，必须全部修正后才可以进行表格导出\n");
// 将错误信息全部输出保存到txt文件中
Utils.SaveErrorInfoToFile();
}
Utils.Log("\n按任意键退出本工具");
Console.ReadKey();
}
static void Main(string[] args)
{
// 读取本工具所在路径下的config配置文件
string errorString = null;
string configFilePath = Utils.CombinePath(AppValues.PROGRAM_FOLDER_PATH, AppValues.CONFIG_FILE_NAME);
AppValues.ConfigData = TxtConfigReader.ParseTxtConfigFile(configFilePath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
// 检查填写的Excel导出目录是否存在
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_EXPORT_EXCEL_PATH))
{
AppValues.ExportExcelPath = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_EXPORT_EXCEL_PATH].Trim();
if (!Directory.Exists(AppValues.ExportExcelPath))
{
Utils.LogErrorAndExit(string.Format("config配置文件中声明的导出Excel文件的存放目录不存在，你填写的为\"{0}\"", AppValues.ExportExcelPath));
}
}
else
{
Utils.LogErrorAndExit(string.Format("未在config配置文件中以名为\"{0}\"的key声明导出Excel文件的存放目录", AppValues.APP_CONFIG_KEY_EXPORT_EXCEL_PATH));
}
// 获取设置的Excel文件中列的最大宽度
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_EXCEL_COLUMN_MAX_WIDTH))
{
double inputExcelColumnMaxWidth = -1;
string inputParam = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_EXCEL_COLUMN_MAX_WIDTH];
if (double.TryParse(inputParam, out inputExcelColumnMaxWidth) == true)
{
if (inputExcelColumnMaxWidth > 0)
{
AppValues.ExcelColumnMaxWidth = inputExcelColumnMaxWidth;
}
else
{
Utils.LogErrorAndExit(string.Format("config配置文件中声明的Excel文件中列的最大宽度非法，必须大于0，你输入的为\"{0}\"", inputParam));
}
}
else
{
Utils.LogErrorAndExit(string.Format("config配置文件中声明的Excel文件中列的最大宽度不是一个合法数字，你输入的为\"{0}\"", inputParam));
}
}
else
{
Utils.LogWarning(string.Format("警告：未在config配置文件中以名为\"{0}\"的key声明生成的Excel文件中列的最大宽度，本工具将不对生成的Excel文件进行美化", AppValues.APP_CONFIG_KEY_EXCEL_COLUMN_MAX_WIDTH));
}
const int COLOR_INDEX_MIN = 0;
const int COLOR_INDEX_MAX = 56;
// 获取设置的每列背景色，如果进行了设置需检查ColorIndex是否正确
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_COLUMN_BACKGROUND_COLOR))
{
AppValues.ColumnBackgroundColorIndex = new List <int>();
string inputParam = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_COLUMN_BACKGROUND_COLOR];
string[] colorIndexString = inputParam.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (colorIndexString.Length > 0)
{
foreach (string oneColorIndexString in colorIndexString)
{
int oneColorIndex = -1;
if (int.TryParse(oneColorIndexString, out oneColorIndex) == true)
{
if (oneColorIndex >= COLOR_INDEX_MIN && oneColorIndex <= COLOR_INDEX_MAX)
{
AppValues.ColumnBackgroundColorIndex.Add(oneColorIndex);
}
else
{
Utils.LogErrorAndExit(string.Format("config配置文件中声明的颜色索引值\"{0}\"非法，必须介于{1}到{2}之间", oneColorIndex, COLOR_INDEX_MIN, COLOR_INDEX_MAX));
}
}
else
{
Utils.LogErrorAndExit(string.Format("config配置文件中声明的颜色索引值\"{0}\"不是一个合法数字", oneColorIndexString));
}
}
}
else
{
Utils.LogErrorAndExit(string.Format("config配置文件中以名为\"{0}\"的key声明各列背景色不允许为空", AppValues.APP_CONFIG_KEY_COLUMN_BACKGROUND_COLOR));
}
}
// 获取设置的data、config两张Sheet表的标签按钮颜色
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DATA_SHEET_TAB_COLOR))
{
string colorIndexString = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DATA_SHEET_TAB_COLOR];
int colorIndex = -1;
if (int.TryParse(colorIndexString, out colorIndex) == true)
{
if (colorIndex >= COLOR_INDEX_MIN && colorIndex <= COLOR_INDEX_MAX)
{
AppValues.DataSheetTabColorIndex = colorIndex;
}
else
{
Utils.LogErrorAndExit(string.Format("config配置文件中声明的data表标签按钮颜色索引值\"{0}\"非法，必须介于{1}到{2}之间", colorIndex, COLOR_INDEX_MIN, COLOR_INDEX_MAX));
}
}
else
{
Utils.LogErrorAndExit(string.Format("config配置文件中声明的data表标签按钮颜色索引值\"{0}\"不是一个合法数字", colorIndexString));
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_CONFIG_SHEET_TAB_COLOR))
{
string colorIndexString = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_CONFIG_SHEET_TAB_COLOR];
int colorIndex = -1;
if (int.TryParse(colorIndexString, out colorIndex) == true)
{
if (colorIndex >= COLOR_INDEX_MIN && colorIndex <= COLOR_INDEX_MAX)
{
AppValues.ConfigSheetTabColorIndex = colorIndex;
}
else
{
Utils.LogErrorAndExit(string.Format("config配置文件中声明的config表标签按钮颜色索引值\"{0}\"非法，必须介于{1}到{2}之间", colorIndex, COLOR_INDEX_MIN, COLOR_INDEX_MAX));
}
}
else
{
Utils.LogErrorAndExit(string.Format("config配置文件中声明的config表标签按钮颜色索引值\"{0}\"不是一个合法数字", colorIndexString));
}
}
// 获取要导出的数据表名
List <string> exportTableName = new List <string>();
// 在这里自定义获取要导出的数据表名的方法（这里以在config.txt中进行配置为例，还可以采用类似表名特殊前缀标识等方式实现）
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_EXPORT_DATA_TABLE_NAMES))
{
string exportTableNameString = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_EXPORT_DATA_TABLE_NAMES].Trim();
if (string.IsNullOrEmpty(exportTableNameString))
{
Utils.LogErrorAndExit(string.Format("config配置文件中以名为\"{0}\"的key声明要导出的数据表名不允许为空", AppValues.APP_CONFIG_KEY_EXPORT_DATA_TABLE_NAMES));
}
else
{
string[] tableNames = exportTableNameString.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string tableName in tableNames)
{
exportTableName.Add(tableName.Trim());
}
}
}
else
{
Utils.LogErrorAndExit(string.Format("未在config配置文件中以名为\"{0}\"的key声明要导出的数据表名", AppValues.APP_CONFIG_KEY_EXPORT_DATA_TABLE_NAMES));
}
// 连接MySQL数据库
MySQLOperateHelper.ConnectToDatabase(out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("无法连接到MySQL数据库，{0}", errorString));
}
// 检查声明的要导出的数据库表格是否存在，若存在导出到Excel
foreach (string tableName in exportTableName)
{
if (MySQLOperateHelper.ExistTableNames.Contains(tableName))
{
Utils.Log(string.Format("导出数据表{0}：", tableName));
ExcelOperateHelper.ExportToExcel(tableName);
Utils.Log("成功");
}
else
{
Utils.LogErrorAndExit(string.Format("\n错误：数据库中不存在名为{0}的数据表，请检查配置中声明的导出数据表名与数据库是否对应", tableName));
}
}
Utils.Log("\n按任意键退出本工具");
Console.ReadKey();
}
/// <summary>
/// 传入参数中，第1个必须为Excel表格所在目录，第2个必须为存放导出lua文件的目录，第3个参数为项目Client目录的路径（无需文件存在型检查规则则填-noClient），第4个参数为必须为lang文件路径（没有填-noLang）
/// 可附加参数为：-columnInfo（在生成lua文件的最上方用注释形式显示列信息，默认不开启），-unchecked（不对表格进行查错，不推荐使用），-printEmptyStringWhenLangNotMatching（当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串即xx = ""，默认为输出nil）
/// </summary>
static void Main(string[] args)
{
// 检查第1个参数（Excel表格所在目录）是否正确
if (args.Length < 1)
{
Utils.LogErrorAndExit("错误：未输入Excel表格所在目录");
}
if (!Directory.Exists(args[0]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的Excel表格所在目录不存在，路径为{0}", args[0]));
}
AppValues.ExcelFolderPath = Path.GetFullPath(args[0]);
Utils.Log(string.Format("选择的Excel所在路径：{0}", AppValues.ExcelFolderPath));
// 检查第2个参数（存放导出lua文件的目录）是否正确
if (args.Length < 2)
{
Utils.LogErrorAndExit("错误：未输入要将生成lua文件存放的路径");
}
if (!Directory.Exists(args[1]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的lua文件导出路径不存在，路径为{0}", args[1]));
}
AppValues.ExportLuaFilePath = Path.GetFullPath(args[1]);
Utils.Log(string.Format("选择的lua文件导出路径：{0}", AppValues.ExportLuaFilePath));
// 检查第3个参数（项目Client目录的路径）是否正确
if (args.Length < 3)
{
Utils.LogErrorAndExit("错误：未输入项目Client目录的路径，如果不需要请输入参数-noClient");
}
if (AppValues.NO_CLIENT_PATH_STRING.Equals(args[2], StringComparison.CurrentCultureIgnoreCase))
{
Utils.LogWarning("警告：你选择了不指定Client文件夹路径，则本工具无法检查表格中填写的图片路径等对应的文件是否存在");
AppValues.ClientPath = null;
}
else if (Directory.Exists(args[2]))
{
AppValues.ClientPath = Path.GetFullPath(args[2]);
Utils.Log(string.Format("Client目录完整路径：{0}", AppValues.ClientPath));
}
else
{
Utils.LogErrorAndExit(string.Format("错误：请检查输入的Client路径是否正确{0}", args[2]));
}
// 检查第4个参数（lang文件路径）是否正确
if (args.Length < 4)
{
Utils.LogErrorAndExit("错误：未输入lang文件路径或未声明不含lang文件（使用-noLang）");
}
if (AppValues.NO_LONG_PARAM_STRING.Equals(args[3], StringComparison.CurrentCultureIgnoreCase))
{
AppValues.LangFilePath = null;
Utils.Log("选择的lang文件路径：无");
}
else if (File.Exists(args[3]))
{
AppValues.LangFilePath = Path.GetFullPath(args[3]);
Utils.Log(string.Format("选择的lang文件路径：{0}", AppValues.LangFilePath));
// 解析lang文件
string errorString = null;
AppValues.LangData = TxtConfigReader.ParseTxtConfigFile(AppValues.LangFilePath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：输入的lang文件不存在，路径为{0}", args[3]));
}
// 检查其他参数
for (int i = 4; i < args.Length; ++i)
{
string param = args[i];
switch (param)
{
case AppValues.UNCHECKED_PARAM_STRING:
{
AppValues.IsNeedCheck = false;
Utils.LogWarning("警告：你选择了不进行表格检查，请务必自己保证表格的正确性");
break;
}
case AppValues.NEED_COLUMN_INFO_PARAM_STRING:
{
AppValues.IsNeedColumnInfo = true;
Utils.LogWarning("你选择了在生成的lua文件最上方用注释形式显示列信息");
break;
}
case AppValues.LANG_NOT_MATCHING_PRINT_PARAM_STRING:
{
AppValues.IsPrintEmptyStringWhenLangNotMatching = true;
Utils.LogWarning("你选择了当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串");
break;
}
default:
{
Utils.LogErrorAndExit(string.Format("错误：未知的指令参数{0}", param));
break;
}
}
}
// 解析本工具所在目录下的config文件
if (File.Exists(AppValues.CONFIG_FILE_NAME))
{
string errorString = null;
AppValues.ConfigData = TxtConfigReader.ParseTxtConfigFile(AppValues.CONFIG_FILE_NAME, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogWarning(string.Format("警告：找不到本工具所在路径下的{0}配置文件，请确定是否真的不需要自定义配置", AppValues.CONFIG_FILE_NAME));
}
// 读取给定的Excel所在目录下的所有Excel文件，然后解析成本工具所需的数据结构
foreach (var filePath in Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"))
{
string errorString = null;
DataSet ds = XlsxReader.ReadXlsxFile(filePath, out errorString);
if (string.IsNullOrEmpty(errorString))
{
string fileName = Path.GetFileNameWithoutExtension(filePath);
TableInfo tableInfo = TableAnalyzeHelper.AnalyzeTable(ds.Tables[AppValues.EXCEL_SHEET_NAME], fileName, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：解析{0}失败\n{1}", filePath, errorString));
}
else
{
// 如果有表格配置进行解析
if (ds.Tables[AppValues.EXCEL_CONFIG_NAME] != null)
{
tableInfo.TableConfig = TableAnalyzeHelper.GetTableConfig(ds.Tables[AppValues.EXCEL_CONFIG_NAME], out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("错误：解析表格{0}的配置失败\n{1}", fileName, errorString));
}
}
AppValues.TableInfo.Add(tableInfo.TableName, tableInfo);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：读取{0}失败\n{1}", filePath, errorString));
}
}
// 进行表格检查
bool isTableAllRight = true;
if (AppValues.IsNeedCheck == true)
{
Utils.Log("\n下面开始进行表格检查：");
foreach (TableInfo tableInfo in AppValues.TableInfo.Values)
{
string errorString = null;
Utils.Log(string.Format("检查表格\"{0}\"：", tableInfo.TableName));
TableCheckHelper.CheckTable(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogError(errorString);
isTableAllRight = false;
}
else
{
Utils.Log("正确");
}
}
}
if (isTableAllRight == true)
{
Utils.Log("\n表格检查完毕，没有发现错误，开始导出为lua文件\n");
// 进行表格导出
foreach (TableInfo tableInfo in AppValues.TableInfo.Values)
{
string errorString = null;
Utils.Log(string.Format("导出表格\"{0}\"：", tableInfo.TableName));
bool isNeedExportOriginalTable = true;
// 判断是否设置了特殊导出规则
if (tableInfo.TableConfig != null && tableInfo.TableConfig.ContainsKey(AppValues.CONFIG_NAME_EXPORT))
{
List <string> inputParams = tableInfo.TableConfig[AppValues.CONFIG_NAME_EXPORT];
if (inputParams.Contains(AppValues.CONFIG_PARAM_NOT_EXPORT_ORIGINAL_TABLE))
{
isNeedExportOriginalTable = false;
if (inputParams.Count == 1)
{
Utils.LogWarning(string.Format("警告：你设置了不对表格\"{0}\"按默认方式进行导出，而又没有指定任何其他自定义导出规则，本工具对此表格不进行任何导出，请确认是否真要如此", tableInfo.TableName));
}
else
{
Utils.Log("你设置了不对此表进行默认规则导出");
}
}
// 执行设置的特殊导出规则
foreach (string param in inputParams)
{
if (!AppValues.CONFIG_PARAM_NOT_EXPORT_ORIGINAL_TABLE.Equals(param, StringComparison.CurrentCultureIgnoreCase))
{
Utils.Log(string.Format("对此表格按\"{0}\"自定义规则进行导出：", param));
TableExportToLuaHelper.SpecialExportTableToLua(tableInfo, param, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit("导出失败：" + errorString);
}
else
{
Utils.Log("成功");
}
}
}
}
// 对表格按默认方式导出（除非通过参数设置不执行此操作）
if (isNeedExportOriginalTable == true)
{
TableExportToLuaHelper.ExportTableToLua(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(errorString);
}
else
{
Utils.Log("按默认方式导出成功");
}
}
}
Utils.Log("\n导出lua文件完毕\n");
}
else
{
Utils.LogError("\n表格检查完毕，但存在上面所列错误，必须全部修正后才可以进行表格导出\n");
// 将错误信息全部输出保存到txt文件中
Utils.SaveErrorInfoToFile();
}
Utils.Log("\n按任意键退出本工具");
Console.ReadKey();
}
private void btnLoadConfig_Click(object sender, EventArgs e)
{
OpenFileDialog dialog = new OpenFileDialog();
dialog.Title = "请选择配置文件所在路径";
dialog.InitialDirectory = AppValues.PROGRAM_FOLDER_PATH;
dialog.Multiselect = false;
dialog.Filter = "Config files (*.txt)|*.txt";
if (dialog.ShowDialog() == DialogResult.OK)
{
string errorString = null;
Dictionary <string, string> config = TxtConfigReader.ParseTxtConfigFile(dialog.FileName, AppValues.SAVE_CONFIG_KEY_VALUE_SEPARATOR, out errorString);
if (!string.IsNullOrEmpty(errorString))
{
MessageBox.Show(string.Format("打开配置文件失败：\n{0}", errorString), "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (config.ContainsKey(AppValues.SAVE_CONFIG_KEY_PROGRAM_PATH))
{
tbProgramPath.Text = config[AppValues.SAVE_CONFIG_KEY_PROGRAM_PATH];
}
if (config.ContainsKey(AppValues.SAVE_CONFIG_KEY_EXCEL_FOLDER_PATH))
{
tbExcelFolderPath.Text = config[AppValues.SAVE_CONFIG_KEY_EXCEL_FOLDER_PATH];
}
if (config.ContainsKey(AppValues.SAVE_CONFIG_KEY_EXPORT_LUA_FOLDER_PATH))
{
tbExportLuaFolderPath.Text = config[AppValues.SAVE_CONFIG_KEY_EXPORT_LUA_FOLDER_PATH];
}
if (config.ContainsKey(AppValues.SAVE_CONFIG_KEY_CLIENT_FOLDER_PATH))
{
tbClientFolderPath.Text = config[AppValues.SAVE_CONFIG_KEY_CLIENT_FOLDER_PATH];
}
if (config.ContainsKey(AppValues.SAVE_CONFIG_KEY_LANG_FILE_PATH))
{
tbLangFilePath.Text = config[AppValues.SAVE_CONFIG_KEY_LANG_FILE_PATH];
}
if (config.ContainsKey(AppValues.NEED_COLUMN_INFO_PARAM_STRING))
{
cbColumnInfo.CheckState = CheckState.Checked;
}
if (config.ContainsKey(AppValues.UNCHECKED_PARAM_STRING))
{
cbUnchecked.CheckState = CheckState.Checked;
}
if (config.ContainsKey(AppValues.LANG_NOT_MATCHING_PRINT_PARAM_STRING))
{
cbPrintEmptyStringWhenLangNotMatching.CheckState = CheckState.Checked;
}
if (config.ContainsKey(AppValues.EXPORT_MYSQL_PARAM_STRING))
{
cbExportMySQL.CheckState = CheckState.Checked;
}
if (config.ContainsKey(AppValues.ALLOWED_NULL_NUMBER_PARAM_STRING))
{
cbAllowedNullNumber.CheckState = CheckState.Checked;
}
if (config.ContainsKey(AppValues.PART_EXPORT_PARAM_STRING))
{
cbPart.CheckState = CheckState.Checked;
tbPartExcelNames.Text = config[AppValues.PART_EXPORT_PARAM_STRING];
}
MessageBox.Show("载入配置文件成功", "恭喜", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
/// <summary>
/// 传入参数中，第1个必须为Excel表格所在目录，第2个必须为存放导出lua文件的目录，第3个参数为项目Client目录的路径（无需文件存在型检查规则则填-noClient），第4个参数为必须为lang文件路径（没有填-noLang）
/// 可附加参数有：
/// 1) -columnInfo（在生成lua文件的最上方用注释形式显示列信息，默认不开启）
/// 2) -unchecked（不对表格进行查错，不推荐使用）
/// 3) -printEmptyStringWhenLangNotMatching（当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串即xx = ""，默认为输出nil）
/// 4) -exportMySQL（将表格数据导出到MySQL数据库中，默认不导出）
/// 5) -part（后面在英文小括号内声明本次要导出的Excel文件名，用|分隔，未声明的文件将被本工具忽略）
/// </summary>
static void Main(string[] args)
{
// 检查第1个参数（Excel表格所在目录）是否正确
if (args.Length < 1)
{
Utils.LogErrorAndExit("错误：未输入Excel表格所在目录");
}
if (!Directory.Exists(args[0]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的Excel表格所在目录不存在，路径为{0}", args[0]));
}
AppValues.ExcelFolderPath = Path.GetFullPath(args[0]);
Utils.Log(string.Format("选择的Excel所在路径：{0}", AppValues.ExcelFolderPath));
// 检查第2个参数（存放导出lua文件的目录）是否正确
if (args.Length < 2)
{
Utils.LogErrorAndExit("错误：未输入要将生成lua文件存放的路径");
}
if (!Directory.Exists(args[1]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的lua文件导出路径不存在，路径为{0}", args[1]));
}
AppValues.ExportLuaFilePath = Path.GetFullPath(args[1]);
Utils.Log(string.Format("选择的lua文件导出路径：{0}", AppValues.ExportLuaFilePath));
// 检查第3个参数（项目Client目录的路径）是否正确
if (args.Length < 3)
{
Utils.LogErrorAndExit("错误：未输入项目Client目录的路径，如果不需要请输入参数-noClient");
}
if (AppValues.NO_CLIENT_PATH_STRING.Equals(args[2], StringComparison.CurrentCultureIgnoreCase))
{
Utils.LogWarning("警告：你选择了不指定Client文件夹路径，则本工具无法检查表格中填写的图片路径等对应的文件是否存在");
AppValues.ClientPath = null;
}
else if (Directory.Exists(args[2]))
{
AppValues.ClientPath = Path.GetFullPath(args[2]);
Utils.Log(string.Format("Client目录完整路径：{0}", AppValues.ClientPath));
}
else
{
Utils.LogErrorAndExit(string.Format("错误：请检查输入的Client路径是否正确{0}", args[2]));
}
// 检查第4个参数（lang文件路径）是否正确
if (args.Length < 4)
{
Utils.LogErrorAndExit("错误：未输入lang文件路径或未声明不含lang文件（使用-noLang）");
}
if (AppValues.NO_LANG_PARAM_STRING.Equals(args[3], StringComparison.CurrentCultureIgnoreCase))
{
AppValues.LangFilePath = null;
Utils.Log("选择的lang文件路径：无");
}
else if (File.Exists(args[3]))
{
AppValues.LangFilePath = Path.GetFullPath(args[3]);
Utils.Log(string.Format("选择的lang文件路径：{0}", AppValues.LangFilePath));
// 解析lang文件
string errorString = null;
AppValues.LangData = TxtConfigReader.ParseTxtConfigFile(AppValues.LangFilePath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：输入的lang文件不存在，路径为{0}", args[3]));
}
// 检查其他参数
for (int i = 4; i < args.Length; ++i)
{
string param = args[i];
if (param.Equals(AppValues.UNCHECKED_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsNeedCheck = false;
Utils.LogWarning("警告：你选择了不进行表格检查，请务必自己保证表格的正确性");
}
else if (param.Equals(AppValues.NEED_COLUMN_INFO_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsNeedColumnInfo = true;
Utils.LogWarning("你选择了在生成的lua文件最上方用注释形式显示列信息");
}
else if (param.Equals(AppValues.LANG_NOT_MATCHING_PRINT_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsPrintEmptyStringWhenLangNotMatching = true;
Utils.LogWarning("你选择了当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串");
}
else if (param.Equals(AppValues.EXPORT_MYSQL_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsExportMySQL = true;
Utils.LogWarning("你选择了导出表格数据到MySQL数据库");
}
else if (param.StartsWith(AppValues.PART_EXPORT_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
// 解析声明的本次要导出的Excel名
int leftBracketIndex = param.IndexOf('(');
int rightBracketIndex = param.LastIndexOf(')');
if (leftBracketIndex == -1 || rightBracketIndex == -1 || leftBracketIndex > rightBracketIndex)
{
Utils.LogErrorAndExit(string.Format("错误：声明导出部分Excel表格的参数{0}后必须在英文小括号内声明Excel文件名", AppValues.PART_EXPORT_PARAM_STRING));
}
else
{
string fileNameString = param.Substring(leftBracketIndex + 1, rightBracketIndex - leftBracketIndex - 1).Trim();
string[] fileNames = fileNameString.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
if (fileNames.Length < 1)
{
Utils.LogErrorAndExit(string.Format("错误：声明导出部分Excel表格的参数{0}后必须在英文小括号内声明至少一个Excel文件名", AppValues.PART_EXPORT_PARAM_STRING));
}
foreach (string fileName in fileNames)
{
AppValues.exportTableNames.Add(fileName.Trim());
}
// 检查指定导出的Excel文件是否存在（注意不能直接用File.Exists判断是否存在，因为Windows会忽略声明的Excel文件名与实际文件名的大小写差异）
List <string> existExcelFilePaths = new List <string>(Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"));
List <string> existExcelFileNames = new List <string>();
foreach (string filePath in existExcelFilePaths)
{
existExcelFileNames.Add(Path.GetFileNameWithoutExtension(filePath));
}
foreach (string exportExcelFileName in AppValues.exportTableNames)
{
if (!existExcelFileNames.Contains(exportExcelFileName))
{
Utils.LogErrorAndExit(string.Format("要求导出的Excel文件（{0}）不存在，请检查后重试并注意区分大小写", Utils.CombinePath(AppValues.ExcelFolderPath, string.Concat(exportExcelFileName, ".xlsx"))));
}
}
Utils.LogWarning(string.Format("警告：本次将仅检查并导出以下Excel文件：\n{0}\n", Utils.CombineString(AppValues.exportTableNames, ", ")));
}
}
else if (param.StartsWith(AppValues.ALLOWED_NULL_NUMBER_PARAM_STRING, StringComparison.CurrentCultureIgnoreCase))
{
AppValues.IsAllowedNullNumber = true;
Utils.LogWarning("警告：你选择了允许int、long、float字段中存在空值，建议为逻辑上不允许为空的数值型字段声明使用notEmpty检查规则");
}
else
{
Utils.LogErrorAndExit(string.Format("错误：未知的指令参数{0}", param));
}
}
// 如果未指定导出部分Excel文件，则全部导出
if (AppValues.exportTableNames.Count == 0)
{
foreach (string filePath in Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"))
{
AppValues.exportTableNames.Add(Path.GetFileNameWithoutExtension(filePath));
}
}
// 解析本工具所在目录下的config文件
string configFilePath = Utils.CombinePath(AppValues.PROGRAM_FOLDER_PATH, AppValues.CONFIG_FILE_NAME);
if (File.Exists(configFilePath))
{
string errorString = null;
AppValues.ConfigData = TxtConfigReader.ParseTxtConfigFile(configFilePath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogWarning(string.Format("警告：找不到本工具所在路径下的{0}配置文件，请确定是否真的不需要自定义配置", AppValues.CONFIG_FILE_NAME));
}
// 读取部分配置项并进行检查
const string ERROR_STRING_FORMAT = "配置项\"{0}\"所设置的值\"{1}\"非法：{2}\n";
StringBuilder errorStringBuilder = new StringBuilder();
string tempErrorString = null;
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT))
{
AppValues.DefaultDateInputFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT].Trim();
if (TableCheckHelper.CheckDateInputDefine(AppValues.DefaultDateInputFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_DATE_INPUT_FORMAT, AppValues.DefaultDateInputFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_LUA_FORMAT))
{
AppValues.DefaultDateToLuaFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_LUA_FORMAT].Trim();
if (TableCheckHelper.CheckDateToLuaDefine(AppValues.DefaultDateToLuaFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_LUA_FORMAT, AppValues.DefaultDateToLuaFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_DATABASE_FORMAT))
{
AppValues.DefaultDateToDatabaseFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_DATABASE_FORMAT].Trim();
if (TableCheckHelper.CheckDateToDatabaseDefine(AppValues.DefaultDateToDatabaseFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_DATE_TO_DATABASE_FORMAT, AppValues.DefaultDateToDatabaseFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT))
{
AppValues.DefaultTimeInputFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(AppValues.DefaultTimeInputFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_TIME_INPUT_FORMAT, AppValues.DefaultTimeInputFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_LUA_FORMAT))
{
AppValues.DefaultTimeToLuaFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_LUA_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(AppValues.DefaultTimeToLuaFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_LUA_FORMAT, AppValues.DefaultTimeToLuaFormat, tempErrorString);
}
}
if (AppValues.ConfigData.ContainsKey(AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_DATABASE_FORMAT))
{
AppValues.DefaultTimeToDatabaseFormat = AppValues.ConfigData[AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_DATABASE_FORMAT].Trim();
if (TableCheckHelper.CheckTimeDefine(AppValues.DefaultTimeToDatabaseFormat, out tempErrorString) == false)
{
errorStringBuilder.AppendFormat(ERROR_STRING_FORMAT, AppValues.APP_CONFIG_KEY_DEFAULT_TIME_TO_DATABASE_FORMAT, AppValues.DefaultTimeToDatabaseFormat, tempErrorString);
}
}
// 读取给定的Excel所在目录下的所有Excel文件，然后解析成本工具所需的数据结构
foreach (string filePath in Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"))
{
string errorString = null;
DataSet ds = XlsxReader.ReadXlsxFile(filePath, out errorString);
if (string.IsNullOrEmpty(errorString))
{
string fileName = Path.GetFileNameWithoutExtension(filePath);
TableInfo tableInfo = TableAnalyzeHelper.AnalyzeTable(ds.Tables[AppValues.EXCEL_DATA_SHEET_NAME], fileName, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：解析{0}失败\n{1}", filePath, errorString));
}
else
{
// 如果有表格配置进行解析
if (ds.Tables[AppValues.EXCEL_CONFIG_SHEET_NAME] != null)
{
tableInfo.TableConfig = TableAnalyzeHelper.GetTableConfig(ds.Tables[AppValues.EXCEL_CONFIG_SHEET_NAME], out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("错误：解析表格{0}的配置失败\n{1}", fileName, errorString));
}
}
AppValues.TableInfo.Add(tableInfo.TableName, tableInfo);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：读取{0}失败\n{1}", filePath, errorString));
}
}
// 进行表格检查
bool isTableAllRight = true;
if (AppValues.IsNeedCheck == true)
{
Utils.Log("\n下面开始进行表格检查：");
foreach (string tableName in AppValues.exportTableNames)
{
TableInfo tableInfo = AppValues.TableInfo[tableName];
string errorString = null;
Utils.Log(string.Format("检查表格\"{0}\"：", tableInfo.TableName));
TableCheckHelper.CheckTable(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogError(errorString);
isTableAllRight = false;
}
else
{
Utils.Log("正确");
}
}
}
if (isTableAllRight == true)
{
Utils.Log("\n表格检查完毕，没有发现错误，开始导出为lua文件\n");
// 进行表格导出
foreach (string tableName in AppValues.exportTableNames)
{
TableInfo tableInfo = AppValues.TableInfo[tableName];
string errorString = null;
Utils.Log(string.Format("导出表格\"{0}\"：", tableInfo.TableName));
bool isNeedExportOriginalTable = true;
// 判断是否设置了特殊导出规则
if (tableInfo.TableConfig != null && tableInfo.TableConfig.ContainsKey(AppValues.CONFIG_NAME_EXPORT))
{
List <string> inputParams = tableInfo.TableConfig[AppValues.CONFIG_NAME_EXPORT];
if (inputParams.Contains(AppValues.CONFIG_PARAM_NOT_EXPORT_ORIGINAL_TABLE))
{
isNeedExportOriginalTable = false;
if (inputParams.Count == 1)
{
Utils.LogWarning(string.Format("警告：你设置了不对表格\"{0}\"按默认方式进行导出，而又没有指定任何其他自定义导出规则，本工具对此表格不进行任何导出，请确认是否真要如此", tableInfo.TableName));
}
else
{
Utils.Log("你设置了不对此表进行默认规则导出");
}
}
// 执行设置的特殊导出规则
foreach (string param in inputParams)
{
if (!AppValues.CONFIG_PARAM_NOT_EXPORT_ORIGINAL_TABLE.Equals(param, StringComparison.CurrentCultureIgnoreCase))
{
Utils.Log(string.Format("对此表格按\"{0}\"自定义规则进行导出：", param));
TableExportToLuaHelper.SpecialExportTableToLua(tableInfo, param, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("导出失败：\n{0}\n", errorString));
}
else
{
Utils.Log("成功");
}
}
}
}
// 对表格按默认方式导出（除非通过参数设置不执行此操作）
if (isNeedExportOriginalTable == true)
{
TableExportToLuaHelper.ExportTableToLua(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(errorString);
}
else
{
Utils.Log("按默认方式导出成功");
}
}
}
Utils.Log("\n导出lua文件完毕\n");
// 进行数据库导出
if (AppValues.IsExportMySQL == true)
{
Utils.Log("\n导出表格数据到MySQL数据库\n");
string errorString = null;
TableExportToMySQLHelper.ConnectToDatabase(out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("无法连接至MySQL数据库：{0}\n导出至MySQL数据库被迫中止，请修正错误后重试\n", errorString));
}
foreach (string tableName in AppValues.exportTableNames)
{
TableInfo tableInfo = AppValues.TableInfo[tableName];
TableExportToMySQLHelper.ExportTableToDatabase(tableInfo, out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(string.Format("导出失败：{0}\n导出至MySQL数据库被迫中止，请修正错误后重试\n", errorString));
}
}
Utils.Log("\n导出到数据库完毕\n");
}
}
else
{
Utils.LogError("\n表格检查完毕，但存在上面所列错误，必须全部修正后才可以进行表格导出\n");
// 将错误信息全部输出保存到txt文件中
Utils.SaveErrorInfoToFile();
}
Utils.Log("\n按任意键退出本工具");
Console.ReadKey();
}
/// <summary>
/// 传入参数中，第1个必须为Excel表格所在目录，第2个必须为存放导出lua文件的目录，第3个参数为项目Client目录的路径（无需文件存在型检查规则则填-noClient），第4个参数为必须为lang文件路径（没有填-noLang）
/// 可附加参数为：-columnInfo（在生成lua文件的最上方用注释形式显示列信息，默认不开启），-unchecked（不对表格进行查错，不推荐使用），-printEmptyStringWhenLangNotMatching（当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串即xx = ""，默认为输出nil）
/// </summary>
static void Main(string[] args)
{
// 检查第1个参数（Excel表格所在目录）是否正确
if (args.Length < 1)
{
Utils.LogErrorAndExit("错误：未输入Excel表格所在目录");
}
if (!Directory.Exists(args[0]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的Excel表格所在目录不存在，路径为{0}", args[0]));
}
AppValues.ExcelFolderPath = Path.GetFullPath(args[0]);
Utils.Log(string.Format("选择的Excel所在路径：{0}", AppValues.ExcelFolderPath));
// 检查第2个参数（存放导出lua文件的目录）是否正确
if (args.Length < 2)
{
Utils.LogErrorAndExit("错误：未输入要将生成lua文件存放的路径");
}
if (!Directory.Exists(args[1]))
{
Utils.LogErrorAndExit(string.Format("错误：输入的lua文件导出路径不存在，路径为{0}", args[1]));
}
AppValues.ExportLuaFilePath = Path.GetFullPath(args[1]);
Utils.Log(string.Format("选择的lua文件导出路径：{0}", AppValues.ExportLuaFilePath));
// 检查第3个参数（项目Client目录的路径）是否正确
if (args.Length < 3)
{
Utils.LogErrorAndExit("错误：未输入项目Client目录的路径，如果不需要请输入参数-noClient");
}
if (AppValues.NO_CLIENT_PATH_STRING.Equals(args[2], StringComparison.CurrentCultureIgnoreCase))
{
Utils.LogWarning("警告：你选择了不指定Client文件夹路径，则本工具无法检查表格中填写的图片路径等对应的文件是否存在");
AppValues.ClientPath = null;
}
else if (Directory.Exists(args[2]))
{
AppValues.ClientPath = Path.GetFullPath(args[2]);
Utils.Log(string.Format("Client目录完整路径：{0}", AppValues.ClientPath));
}
else
{
Utils.LogErrorAndExit(string.Format("错误：请检查输入的Client路径是否正确{0}", args[2]));
}
// 检查第4个参数（lang文件路径）是否正确
if (args.Length < 4)
{
Utils.LogErrorAndExit("错误：未输入lang文件路径或未声明不含lang文件（使用-noLang）");
}
if (AppValues.NO_LONG_PARAM_STRING.Equals(args[3], StringComparison.CurrentCultureIgnoreCase))
{
AppValues.LangFilePath = null;
Utils.Log("选择的lang文件路径：无");
}
else if (File.Exists(args[3]))
{
AppValues.LangFilePath = Path.GetFullPath(args[3]);
Utils.Log(string.Format("选择的lang文件路径：{0}", AppValues.LangFilePath));
// 解析lang文件
string errorString = null;
AppValues.LangData = TxtConfigReader.ParseTxtConfigFile(AppValues.LangFilePath, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：输入的lang文件不存在，路径为{0}", args[3]));
}
// 检查其他参数
for (int i = 4; i < args.Length; ++i)
{
string param = args[i];
switch (param)
{
case AppValues.UNCHECKED_PARAM_STRING:
{
AppValues.IsNeedCheck = false;
Utils.LogWarning("警告：你选择了不进行表格检查，请务必自己保证表格的正确性");
break;
}
case AppValues.NEED_COLUMN_INFO_PARAM_STRING:
{
AppValues.IsNeedColumnInfo = true;
Utils.LogWarning("你选择了在生成的lua文件最上方用注释形式显示列信息");
break;
}
case AppValues.LANG_NOT_MATCHING_PRINT_PARAM_STRING:
{
AppValues.IsPrintEmptyStringWhenLangNotMatching = true;
Utils.LogWarning("你选择了当lang型数据key在lang文件中找不到对应值时，在lua文件输出字段值为空字符串");
break;
}
default:
{
Utils.LogErrorAndExit(string.Format("错误：未知的指令参数{0}", param));
break;
}
}
}
// 解析本工具所在目录下的config文件
if (File.Exists(AppValues.CONFIG_FILE_NAME))
{
string errorString = null;
AppValues.ConfigData = TxtConfigReader.ParseTxtConfigFile(AppValues.CONFIG_FILE_NAME, ":", out errorString);
if (!string.IsNullOrEmpty(errorString))
{
Utils.LogErrorAndExit(errorString);
}
}
else
{
Utils.LogWarning(string.Format("警告：找不到本工具所在路径下的{0}配置文件，请确定是否真的不需要自定义配置", AppValues.CONFIG_FILE_NAME));
}
// 读取给定的Excel所在目录下的所有Excel文件，然后解析成本程序所需的数据结构
foreach (var filePath in Directory.GetFiles(AppValues.ExcelFolderPath, "*.xlsx"))
{
string errorString = null;
DataTable dt = XlsxReader.ReadXlsxFile(filePath, out errorString);
if (string.IsNullOrEmpty(errorString))
{
string fileName = Path.GetFileNameWithoutExtension(filePath);
TableInfo tableInfo = TableAnalyzeHelper.AnalyzeTable(dt, fileName, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(string.Format("错误：解析{0}失败\n{1}", filePath, errorString));
}
else
{
AppValues.TableInfo.Add(tableInfo.TableName, tableInfo);
}
}
else
{
Utils.LogErrorAndExit(string.Format("错误：读取{0}失败\n{1}", filePath, errorString));
}
}
// 进行表格检查
bool isTableAllRight = true;
if (AppValues.IsNeedCheck == true)
{
Utils.Log("\n下面开始进行表格检查：");
foreach (TableInfo tableInfo in AppValues.TableInfo.Values)
{
string errorString = null;
Utils.Log(string.Format("检查表格\"{0}\"：", tableInfo.TableName));
TableCheckHelper.CheckTable(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogError(errorString);
isTableAllRight = false;
}
else
{
Utils.Log("正确");
}
}
}
if (isTableAllRight == true)
{
Utils.Log("\n表格检查完毕，没有发现错误，开始导出为lua文件\n");
// 进行表格导出
foreach (TableInfo tableInfo in AppValues.TableInfo.Values)
{
string errorString = null;
TableExportToLuaHelper.ExportTableToLua(tableInfo, out errorString);
if (errorString != null)
{
Utils.LogErrorAndExit(errorString);
}
}
Utils.Log("\n导出lua文件完毕\n");
}
else
{
Utils.LogError("\n表格检查完毕，但存在上面所列错误，必须全部修正后才可以进行表格导出\n");
// 将错误信息全部输出保存到txt文件中
Utils.SaveErrorInfoToFile();
}
Utils.Log("\n按任意键退出本程序");
Console.ReadKey();
}
private void btnLoadConfig_Click(object sender, EventArgs e)
{
OpenFileDialog dialog = new OpenFileDialog();
dialog.Title = "请选择配置文件所在路径";
dialog.InitialDirectory = AppValues.PROGRAM_FOLDER_PATH;
dialog.Multiselect = false;
dialog.Filter = "Config files (*.txt)|*.txt";
if (dialog.ShowDialog() == DialogResult.OK)
{
string errorString = null;
Dictionary <string, string> config = TxtConfigReader.ParseTxtConfigFile(dialog.FileName, AppValues.SAVE_CONFIG_KEY_VALUE_SEPARATOR, out errorString);
if (!string.IsNullOrEmpty(errorString))
{
MessageBox.Show(string.Format("打开配置文件失败：\n{0}", errorString), "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (config.ContainsKey(AppValues.SAVE_CONFIG_KEY_PROGRAM_PATH))
{
tbProgramPath.Text = config[AppValues.SAVE_CONFIG_KEY_PROGRAM_PATH];
}
if (config.ContainsKey(AppValues.SAVE_CONFIG_KEY_EXCEL_FOLDER_PATH))
{
tbExcelFolderPath.Text = config[AppValues.SAVE_CONFIG_KEY_EXCEL_FOLDER_PATH];
}
if (config.ContainsKey(AppValues.SAVE_CONFIG_KEY_EXPORT_LUA_FOLDER_PATH))
{
tbExportLuaFolderPath.Text = config[AppValues.SAVE_CONFIG_KEY_EXPORT_LUA_FOLDER_PATH];
}
if (config.ContainsKey(AppValues.SAVE_CONFIG_KEY_CLIENT_FOLDER_PATH))
{
tbClientFolderPath.Text = config[AppValues.SAVE_CONFIG_KEY_CLIENT_FOLDER_PATH];
}
if (config.ContainsKey(AppValues.SAVE_CONFIG_KEY_LANG_FILE_PATH))
{
tbLangFilePath.Text = config[AppValues.SAVE_CONFIG_KEY_LANG_FILE_PATH];
}
if (config.ContainsKey(AppValues.NEED_COLUMN_INFO_PARAM_STRING))
{
cbColumnInfo.Checked = true;
}
if (config.ContainsKey(AppValues.UNCHECKED_PARAM_STRING))
{
cbUnchecked.Checked = true;
}
if (config.ContainsKey(AppValues.LANG_NOT_MATCHING_PRINT_PARAM_STRING))
{
cbPrintEmptyStringWhenLangNotMatching.Checked = true;
}
if (config.ContainsKey(AppValues.EXPORT_MYSQL_PARAM_STRING))
{
cbExportMySQL.Checked = true;
}
if (config.ContainsKey(AppValues.ALLOWED_NULL_NUMBER_PARAM_STRING))
{
cbAllowedNullNumber.Checked = true;
}
if (config.ContainsKey(AppValues.PART_EXPORT_PARAM_STRING))
{
tbPartExcelNames.Text = config[AppValues.PART_EXPORT_PARAM_STRING];
}
if (config.ContainsKey(AppValues.EXPORT_CSV_PARAM_STRING))
{
tbExportCsvTableNames.Text = config[AppValues.EXPORT_CSV_PARAM_STRING];
}
if (config.ContainsKey(AppValues.EXPORT_JSON_PARAM_STRING))
{
tbExportJsonTableNames.Text = config[AppValues.EXPORT_JSON_PARAM_STRING];
}
string exportCsvFilePathKey = string.Concat(AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.SAVE_CONFIG_PARAM_SUBTYPE_SEPARATOR, AppValues.EXPORT_CSV_PARAM_SUBTYPE_EXPORT_PATH);
if (config.ContainsKey(exportCsvFilePathKey))
{
tbExportCsvFilePath.Text = config[exportCsvFilePathKey];
}
string csvFileExtensionKey = string.Concat(AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.SAVE_CONFIG_PARAM_SUBTYPE_SEPARATOR, AppValues.EXPORT_CSV_PARAM_SUBTYPE_EXTENSION);
if (config.ContainsKey(csvFileExtensionKey))
{
tbCsvFileExtension.Text = config[csvFileExtensionKey];
}
string csvFileSplitStringKey = string.Concat(AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.SAVE_CONFIG_PARAM_SUBTYPE_SEPARATOR, AppValues.EXPORT_CSV_PARAM_SUBTYPE_SPLIT_STRING);
if (config.ContainsKey(csvFileSplitStringKey))
{
tbCsvFileSplitString.Text = config[csvFileSplitStringKey];
}
string exportJsonFilePathKey = string.Concat(AppValues.EXPORT_JSON_PARAM_PARAM_STRING, AppValues.SAVE_CONFIG_PARAM_SUBTYPE_SEPARATOR, AppValues.EXPORT_JSON_PARAM_SUBTYPE_EXPORT_PATH);
if (config.ContainsKey(exportJsonFilePathKey))
{
tbExportJsonFilePath.Text = config[exportJsonFilePathKey];
}
string jsonFileExtensionKey = string.Concat(AppValues.EXPORT_JSON_PARAM_PARAM_STRING, AppValues.SAVE_CONFIG_PARAM_SUBTYPE_SEPARATOR, AppValues.EXPORT_JSON_PARAM_SUBTYPE_EXTENSION);
if (config.ContainsKey(jsonFileExtensionKey))
{
tbJsonFileExtension.Text = config[jsonFileExtensionKey];
}
cbPart.Checked = config.ContainsKey(AppValues.SAVE_CONFIG_KEY_IS_CHECKED_PART);
cbExportCsv.Checked = config.ContainsKey(AppValues.SAVE_CONFIG_KEY_IS_CHECKED_EXPORT_CSV);
cbExportJson.Checked = config.ContainsKey(AppValues.SAVE_CONFIG_KEY_IS_CHECKED_EXPORT_JSON);
string isExportCsvColumnNameKey = string.Concat(AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.SAVE_CONFIG_PARAM_SUBTYPE_SEPARATOR, AppValues.EXPORT_CSV_PARAM_SUBTYPE_IS_EXPORT_COLUMN_NAME);
cbIsExportCsvColumnName.Checked = config.ContainsKey(isExportCsvColumnNameKey);
string isExportCsvColumnDataTypeKey = string.Concat(AppValues.EXPORT_CSV_PARAM_PARAM_STRING, AppValues.SAVE_CONFIG_PARAM_SUBTYPE_SEPARATOR, AppValues.EXPORT_CSV_PARAM_SUBTYPE_IS_EXPORT_COLUMN_DATA_TYPE);
cbIsExportCsvColumnDataType.Checked = config.ContainsKey(isExportCsvColumnDataTypeKey);
string isExportJsonWithFormatKey = string.Concat(AppValues.EXPORT_JSON_PARAM_PARAM_STRING, AppValues.SAVE_CONFIG_PARAM_SUBTYPE_SEPARATOR, AppValues.EXPORT_JSON_PARAM_SUBTYPE_IS_FORMAT);
cbIsExportJsonWithFormat.Checked = config.ContainsKey(isExportJsonWithFormatKey);
MessageBox.Show("载入配置文件成功", "恭喜", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}