public override Task DoWork(CodeFileBuilder pCodeFileBuilder, ISheetConnector pConnector, TypeData[] arrSheetData, Action <string> OnPrintWorkProcess)
{
//TypeDataList pTypeDataList = JsonSaveManager.LoadData<TypeDataList>($"{GetRelative_To_AbsolutePath(strExportPath)}/{nameof(TypeDataList)}.json", OnPrintWorkProcess);
//if (pTypeDataList == null)
// pTypeDataList = new TypeDataList(pConnector.strSheetID);
// 로컬 데이터에 있는 TypeData와 현재 TypeData가 일치하지 않음.
// 무조건 현재 TypeData기준으로 작업하기
TypeDataList pTypeDataList = new TypeDataList(pConnector.strSheetID);
pTypeDataList.listTypeData = arrSheetData.ToList();
List <Task> listTask = new List <Task>();
foreach (var pSheet in arrSheetData)
{
if (pSheet.eType == ESheetType.Enum)
{
continue;
}
listTask.Add(ProcessJson(pConnector, OnPrintWorkProcess, pSheet, pTypeDataList));
}
Task.WaitAll(listTask.ToArray(), new TimeSpan(3000));
return(Task.Run(() =>
{
pTypeDataList.listTypeData.Sort((x, y) => x.iOrder.CompareTo(y.iOrder));
JsonSaveManager.SaveData(pTypeDataList, $"{GetRelative_To_AbsolutePath(strExportPath)}/{nameof(TypeDataList)}.json");
}));
}
private static Task Parsing_OnCode(TypeData pSheetData, ISheetConnector pConnector, CodeFileBuilder pCodeFileBuilder, List <CommandLineArg> listCommandLine)
{
var pCodeType = pCodeFileBuilder.AddCodeType(pSheetData.strFileName, pSheetData.eType);
var mapFieldData_ConvertStringToEnum = pSheetData.listFieldData.Where((pFieldData) => pFieldData.bConvertStringToEnum).ToDictionary(((pFieldData) => pFieldData.strFieldName));
var listFieldData_DeleteThisField_OnCode = pSheetData.listFieldData.Where((pFieldData) => pFieldData.bDeleteThisField_InCode).Select((pFieldData) => pFieldData.strFieldName);
Dictionary <int, CodeTypeDeclaration> mapEnumType = new Dictionary <int, CodeTypeDeclaration>();
int iDefinedTypeRow = -1;
pSheetData.listEnumName.Clear();
return(pSheetData.ParsingSheet_UseTask(pConnector,
(listRow, strText, iRow, iColumn) =>
{
// 변수 선언 형식인경우
if (strText.Contains(":"))
{
if (iDefinedTypeRow == -1)
{
iDefinedTypeRow = iRow;
}
if (iDefinedTypeRow != iRow)
{
return;
}
string[] arrText = strText.Split(':');
string strFieldName = arrText[0];
if (mapFieldData_ConvertStringToEnum.ContainsKey(strFieldName))
{
FieldTypeData pFieldData = mapFieldData_ConvertStringToEnum[strFieldName];
mapEnumType.Add(iColumn, pCodeFileBuilder.AddCodeType(pFieldData.strEnumName, ESheetType.Enum));
if (pSheetData.listEnumName.Contains(pFieldData.strEnumName) == false)
{
pSheetData.listEnumName.Add(pFieldData.strEnumName);
}
}
// 삭제되는 코드인 경우
if (listFieldData_DeleteThisField_OnCode.Contains(strFieldName))
{
return;
}
pCodeType.AddField(new FieldTypeData(strFieldName, arrText[1]));
return;
}
// 이넘 Column인 경우 이넘 생성
if (mapEnumType.ContainsKey(iColumn))
{
mapEnumType[iColumn].AddEnumField(new EnumFieldData(strText));
return;
}
}).ContinueWith((p) => Execute_CommandLine(pCodeType, listCommandLine)));
}
public static void DoCheck_IsValid_Table(this TypeData pSheetData, ISheetConnector pConnector, Action <string> OnError)
{
bool bIsEnum = pSheetData.eType == ESheetType.Enum;
pSheetData.ParsingSheet(pConnector,
(listRow, strText, iRow, iColumn) =>
{
if (bIsEnum)
{
Dictionary <int, EEnumHeaderType> mapEnumType = new Dictionary <int, EEnumHeaderType>();
if (Enum.TryParse(strText, out EEnumHeaderType eType))
{
// mapEnumType.Add(,eType)
if (eType == EEnumHeaderType.EnumType)
{
for (int i = iColumn; i < listRow.Count; i++)
{
string strTextOtherColumn = (string)listRow[i];
if (Enum.TryParse(strTextOtherColumn, out eType) == false)
{
OnError?.Invoke($"테이블 유효성 체크 - 이넘 파싱 에러");
return;
}
if (mapEnumType.ContainsKey(iColumn) == false)
{
mapEnumType.Add(iColumn, eType);
}
}
}
return;
}
if (mapEnumType.ContainsKey(iColumn) == false)
{
return;
}
switch (mapEnumType[iColumn])
{
case EEnumHeaderType.EnumType:
case EEnumHeaderType.EnumValue:
if (string.IsNullOrEmpty(strText))
{
OnError?.Invoke($"테이블 유효성 체크 - 이넘 파싱 에러");
return;
}
break;
}
}
else
{
}
});
}
public override Task DoWork(CodeFileBuilder pCodeFileBuilder, ISheetConnector pConnector, TypeData[] arrSheetData, Action <string> OnPrintWorkProcess)
{
List <Task> listTask = new List <Task>();
foreach (var pSheet in arrSheetData)
{
listTask.Add(Task.Run(() =>
{
StringBuilder pStrBuilder = new StringBuilder();
StreamWriter pFileWriter = new StreamWriter($"{GetRelative_To_AbsolutePath(strExportPath)}/{pSheet.strFileName.Trim()}.csv");
int iLastRowIndex = -1;
return(pSheet.ParsingSheet_UseTask(pConnector,
(listRow, strText, iRowIndex, iColumnIndex) =>
{
if (iLastRowIndex == -1)
{
iLastRowIndex = iRowIndex;
}
if (strText.Contains(':'))
{
string[] arrText = strText.Split(':');
strText = arrText[0];
}
if (iLastRowIndex != iRowIndex)
{
iLastRowIndex = iRowIndex;
pStrBuilder.Remove(pStrBuilder.Length - 1, 1);
pFileWriter.WriteLine(pStrBuilder.ToString());
pFileWriter.Flush();
pStrBuilder.Clear();
}
pStrBuilder.Append(strText);
pStrBuilder.Append(",");
}).ContinueWith((p) =>
{
pStrBuilder.Remove(pStrBuilder.Length - 1, 1);
pFileWriter.WriteLine(pStrBuilder.ToString());
pFileWriter.Flush();
pFileWriter.Close();
pFileWriter.Dispose();
}));
}));
}
// Task.WaitAll(listTask.ToArray());
return(Task.WhenAll(listTask));
}
public static void ParsingSheet(this TypeData pSheet, ISheetConnector pConnector, delOnParsingText OnParsingTextLine)
{
IList <IList <Object> > pData = pConnector.ISheetConnector_GetSheetData(pSheet.strSheetName);
if (pData == null)
{
return;
}
_ParsingSheet(OnParsingTextLine, pData);
}
public static Task DoWork(this TypeData pSheetData, ISheetConnector pConnector, CodeFileBuilder pCodeFileBuilder, Action <string> OnError)
{
List <CommandLineArg> listCommandLine = Parsing_CommandLine(pSheetData.strCommandLine, OnError);
switch (pSheetData.eType)
{
case ESheetType.Class:
case ESheetType.Struct:
return(Parsing_OnCode(pSheetData, pConnector, pCodeFileBuilder, listCommandLine));
case ESheetType.Enum:
return(Parsing_OnEnum(pSheetData, pConnector, pCodeFileBuilder));
case ESheetType.Global:
return(Parsing_OnGlobal(pSheetData, pConnector, pCodeFileBuilder));
default: return(Task.CompletedTask);
}
}
public SheetData(ISheetConnector pConnector, string strSheetName, string strSheetID)
{
this.pConnector = pConnector;
this.strSheetName = strSheetName;
this.strSheetID = strSheetID;
}
public override Task DoWork(CodeFileBuilder pCodeFileBuilder, ISheetConnector pConnector, TypeData[] arrSheetData, Action <string> OnPrintWorkState)
{
CodeNamespace pNameSpace = new CodeNamespace();
List <CodeNamespaceImport> listDefaultUsing = new List <CodeNamespaceImport>();
listDefaultUsing.Add(new CodeNamespaceImport("UnityEngine"));
List <CommandLineArg> listCommandLine = Parsing_CommandLine(strCommandLine, null);
for (int i = 0; i < listCommandLine.Count; i++)
{
ECommandLine eCommandLine = (ECommandLine)Enum.Parse(typeof(ECommandLine), listCommandLine[i].strArgName);
switch (eCommandLine)
{
case ECommandLine.addusing:
listDefaultUsing.Add(new CodeNamespaceImport(listCommandLine[i].strArgValue));
break;
case ECommandLine.useusing:
pNameSpace.Name = listCommandLine[i].strArgValue;
break;
}
}
CodeNamespaceImport[] arrDefaultUsing = listDefaultUsing.ToArray();
pNameSpace.Imports.AddRange(arrDefaultUsing);
CodeTypeDeclarationCollection arrTypes = pCodeFileBuilder.GetCodeTypeDeclarationCollection();
List <CodeTypeDeclaration> listType = new List <CodeTypeDeclaration>();
foreach (CodeTypeDeclaration pType in arrTypes)
{
listType.Add(pType);
}
HashSet <CodeTypeDeclaration> setExecutedType = new HashSet <CodeTypeDeclaration>();
IEnumerable <CodeTypeDeclaration> listUnitySO = listType.Where(p => string.IsNullOrEmpty(p.Name) == false && p.IsClass);
foreach (CodeTypeDeclaration pType in listUnitySO)
{
TypeData pSaveData = arrSheetData.FirstOrDefault((pSaveDataSheet) => pSaveDataSheet.strFileName == pType.Name);
if (pSaveData == null)
{
continue;
}
Create_SO(pCodeFileBuilder, pNameSpace, pType, pSaveData);
CodeTypeDeclaration[] arrEnumTypes = listType.Where(p => pSaveData.listEnumName.Contains(p.Name)).ToArray();
foreach (var pEnumType in arrEnumTypes)
{
setExecutedType.Add(pEnumType);
}
if (pSaveData.eType == ESheetType.Global)
{
Create_GlobalSOContainer(pCodeFileBuilder, pNameSpace, arrDefaultUsing, pType, arrEnumTypes, pSaveData);
}
else
{
Create_SOContainer(pCodeFileBuilder, pNameSpace, arrDefaultUsing, pType, arrEnumTypes, pSaveData);
}
OnPrintWorkState?.Invoke($"UnitySO - Working SO {pType.Name}");
setExecutedType.Add(pType);
}
// Others
pNameSpace.Types.Clear();
IEnumerable <CodeTypeDeclaration> listOthers = listType.Where(p => string.IsNullOrEmpty(p.Name) == false && setExecutedType.Contains(p) == false);
foreach (CodeTypeDeclaration pType in listOthers)
{
OnPrintWorkState?.Invoke($"UnitySO - Working Others {pType.Name}");
pNameSpace.Types.Add(pType);
setExecutedType.Add(pType);
}
if (pNameSpace.Types.Count != 0)
{
pCodeFileBuilder.Generate_CSharpCode(pNameSpace, $"{GetRelative_To_AbsolutePath(strExportPath)}/Others");
}
return(Task.CompletedTask);
}
public static Task ParsingSheet_UseTask(this TypeData pSheet, ISheetConnector pConnector, delOnParsingText OnParsingTextLine)
{
return(pConnector.ISheetConnector_GetSheetData_Async(pSheet.strSheetName).
ContinueWith(p => _ParsingSheet(OnParsingTextLine, p.Result)));
}
private static Task Parsing_OnEnum(TypeData pSheetData, ISheetConnector pConnector, CodeFileBuilder pCodeFileBuilder)
{
Dictionary <int, EEnumHeaderType> mapEnumType = new Dictionary <int, EEnumHeaderType>();
Dictionary <string, CodeTypeDeclaration> mapEnumValue = new Dictionary <string, CodeTypeDeclaration>();
return(pSheetData.ParsingSheet_UseTask(pConnector,
(listRow, strText, iRow, iColumn) =>
{
EEnumHeaderType eType = EEnumHeaderType.EnumNone;
if (Enum.TryParse(strText, out eType))
{
if (eType == EEnumHeaderType.EnumType)
{
if (mapEnumType.ContainsKey(iColumn) == false)
{
mapEnumType.Add(iColumn, eType);
}
for (int i = iColumn; i < listRow.Count; i++)
{
string strTextOtherColumn = (string)listRow[i];
if (Enum.TryParse(strTextOtherColumn, out eType))
{
if (mapEnumType.ContainsKey(i) == false)
{
mapEnumType.Add(i, eType);
}
}
}
}
return;
}
if (mapEnumType.TryGetValue(iColumn, out eType) == false)
{
return;
}
if (eType != EEnumHeaderType.EnumType)
{
return;
}
if (mapEnumValue.ContainsKey(strText) == false)
{
mapEnumValue.Add(strText, pCodeFileBuilder.AddCodeType(strText, ESheetType.Enum));
}
EnumFieldData pFieldData = new EnumFieldData();
for (int i = iColumn; i < listRow.Count; i++)
{
if (mapEnumType.TryGetValue(i, out eType))
{
string strNextText = (string)listRow[i];
switch (eType)
{
case EEnumHeaderType.EnumValue:
pFieldData.strValue = strNextText;
break;
case EEnumHeaderType.NumberValue: pFieldData.iNumber = int.Parse(strNextText); break;
case EEnumHeaderType.Comment: pFieldData.strComment = strNextText; break;
}
}
}
if (string.IsNullOrEmpty(pFieldData.strValue))
{
throw new Exception($"이넘인데 값이 없습니다 - 타입 : {mapEnumValue[strText].Name}");
}
mapEnumValue[strText].AddEnumField(pFieldData);
}));
}
private static Task Parsing_OnGlobal(TypeData pSheetData, ISheetConnector pConnector, CodeFileBuilder pCodeFileBuilder)
{
var pCodeType_Class = pCodeFileBuilder.AddCodeType(pSheetData.strFileName, pSheetData.eType);
Dictionary <int, EGlobalColumnType> mapGlobalColumnType = new Dictionary <int, EGlobalColumnType>();
Dictionary <string, CodeTypeDeclaration> mapEnumFieldType = new Dictionary <string, CodeTypeDeclaration>();
HashSet <string> setGlobalTable_ByType = new HashSet <string>();
string strKeyFieldName = "";
string strTypeFieldName = "";
int iColumnIndex_Type = -1;
int iColumnIndex_Comment = -1;
return(pSheetData.ParsingSheet_UseTask(pConnector,
(listRow, strText, iRow, iColumn) =>
{
// 변수 선언 형식인경우
if (strText.Contains(":"))
{
string[] arrText = strText.Split(':');
string strFieldName = arrText[0];
string strFieldName_Lower = strFieldName.ToLower();
for (int i = 0; i < (int)EGlobalColumnType.MAX; i++)
{
EGlobalColumnType eCurrentColumnType = (EGlobalColumnType)i;
if (strFieldName_Lower.Contains(eCurrentColumnType.ToString().ToLower()))
{
mapGlobalColumnType.Add(iColumn, eCurrentColumnType);
switch (eCurrentColumnType)
{
case EGlobalColumnType.Key:
{
FieldTypeData pFieldData = pSheetData.listFieldData.FirstOrDefault(p => p.strFieldName == strFieldName);
if (pFieldData != null)
{
pFieldData.bDeleteThisField_InCode = true;
}
strKeyFieldName = strFieldName;
}
break;
case EGlobalColumnType.Comment:
{
FieldTypeData pFieldData = pSheetData.listFieldData.FirstOrDefault(p => p.strFieldName == strFieldName);
if (pFieldData != null)
{
pFieldData.bDeleteThisField_InCode = true;
}
iColumnIndex_Comment = iColumn;
}
break;
case EGlobalColumnType.Type:
{
iColumnIndex_Type = iColumn;
strTypeFieldName = strFieldName;
pCodeType_Class.AddField(new FieldTypeData(strFieldName, arrText[1]));
FieldTypeData pFieldData_Type = pSheetData.listFieldData.FirstOrDefault(p => p.strFieldName == strFieldName);
if (pFieldData_Type == null)
{
pSheetData.listFieldData.Add(new FieldTypeData(strFieldName, arrText[1]));
}
}
break;
default:
pCodeType_Class.AddField(new FieldTypeData(strFieldName, arrText[1]));
break;
}
return;
}
}
}
// 변수 선언이 아니라 값을 파싱하면 일단 타입부터 확인한다
if (mapGlobalColumnType.TryGetValue(iColumn, out var eColumnType) == false)
{
return;
}
switch (eColumnType)
{
case EGlobalColumnType.Key:
string strTypeName = (string)listRow[iColumnIndex_Type];
string strEnumTypeName = const_GlobalKey_EnumName + "_" + strTypeName;
string strEnumFieldName = const_GlobalKey_FieldName + "_" + strTypeName;
if (mapEnumFieldType.TryGetValue(strEnumTypeName, out CodeTypeDeclaration pEnumTypeDeclaration) == false)
{
pEnumTypeDeclaration = AddEnumType(pSheetData, pCodeFileBuilder, strEnumTypeName);
mapEnumFieldType.Add(strEnumTypeName, pEnumTypeDeclaration);
}
FieldTypeData pFieldData_Enum = pSheetData.listFieldData.FirstOrDefault(p => p.strFieldName == strEnumFieldName);
if (pFieldData_Enum == null)
{
pFieldData_Enum = new FieldTypeData(strEnumFieldName, strEnumTypeName);
pFieldData_Enum.strDependencyFieldName = strKeyFieldName;
pFieldData_Enum.bIsVirtualField = true;
pSheetData.listFieldData.Add(pFieldData_Enum);
}
string strComment = "";
if (iColumnIndex_Comment != -1 && iColumnIndex_Comment < listRow.Count)
{
strComment = (string)listRow[iColumnIndex_Comment];
}
if (string.IsNullOrEmpty(strComment))
{
pEnumTypeDeclaration.AddEnumField(new EnumFieldData(strText));
}
else
{
pEnumTypeDeclaration.AddEnumField(new EnumFieldData(strText, strComment));
}
break;
case EGlobalColumnType.Type:
if (setGlobalTable_ByType.Contains(strText))
{
return;
}
setGlobalTable_ByType.Add(strText);
string strFieldType = (string)listRow[iColumnIndex_Type];
FieldTypeData pFieldData = pSheetData.listFieldData.FirstOrDefault(p => p.strFieldName == strTypeFieldName && p.strFieldType == strFieldType);
if (pFieldData == null)
{
pFieldData = new FieldTypeData(strTypeFieldName, strFieldType);
pSheetData.listFieldData.Add(pFieldData);
}
pFieldData.bIsTemp = true;
pFieldData.bDeleteThisField_InCode = true;
pFieldData.bIsVirtualField = strFieldType != "string";
pFieldData.bIsKeyField = true;
pFieldData.bIsOverlapKey = true;
break;
}
}));
}
public override Task DoWork(CodeFileBuilder pCodeFileBuilder, ISheetConnector pConnector, TypeData[] arrSheetData, Action <string> OnPrintWorkProcess)
{
return(Task.Run(() => pCodeFileBuilder.Generate_CSharpCode($"{GetRelative_To_AbsolutePath(strPath)}/{strFileName}")));
}
public abstract Task DoWork(CodeFileBuilder pCodeFileBuilder, ISheetConnector pConnector, TypeData[] arrSheetData, Action <string> OnPrintWorkState);
private Task ProcessJson(ISheetConnector pConnector, Action <string> OnPrintWorkProcess, TypeData pSheet,
TypeDataList pTypeDataList)
{
JObject pJson_Instance = new JObject();
JArray pArray = new JArray();
Dictionary <string, FieldTypeData> mapFieldData = pSheet.listFieldData.Where(p => p.bIsVirtualField == false).ToDictionary(p => p.strFieldName);
Dictionary <int, string> mapMemberName = new Dictionary <int, string>();
int iColumnStartIndex = -1;
return(pSheet.ParsingSheet_UseTask(pConnector,
((listRow, strText, iRowIndex, iColumnIndex) =>
{
if (strText.Contains(':')) // 변수 타입 파싱
{
if (mapMemberName.ContainsKey(iColumnIndex))
{
return;
}
string[] arrText = strText.Split(':');
mapMemberName.Add(iColumnIndex, arrText[0]);
// mapMemberType.Add(iColumnIndex, arrText[1]);
if (iColumnStartIndex == -1)
{
iColumnStartIndex = iColumnIndex;
}
return;
}
if (iColumnIndex != iColumnStartIndex)
{
return;
}
JObject pObject = new JObject();
// 실제 변수값
for (int i = iColumnIndex; i < listRow.Count; i++)
{
if (mapMemberName.ContainsKey(i) == false)
{
continue;
}
if (mapFieldData.TryGetValue(mapMemberName[i], out FieldTypeData pFieldTypeData) == false)
{
OnPrintWorkProcess?.Invoke($"{pSheet.strSheetName}({pSheet.strSheetID}) - mapFieldData.ContainsKey({mapMemberName[i]}) Fail");
continue;
}
string strFieldName = pFieldTypeData.strFieldName;
string strValue = (string)listRow[i];
pObject.Add(strFieldName, strValue);
}
pArray.Add(pObject);
})).ContinueWith((pTask) =>
{
pJson_Instance.Add("array", pArray);
string strFileName = $"{pSheet.strFileName}.json";
JsonSaveManager.SaveData(pJson_Instance, $"{GetRelative_To_AbsolutePath(strExportPath)}/{strFileName}");
var pAlreadyExist = pTypeDataList.listTypeData.FirstOrDefault(p => p.strSheetID == pSheet.strSheetID);
if (pAlreadyExist != null)
{
pTypeDataList.listTypeData.Remove(pAlreadyExist);
}
pTypeDataList.listTypeData.Add(pSheet);
}));
}
private void OnFinishConnect(ISheetConnector pConnector, Exception pException_OnError)
{
if (pException_OnError != null)
{
WriteConsole("연결 실패 " + pException_OnError);
return;
}
if (_mapSaveData.ContainsKey(pConnector.strSheetID))
{
pSpreadSheet_CurrentConnected = _mapSaveData[pConnector.strSheetID];
pSpreadSheet_CurrentConnected.eType = pConnector.eSheetType;
List <TypeData> listSavedTable = pSpreadSheet_CurrentConnected.listTable;
int iOrder = 0;
foreach (KeyValuePair <string, SheetData> pSheet in pConnector.mapWorkSheetData_Key_Is_SheetID)
{
TypeData pTypeDataFind = listSavedTable.FirstOrDefault(x => (x.strSheetID == pSheet.Key));
if (pTypeDataFind == null)
{
listSavedTable.Add(new TypeData(pSheet.Value.strSheetID, pSheet.Value.strSheetName, iOrder));
}
else
{
// 이미 저장되있는 Sheet의 경우
// 웹에 있는 SheetName과 로컬의 SheetName이 다를 수 있기 때문에 갱신
pTypeDataFind.strSheetName = pSheet.Value.strSheetName;
pTypeDataFind.iOrder = iOrder;
}
iOrder++;
}
}
else
{
pSpreadSheet_CurrentConnected = new SaveData_SpreadSheet(pConnector.strSheetID, pConnector.eSheetType);
_mapSaveData[pSpreadSheet_CurrentConnected.strSheetID] = pSpreadSheet_CurrentConnected;
int iOrder = 0;
pSpreadSheet_CurrentConnected.listTable.Clear();
foreach (KeyValuePair <string, SheetData> pSheet in pConnector.mapWorkSheetData_Key_Is_SheetID)
{
pSpreadSheet_CurrentConnected.listTable.Add(new TypeData(pSheet.Value.strSheetID, pSheet.Value.strSheetName, iOrder++));
}
SaveDataManager.SaveSheet(pSpreadSheet_CurrentConnected);
WriteConsole("새 파일을 만들었습니다.");
}
checkedListBox_SheetList.Items.Clear();
List <TypeData> listSheetSaved = pSpreadSheet_CurrentConnected.listTable;
listSheetSaved.Sort((x, y) => x.iOrder.CompareTo(y.iOrder));
TypeData[] arrSheetDelete = listSheetSaved.Where((pSheet) =>
pConnector.mapWorkSheetData_Key_Is_SheetID.Values.Any(p => p.strSheetID == pSheet.strSheetID) == false).ToArray();
if (arrSheetDelete.Length > 0)
{
for (int i = 0; i < arrSheetDelete.Length; i++)
{
listSheetSaved.Remove(arrSheetDelete[i]);
}
AutoSaveAsync_CurrentSheet();
}
ClearFieldData(listSheetSaved);
for (int i = 0; i < listSheetSaved.Count; i++)
{
checkedListBox_SheetList.Items.Add(listSheetSaved[i], listSheetSaved[i].bEnable);
}
checkedListBox_WorkList.Items.Clear();
List <WorkBase> listWorkBase = pSpreadSheet_CurrentConnected.listSaveWork;
listWorkBase.Sort((x, y) => x.iWorkOrder.CompareTo(y.iWorkOrder));
for (int i = 0; i < listWorkBase.Count; i++)
{
checkedListBox_WorkList.Items.Add(listWorkBase[i], listWorkBase[i].bEnable);
}
SetState(EState.IsConnected);
WriteConsole("연결 성공");
_bIsConnecting = false;
}
