SW/CPXV2
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[성현모] CPXV2 Init

Browse Source
This commit is contained in:
SHM
2024-06-26 10:30:00 +09:00
parent cdf12248c5
commit 5958993b6a
588 changed files with 698420 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
SystemX.Net.CP.Platform/SystemX.Net.CP.Platform.sln Normal file
View File

@ -0,0 +1,52 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.30330.147
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SystemX.Net.CP.Platform", "SystemX.Net.Platform\SystemX.Net.CP.Platform.csproj", "{9E024203-A0D4-4A08-8041-9D31248B6F7B}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SystemX.PLC", "SystemX.PLC\SystemX.PLC.csproj", "{56642DC5-C7EF-4040-ACFC-FEC17EC717D6}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SystemX.XEFCore", "SystemX.XEFCore\SystemX.XEFCore.csproj", "{ABA6745F-3019-4551-8DF2-EE85B7C9D7AD}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Debug|x64 = Debug|x64
Release|Any CPU = Release|Any CPU
Release|x64 = Release|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{9E024203-A0D4-4A08-8041-9D31248B6F7B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{9E024203-A0D4-4A08-8041-9D31248B6F7B}.Debug|Any CPU.Build.0 = Debug|Any CPU
{9E024203-A0D4-4A08-8041-9D31248B6F7B}.Debug|x64.ActiveCfg = Debug|x64
{9E024203-A0D4-4A08-8041-9D31248B6F7B}.Debug|x64.Build.0 = Debug|x64
{9E024203-A0D4-4A08-8041-9D31248B6F7B}.Release|Any CPU.ActiveCfg = Release|Any CPU
{9E024203-A0D4-4A08-8041-9D31248B6F7B}.Release|Any CPU.Build.0 = Release|Any CPU
{9E024203-A0D4-4A08-8041-9D31248B6F7B}.Release|x64.ActiveCfg = Release|x64
{9E024203-A0D4-4A08-8041-9D31248B6F7B}.Release|x64.Build.0 = Release|x64
{56642DC5-C7EF-4040-ACFC-FEC17EC717D6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{56642DC5-C7EF-4040-ACFC-FEC17EC717D6}.Debug|Any CPU.Build.0 = Debug|Any CPU
{56642DC5-C7EF-4040-ACFC-FEC17EC717D6}.Debug|x64.ActiveCfg = Debug|x64
{56642DC5-C7EF-4040-ACFC-FEC17EC717D6}.Debug|x64.Build.0 = Debug|x64
{56642DC5-C7EF-4040-ACFC-FEC17EC717D6}.Release|Any CPU.ActiveCfg = Release|Any CPU
{56642DC5-C7EF-4040-ACFC-FEC17EC717D6}.Release|Any CPU.Build.0 = Release|Any CPU
{56642DC5-C7EF-4040-ACFC-FEC17EC717D6}.Release|x64.ActiveCfg = Release|Any CPU
{56642DC5-C7EF-4040-ACFC-FEC17EC717D6}.Release|x64.Build.0 = Release|Any CPU
{ABA6745F-3019-4551-8DF2-EE85B7C9D7AD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{ABA6745F-3019-4551-8DF2-EE85B7C9D7AD}.Debug|Any CPU.Build.0 = Debug|Any CPU
{ABA6745F-3019-4551-8DF2-EE85B7C9D7AD}.Debug|x64.ActiveCfg = Debug|Any CPU
{ABA6745F-3019-4551-8DF2-EE85B7C9D7AD}.Debug|x64.Build.0 = Debug|Any CPU
{ABA6745F-3019-4551-8DF2-EE85B7C9D7AD}.Release|Any CPU.ActiveCfg = Release|Any CPU
{ABA6745F-3019-4551-8DF2-EE85B7C9D7AD}.Release|Any CPU.Build.0 = Release|Any CPU
{ABA6745F-3019-4551-8DF2-EE85B7C9D7AD}.Release|x64.ActiveCfg = Release|Any CPU
{ABA6745F-3019-4551-8DF2-EE85B7C9D7AD}.Release|x64.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {34BF09E0-D510-452D-8E8B-B0D1C6FE25BF}
VisualSVNWorkingCopyRoot = .
EndGlobalSection
EndGlobal

36
SystemX.Net.CP.Platform/SystemX.Net.Platform/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// 어셈블리에 대한 일반 정보는 다음 특성 집합을 통해
// 제어됩니다. 어셈블리와 관련된 정보를 수정하려면
// 이러한 특성 값을 변경하세요.
[assembly: AssemblyTitle("SystemX.Net.Platform")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("SystemX.Net.Platform")]
[assembly: AssemblyCopyright("Copyright © 2020")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// ComVisible을 false로 설정하면 이 어셈블리의 형식이 COM 구성 요소에
// 표시되지 않습니다. COM에서 이 어셈블리의 형식에 액세스하려면
// 해당 형식에 대해 ComVisible 특성을 true로 설정하세요.
[assembly: ComVisible(false)]
// 이 프로젝트가 COM에 노출되는 경우 다음 GUID는 typelib의 ID를 나타냅니다.
[assembly: Guid("9e024203-a0d4-4a08-8041-9d31248b6f7b")]
// 어셈블리의 버전 정보는 다음 네 가지 값으로 구성됩니다.
//
// 주 버전
// 부 버전
// 빌드 번호
// 수정 버전
//
// 모든 값을 지정하거나 아래와 같이 '*'를 사용하여 빌드 번호 및 수정 번호를
// 기본값으로 할 수 있습니다.
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

361
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common.Protocol/AsyncEventProcess.cs Normal file
View File

@ -0,0 +1,361 @@
using System;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using SystemX.Common.Serialization;
using SystemX.Net.BaseProtocol;
using SystemX.Net.Schedule;
namespace SystemX.Common.Protocol
{
using static SystemX.Net.Platform.Common.Util.LogMessage;
public class PacketProgressChangedEventArgs : EventArgs
{
public PacketProgressChangedEventArgs(int progressPercentage, object userState)
{
this.ProgressPercentage = progressPercentage;
this.UserState = userState;
}
public int ProgressPercentage { get; private set; }
public object UserState { get; private set; }
}
public class PacketAnalyzerCompletedEventArgs : AsyncCompletedEventArgs
{
private object result;
public PacketAnalyzerCompletedEventArgs(object result, Exception error, bool cancelled, object userState) : base(error, cancelled, userState)
{
this.result = result;
}
public object Result
{
get
{
base.RaiseExceptionIfNecessary();
return this.result;
}
}
[EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
public new object UserState
{
get
{
return base.UserState;
}
}
}
public class PacketCalculate
{
public event EventHandler<PacketAnalyzerCompletedEventArgs> PacketAnalyzerCompleted;
public event EventHandler<PacketProgressChangedEventArgs> ProgressChanged;
/// <summary>
/// ThreadContext에서 실행하기 위한 AsyncOperation.
/// </summary>
private AsyncOperation asyncOperation;
/// <summary>
/// AsyncOperation 로 Completed 호출을 위한 델리게이트.
/// </summary>
private SendOrPostCallback operationCompleted;
/// <summary>
/// AsyncOperation 로 ProgressChanged 호출을 위한 델리게이트.
/// </summary>
private SendOrPostCallback progressReporter;
public bool IsBusy { get; private set; }
public bool CancellationPending { get; private set; }
private readonly Action<object> startDelegate;
public bool WorkerReportsProgress { get; set; }
public bool WorkerSupportsCancellation { get; set; }
#region CREATE
public PacketCalculate()
{
this.startDelegate = this.WorkerThreadStart;
this.operationCompleted = this.SendOperationCompletedEvent;
this.progressReporter = this.SendProgressChangedEvent;
}
#endregion
private void SendOperationCompletedEvent(object arg)
{
this.IsBusy = false;
this.CancellationPending = false;
var eventArgs = arg as PacketAnalyzerCompletedEventArgs;
if (eventArgs == null)
return;
var completed = this.PacketAnalyzerCompleted;
if (completed != null)
completed(this, eventArgs);
}
private void SendProgressChangedEvent(object arg)
{
var eventArgs = arg as PacketProgressChangedEventArgs;
if (eventArgs == null)
return;
var progressChanged = this.ProgressChanged;
if (progressChanged != null)
progressChanged(this, eventArgs);
}
private void WorkerThreadStart(object argument)
{
object result = null;
Exception error = null;
try
{
result = this.Calculate(argument, true);
}
catch (Exception ex)
{
error = ex;
}
this.asyncOperation.PostOperationCompleted(this.operationCompleted, new PacketAnalyzerCompletedEventArgs(result, error, this.CancellationPending, null));
}
private void ReportProgress(int percentProgress)
{
if (!this.WorkerReportsProgress)
{
//throw new InvalidOperationException("BackgroundWorker_WorkerDoesntReportProgress.[SystemX.Common.AsyncEvent : PacketCalculate.ReportProgress]");
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"BackgroundWorker_WorkerDoesntReportProgress.[SystemX.Common.AsyncEvent : PacketCalculate.ReportProgress]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
var arg = new PacketProgressChangedEventArgs(percentProgress, null);
if (this.asyncOperation != null)
{
this.asyncOperation.Post(this.progressReporter, arg);
}
else
{
this.progressReporter(arg);
}
}
public void CalculateAsync(object argument)
{
this.IsBusy = true;
this.CancellationPending = false;
this.asyncOperation = AsyncOperationManager.CreateOperation(null);
this.startDelegate.BeginInvoke(argument, null, null);
}
public void CancelAsync()
{
if (!this.WorkerSupportsCancellation)
{
//throw new InvalidOperationException("BackgroundWorker_WorkerDoesntSupportCancellation.[SystemX.Common.AsyncEvent : PacketCalculate.CancelAsync]");
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"General packet marshalling failed.[SystemX.Common : COMMON.GetHeaderProtocol]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
this.CancellationPending = true;
}
public XData Calculate(object objPacket, bool isAsync = false)
{
XData ResultData = null;
XPacket getPacket = (XPacket)objPacket;
int iStoreCnt = getPacket.ucPacketBytes.Count();
byte[] recvStoreBuffer = getPacket.ucPacketBytes;
BASE_PROTOCOL GET_PROTOCOL = new BASE_PROTOCOL();
BASE_PROTOCOL.PROTOCOL_CODE GET_CODE = new BASE_PROTOCOL.PROTOCOL_CODE();
HEADER_PACKET GET_HEADER = new HEADER_PACKET();
byte ucSetLabel = getPacket.nLabel;
bool bReplayResult = true;
object objData = null;
try
{
GET_PROTOCOL = XCommons.GetHeaderProtocol(iStoreCnt, recvStoreBuffer);
GET_HEADER = XCommons.GetHeaderPacket(iStoreCnt, recvStoreBuffer);
GET_CODE = GET_PROTOCOL.GET_CURRENT_PROTOCOL;
if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.CONNECT_STATE)
{
PING_PACKET PacketData = new PING_PACKET();
PacketData = XCommons.ByteStreamToSpecialObject<PING_PACKET>(GET_CODE, iStoreCnt, recvStoreBuffer);
objData = PacketData;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.MIDDLEWARE_MESSAGE)
{
MESSAGE_PACKET PacketData = new MESSAGE_PACKET();
PacketData = XCommons.ByteStreamToSpecialObject<MESSAGE_PACKET>(GET_CODE, iStoreCnt, recvStoreBuffer);
objData = PacketData;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.HOST_INFO_CHECK)
{
SYSTEM_HOST_PACKET PacketData = new SYSTEM_HOST_PACKET();
PacketData = XCommons.ByteStreamToSpecialObject<SYSTEM_HOST_PACKET>(GET_CODE, iStoreCnt, recvStoreBuffer);
objData = PacketData;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.SYNC_TIME_SERVER)
{
TIME_PACKET PacketData = new TIME_PACKET();
PacketData = XCommons.ByteStreamToSpecialObject<TIME_PACKET>(GET_CODE, iStoreCnt, recvStoreBuffer);
objData = PacketData;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.FILE_TRANSFER)
{
byte[] PacketData = XCommons.ByteStreamToObject<byte[]>(GET_CODE, iStoreCnt, recvStoreBuffer);
objData = PacketData;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.DATASET_TRANSEFER)
{
DataSet PacketData = XCommons.ByteStreamToObject<DataSet>(GET_CODE, iStoreCnt, recvStoreBuffer);
bReplayResult = GET_HEADER.bResponsState;
objData = PacketData;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.RAW_SIZE)
{
byte[] PacketData = XCommons.ByteStreamToObject<byte[]>(GET_CODE, iStoreCnt, recvStoreBuffer);
objData = PacketData;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.INITILALIZE_INFO)
{
COMM_INFO_PACKET PacketData = new COMM_INFO_PACKET();
PacketData = XCommons.ByteStreamToSpecialObject<COMM_INFO_PACKET>(GET_CODE, iStoreCnt, recvStoreBuffer);
objData = PacketData;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.SYSTEM_QUERY)
{
QUERY_PACKET PacketData = new QUERY_PACKET();
PacketData = XCommons.ByteStreamToSpecialObject<QUERY_PACKET>(GET_CODE, iStoreCnt, recvStoreBuffer);
objData = PacketData;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.USER_QUERY)
{
QUERY_PACKET PacketData = new QUERY_PACKET();
PacketData = XCommons.ByteStreamToSpecialObject<QUERY_PACKET>(GET_CODE, iStoreCnt, recvStoreBuffer);
objData = PacketData;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.TRANSFER_RESULT)
{
TRANSFER_PACKET PacketData = new TRANSFER_PACKET();
PacketData = XCommons.ByteStreamToSpecialObject<TRANSFER_PACKET>(GET_CODE, iStoreCnt, recvStoreBuffer);
objData = PacketData;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.ETC)
{
USER_PACKET PacketData = new USER_PACKET();
PacketData = XCommons.ByteStreamToSpecialObject<USER_PACKET>(GET_CODE, iStoreCnt, recvStoreBuffer);
objData = PacketData;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.PROCESS_QUERY)
{
PROCESS_PACKET PacketData = new PROCESS_PACKET();
PacketData = XCommons.ByteStreamToSpecialObject<PROCESS_PACKET>(GET_CODE, iStoreCnt, recvStoreBuffer);
objData = PacketData;
}
else
{
GET_PROTOCOL = new BASE_PROTOCOL(BASE_PROTOCOL.PROTOCOL_CODE.NONE);
bReplayResult = false;
objData = null;
}
}
catch (Exception e)
{
GET_PROTOCOL = new BASE_PROTOCOL(BASE_PROTOCOL.PROTOCOL_CODE.NONE);
bReplayResult = false;
objData = null;
string strErrMsg = e.Message;
}
ResultData = new XData();
ResultData.dtTime = DateTime.Now;
ResultData.bReplayResult = bReplayResult;
ResultData.BaseProtocol = GET_PROTOCOL;
ResultData.HeaderPacket = GET_HEADER;
ResultData.objData = objData;
ResultData.nLabel = ucSetLabel;
return ResultData;
}
}
public class EventBaseAsyncPattern
{
public void Run(int p)
{
var PacketAnalyzerWait = new PacketCalculate
{
WorkerReportsProgress = true,
WorkerSupportsCancellation = true
};
PacketAnalyzerWait.PacketAnalyzerCompleted += calculatorPacket_CalculateCompleted;
PacketAnalyzerWait.ProgressChanged += calculatorPacket_ProgressChanged;
var i = 0;
while (i < 5)
{
if (PacketAnalyzerWait.IsBusy)
continue;
PacketAnalyzerWait.CalculateAsync(p + i);
i++;
}
}
void calculatorPacket_ProgressChanged(object sender, PacketProgressChangedEventArgs e)
{
//"Calculating : {0}% Completed", e.ProgressPercentage;
}
void calculatorPacket_CalculateCompleted(object sender, PacketAnalyzerCompletedEventArgs e)
{
//e.Result;
}
}
}

91
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common.Protocol/CommonCustomMakeProtocol.cs Normal file
View File

@ -0,0 +1,91 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SystemX.Net;
using SystemX.Net.BaseProtocol;
namespace SystemX.Common.Protocol
{
using ParamElement = Tuple<SqlDbType, int, byte, byte>;
public static class CommonParamSet
{
public static Dictionary<string, ParamElement> fParam= new Dictionary<string, ParamElement>();
public static void TestResultField()
{
fParam.Clear();
fParam = new Dictionary<string, ParamElement>();
fParam.Add("No", new ParamElement(SqlDbType.BigInt, 0, 0, 0));
fParam.Add("TestDT", new ParamElement(SqlDbType.DateTime2, 7, 0, 0));
fParam.Add("LogData", new ParamElement(SqlDbType.NVarChar, -1, 0, 0));
}
public static SqlParameter GetMakeSqlParameterInfo(Dictionary<string, ParamElement> refField, string strSetName, object objValue)
{
if (refField.ContainsKey(strSetName))
{
SqlParameter param = null;
if (refField[strSetName].Item2 != 0)
param = new SqlParameter("@" + strSetName, refField[strSetName].Item1, refField[strSetName].Item2);
else
param = new SqlParameter("@" + strSetName, refField[strSetName].Item1);
if (refField[strSetName].Item1 == SqlDbType.Decimal)
{
param.Precision = refField[strSetName].Item3;
param.Scale = refField[strSetName].Item4;
}
param.Value = objValue;
return param;
}
else
return null;
}
}
public class CommonCustomProtocol : BASE_PROTOCOL
{
public CommonCustomProtocol() : base()
{
}
public CommonCustomProtocol(ushort usGetCommnad, ushort usGetSubCommand) : base(usGetCommnad, usGetSubCommand)
{
}
public CommonCustomProtocol(PROTOCOL_CODE SET_CODE) : base(SET_CODE)
{
}
public SqlCommand LogDataResultInsert(string strTableName, DataRow itemData)
{
string columns = string.Empty;
columns = "No,TestDT,DataLog";
string values = string.Join(",", columns.Split(',').Select(c => string.Format("@{0}", c)));
string sqlCommand = string.Format("INSERT INTO [" + strTableName + "] ({0}) VALUES ({1})", columns, values);
CommonParamSet.TestResultField();
SqlCommand cmd = new SqlCommand(sqlCommand);
SqlParameter[] setParams = new SqlParameter[columns.Split(',').Count()];
setParams[0] = CommonParamSet.GetMakeSqlParameterInfo(CommonParamSet.fParam, "No", itemData["No"]);
setParams[1] = CommonParamSet.GetMakeSqlParameterInfo(CommonParamSet.fParam, "TestDT", itemData["TestDT"]);
setParams[2] = CommonParamSet.GetMakeSqlParameterInfo(CommonParamSet.fParam, "LogData", itemData["LogData"]);
cmd.Parameters.AddRange(setParams);
return cmd;
}
}
}

593
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common.Protocol/LSU Trimming 4th/CustomMakeProtocol_LSU.cs Normal file
View File

@ -0,0 +1,593 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SystemX.Net;
using SystemX.Net.BaseProtocol;
namespace SystemX.Common.Protocol.LSU
{
public class CustomProtocol_ : BASE_PROTOCOL
{
public CustomProtocol_() : base()
{
}
public CustomProtocol_(ushort usGetCommnad, ushort usGetSubCommand) : base(usGetCommnad, usGetSubCommand)
{
}
public CustomProtocol_(PROTOCOL_CODE SET_CODE) : base(SET_CODE)
{
}
//REF
public string QueryRefModelList()
{
string strQueryInfo = string.Empty;
strQueryInfo = "SELECT * FROM REFS_Model ORDER BY No";
return strQueryInfo;
}
public string QueryRefModelAllInfo(string strSensorID)
{
string strQueryInfo = string.Empty;
//INNER JOIN REFS_Model C ON C.RefSnrsID = A.RefSnrsID
strQueryInfo = "SELECT B.Model_Type, B.RefSnrsID, B.Name, B.Status, " +
"A.Pressure, A.ZeroPoint, A.SetPointPM, A.SetPointFT, A.MRG1, A.MRG3, A.MRG4, A.MRG5, A.SFG20, A.SFG45, A.RI, " +
"X.CountWarning, X.CountLimit " +
"FROM REFS_Model AS B, REFS_UsagePlan AS X, REFS_ModelChar AS A " +
"WHERE B.RefSnrsID = '" + strSensorID + "' AND B.RefSnrsID = A.RefSnrsID AND A.RefSnrsID = X.RefSnrsID;";
return strQueryInfo;
}
public string QueryRefModelPlanInfo(string strSensorID)
{
string strQueryInfo = string.Empty;
strQueryInfo = "SELECT A.Model_Type, A.RefSnrsID, A.Name, A.Status, " +
"X.CountWarning, X.CountLimit " +
"FROM REFS_Model AS A, REFS_UsagePlan AS X " +
"WHERE A.RefSnrsID = '" + strSensorID + "' AND A.RefSnrsID = X.RefSnrsID;";
return strQueryInfo;
}
public string QueryRefModelGetCnt(string strSensroID, string strUsageID)
{
string strQueryInfo = string.Empty;
strQueryInfo = "SELECT A.RefSnrsID, A.UsagePlaceID, A.LastUpdateDT, A.Count, A.AccumulateCount " +
"FROM REFS_UsageHistory AS A " +
"INNER JOIN(SELECT MAX(B.LastUpdateDT) AS LAST_DATE, B.RefSnrsID AS ID, B.UsagePlaceID AS UPI " +
"FROM REFS_UsageHistory AS B WHERE B.RefSnrsID = '" + strSensroID + "' AND B.UsagePlaceID = '" + strUsageID + "' GROUP BY B.RefSnrsID, B.UsagePlaceID) AS SUB " +
"ON SUB.LAST_DATE = A.LastUpdateDT " +
"AND A.RefSnrsID = SUB.ID " +
"AND A.UsagePlaceID = SUB.UPI;";
return strQueryInfo;
}
public string QueryRefModelSetCnt(string strSensroID, string strUsageID)
{
string strQueryInfo = string.Empty;
strQueryInfo = "UPDATE A SET A.Count = A.Count + 1, A.AccumulateCount = A.AccumulateCount + 1, A.LastUpdateDT = GETDATE() " +
"FROM REFS_UsageHistory A " +
"JOIN(SELECT MAX(B.LastUpdateDT) AS LAST_DATE, B.RefSnrsID AS ID, B.UsagePlaceID AS UPI " +
"FROM REFS_UsageHistory AS B WHERE B.RefSnrsID = '" + strSensroID + "' AND B.UsagePlaceID = '" + strUsageID + "' GROUP BY B.RefSnrsID, B.UsagePlaceID) AS SUB " +
"ON SUB.LAST_DATE = A.LastUpdateDT " +
"AND A.RefSnrsID = SUB.ID " +
"AND A.UsagePlaceID = SUB.UPI;";
return strQueryInfo;
}
public string QueryRefModelChangeKnowNewPlace(string strSensroID, string strUsageID, string strNewUsageID)
{
string strQueryInfo = string.Empty;
strQueryInfo = "INSERT INTO REFS_UsageHistory (RefSnrsID, UsagePlaceID, Count, AccumulateCount, Description) " +
"SELECT RefSnrsID, '" + strNewUsageID + "', '0', AccumulateCount, Description FROM REFS_UsageHistory AS A " +
"INNER JOIN(SELECT MAX(B.LastUpdateDT) AS LAST_DATE, B.RefSnrsID AS ID, B.UsagePlaceID AS UPI " +
"FROM REFS_UsageHistory AS B WHERE B.RefSnrsID = '" + strSensroID + "' AND B.UsagePlaceID = '" + strUsageID + "' GROUP BY B.RefSnrsID, B.UsagePlaceID) AS SUB " +
"ON SUB.LAST_DATE = A.LastUpdateDT " +
"AND A.RefSnrsID = SUB.ID " +
"AND A.UsagePlaceID = SUB.UPI;";
return strQueryInfo;
}
public string QueryRefModelChange(string strSensroID, string strNewUsageID)
{
string strQueryInfo = string.Empty;
strQueryInfo = "INSERT INTO REFS_UsageHistory(RefSnrsID, UsagePlaceID, Count, AccumulateCount, Description) " +
"SELECT A.RefSnrsID, '" + strNewUsageID + "', '0', A.AccumulateCount, A.Description FROM REFS_UsageHistory AS A " +
"INNER JOIN(SELECT * FROM REFS_UsageHistory WHERE " +
"LastUpdateDT = (SELECT MAX(LastUpdateDT) FROM REFS_UsageHistory B WHERE B.RefSnrsID = '" + strSensroID + "' " +
"GROUP BY B.RefSnrsID)) AS SUB " +
"ON SUB.LastUpdateDT = A.LastUpdateDT " +
"AND A.RefSnrsID = SUB.RefSnrsID " +
"AND A.UsagePlaceID = SUB.UsagePlaceID;";
return strQueryInfo;
}
public string QueryRefModelRegister(string strSensroID, string strUsageID)
{
string strQueryInfo = string.Empty;
strQueryInfo = "IF EXISTS(SELECT RefSnrsID FROM [REFS_Model] AS B WHERE B.RefSnrsID = '" + strSensroID + "') " +
"BEGIN " +
"IF NOT EXISTS(SELECT RefSnrsID FROM REFS_UsageHistory AS A WHERE A.RefSnrsID = '" + strSensroID + "') " +
"BEGIN " +
"INSERT INTO REFS_UsageHistory (RefSnrsID, UsagePlaceID, Count, AccumulateCount, Description) VALUES('" + strSensroID + "', '" + strUsageID + "', 0, 0, '-'); " +
"END " +
"END;";
return strQueryInfo;
}
public string QueryRefModelLastSensorAtPlaceID(string strUsageID)
{
string strQueryInfo = string.Empty;
strQueryInfo = "SELECT * FROM[REFS_UsageHistory] A " +
"WHERE LastUpdateDT = (SELECT MAX(LastUpdateDT) " +
"FROM[REFS_UsageHistory] B " +
"WHERE B.UsagePlaceID = '" + strUsageID + "' " +
"GROUP BY B.UsagePlaceID);";
return strQueryInfo;
}
/*
*
*/
/*
public string QueryMakeModeInfo(PROCESS_PACKET getPaket)
{
string strQueryInfo = string.Empty;
strQueryInfo = "SELECT ModeID FROM [CONST_WorkMode] WHERE PalletNumber = '" + getPaket.objPalletNumber[0].Data + "';";
return strQueryInfo;
}
public string QueryFindTrimmingImage(int iProcNum, PROCESS_PACKET getPaket)
{
string strQueryInfo = string.Empty;
int iSetType = 0;
if (getPaket.objPalletID[0].Data.IndexOf("-") >= 0)
iSetType = 1;
if (getPaket.objPalletNumber[0].Data.IndexOf("-") >= 0)
iSetType = 2;
//Normal
strQueryInfo = "SELECT TOP 1 No, LogData, UpdateDT FROM [HIST_TestResultData_" + iProcNum.ToString() + "] WHERE No " +
"IN(SELECT No FROM [HIST_TestResultData_" + iProcNum.ToString() + "] WHERE " +
"PalletNumber = '" + getPaket.objPalletNumber[0].Data + "' " +
"AND PalletID = '" + getPaket.objPalletID[0].Data + "' " +
"AND ProdID = '" + getPaket.objProductID[0].Data + "' " +
"AND TestID = 'LTV' " +
"AND Status = 50) " +
"ORDER BY No DESC;";
if(iSetType == 1)
{
strQueryInfo = "SELECT TOP 1 No, LogData, UpdateDT FROM [HIST_TestResultData_" + iProcNum.ToString() + "] WHERE No " +
"IN(SELECT No FROM [HIST_TestResultData_" + iProcNum.ToString() + "] WHERE " +
"PalletNumber = '" + getPaket.objPalletNumber[0].Data + "' " +
"AND ProdID = '" + getPaket.objProductID[0].Data + "' " +
"AND TestID = 'LTV' " +
"AND Status = 50) " +
"ORDER BY No DESC;";
}
else if (iSetType == 2)
{
strQueryInfo = "SELECT TOP 1 No, LogData, UpdateDT FROM [HIST_TestResultData_" + iProcNum.ToString() + "] WHERE No " +
"IN(SELECT No FROM [HIST_TestResultData_" + iProcNum.ToString() + "] WHERE " +
"ProdID = '" + getPaket.objProductID[0].Data + "' " +
"AND TestID = 'LTV' " +
"AND Status = 50) " +
"ORDER BY No DESC;";
}
return strQueryInfo;
}
public string QueryMakePalletInfo(PROCESS_PACKET getPaket)
{
string strQueryInfo = string.Empty;
//Unused Pallet Position
if (getPaket.objProductID[0].Data.Length == 0)
strQueryInfo = "SELECT * FROM STAT_ProdLoad A WHERE A.PalletNumber = '" + getPaket.objPalletNumber[0].Data + "' ORDER BY A.No;";
else
strQueryInfo = "SELECT * FROM STAT_ProdLoad A WHERE A.PalletNumber = '" + getPaket.objPalletNumber[0].Data +
"' AND A.ProdID = '" + getPaket.objProductID[0].Data + "' ORDER BY A.No;";
return strQueryInfo;
}
*/
public string QueryMakePalletInfo(string strPalletNumber, string strProductID = "")
{
string strQueryInfo = string.Empty;
//Unused Pallet Position
if (strProductID.Length == 0)
strQueryInfo = "SELECT * FROM STAT_ProdLoad A WHERE A.PalletNumber = '" + strPalletNumber + "' ORDER BY A.No;";
else
strQueryInfo = "SELECT * FROM STAT_ProdLoad A WHERE A.PalletNumber = '" + strPalletNumber +
"' AND A.ProdID = '" + strProductID + "' ORDER BY A.No;";
return strQueryInfo;
}
public string QueryMakeModelInfo(int iPos, ServerInfo getServerInfo, XTableInfo getSchemaTableInfo, string strProdNo)
{
//int iGetProcessCode = getServerInfo.ConnectInfo[iPos].Item4;
string strQueryInfo = string.Empty;
/*IEnumerable<InfoProcess> queryFindProcessInfo =
from Process in getServerInfo.ProcessInfo
where Process.nNum == (iPos + 1)
select Process;
string strQueryInfo = string.Empty;
foreach (InfoProcess fpi in queryFindProcessInfo)
{
//Find Process Info
//기본 Child 및 Parent Model info Inner join Query 문 생성
if (fpi.bParameterInfoUse == false)
{
strQueryInfo = "SELECT B.Model_Type, A.PrtProdNo, A.Plug_Type AS 'C Plug Type', B.Plug_Type AS 'P Plug Type', A.ProdNo, A.Name AS 'C Name', A.CableLength, A.FillPrs_Target, A.FillPrs_USpec, A.FillPrs_LSpec," +
"B.Name AS 'P Name', B.RegulationType, B.ProtTubeType, B.RiSetPoint" +
//
" FROM PROD_ModelParent AS B, " +
//
"PROD_ModelChild AS A INNER JOIN PROD_ModelParent C ON C.PrtProdNo = A.PrtProdNo" +
" WHERE A.ProdNo = '" + strProdNo + "' AND B.PrtProdNo = A.PrtProdNo;";
}
else
{
strQueryInfo = "SELECT B.Model_Type, A.PrtProdNo, A.Plug_Type AS 'C Plug Type', B.Plug_Type AS 'P Plug Type', A.ProdNo, A.Name AS 'C Name', A.CableLength, A.FillPrs_Target, A.FillPrs_USpec, A.FillPrs_LSpec," +
"B.Name AS 'P Name', B.RegulationType, B.ProtTubeType, B.RiSetPoint,";
string[] strParameterTableList = null;
strParameterTableList = fpi.strParameterInfoTableName.Split(',');
if (strParameterTableList.Count() > 3)
return "ERROR - Parameter table use max 3.";
string[] strSubAs = new string[3] { "X", "Y", "Z" };
string[] strSubTable = new string[3] { "", "", "" };
int iSet = 0;
foreach (string strName in strParameterTableList)
{
int iTp = Array.FindIndex<XTable>(getSchemaTableInfo._table.ToArray(), x => x.tableName == strName);
XTable xt = getSchemaTableInfo._table[iTp];
string[] strAddModelInfo = new string[xt.lstName.Count];
for (int i = 0; i < xt.lstName.Count; i++)
{
strAddModelInfo[i] = string.Empty;
strAddModelInfo[i] = @" " + strSubAs[iSet] + "." + xt.lstName[i] + " AS '" + strName + " " + xt.lstName[i] + "',";
//'SUB" + (iSet+1).ToString() + " " + xt.lstName[i] + "',";
if (xt.lstName[i].CompareTo("No") == 0)
continue;
else if (xt.lstName[i].CompareTo("UpdateDT") == 0)
continue;
else if (xt.lstName[i].CompareTo("Revision") == 0)
continue;
else if (xt.lstName[i].CompareTo("Description") == 0)
continue;
strQueryInfo += strAddModelInfo[i];
}
strSubTable[iSet] = strName + " AS " + strSubAs[iSet] + ",";
iSet++;
}
strQueryInfo = strQueryInfo.Remove(strQueryInfo.Length - 1, 1);
strQueryInfo +=
" FROM ";
foreach (string strSubT in strSubTable)
{
if (strSubT.Length > 0)
strQueryInfo += strSubT;
}
strQueryInfo +=
" PROD_ModelParent AS B, " +
"PROD_ModelChild AS A INNER JOIN PROD_ModelParent C ON C.PrtProdNo = A.PrtProdNo" +
" WHERE A.ProdNo = '" + strProdNo + "' AND B.PrtProdNo = A.PrtProdNo ";
iSet = 0;
foreach (string strSubT in strSubTable)
{
if (strSubT.Length > 0)
strQueryInfo += "AND B.PrtProdNo = " + strSubAs[iSet] + ".PrtProdNo ";
iSet++;
}
strQueryInfo += ";";
}
break;
}
*/
return strQueryInfo;
}
public string[] GetProcessPPITableList(int iPos, ServerInfo getServerInfo, XTableInfo getSchemaTableInfo)
{
//int iGetProcessCode = getServerInfo.ConnectInfo[iPos].Item4;
string[] strPPITableList = null;
/*IEnumerable<InfoProcess> queryFindProcessInfo =
from Process in getServerInfo.ProcessInfo
where Process.nNum == (iPos + 1)
select Process;
foreach (InfoProcess fpi in queryFindProcessInfo)
{
//Find Process Info
strPPITableList = fpi.strPreviousProcessInquiryTableName.Split(',');
break;
}*/
return strPPITableList;
}
public SqlCommand[] InsertLogData(
ref string strOutLogKey,
string strSetAddLogKey,
Int64 SetNumber,
string strTestID,
int iProcNum,
DataSet dsPalletInfo,
string strFilePath,
byte[] ucDataArray,
ushort usPalletIndex = ushort.MaxValue,
string strSetPalletNumber = "",
string strSetPalletID = "",
string strSetPIndex = "",
string strSeProdNo = "",
string strSetProdID = "",
int iSetStatus = 0)
{
SqlCommand[] cmd = new SqlCommand[2];
strOutLogKey = string.Empty;
strOutLogKey = "";
string strNullPath = "NULL";
byte[] ucNullByte = new byte[1];
ucNullByte[0] = 0x01;
if (dsPalletInfo != null)
{
bool hasRows = dsPalletInfo.Tables.Cast<DataTable>().Any(table => table.Rows.Count != 0);
if (hasRows)
{
string strPalletNumber = string.Empty;
string strPalletID = string.Empty;
string strPIndex = string.Empty;
string strProdNo = string.Empty;
string strProdID = string.Empty;
if (usPalletIndex == ushort.MaxValue)
{
strPalletNumber = strSetPalletNumber;
strPalletID = strSetPalletID;
strPIndex = strSetPIndex;
strProdNo = strSeProdNo;
strProdID = strSetProdID;
}
else
{
int iAccessPos = 0;
if (usPalletIndex != ushort.MaxValue)
iAccessPos = usPalletIndex - 1;
strPalletNumber = dsPalletInfo.Tables[0].Rows[iAccessPos]["PalletNumber"].ToString();
strPalletID = dsPalletInfo.Tables[0].Rows[iAccessPos]["PalletID"].ToString();
strPIndex = dsPalletInfo.Tables[0].Rows[iAccessPos]["PIndex"].ToString();
strProdNo = dsPalletInfo.Tables[0].Rows[iAccessPos]["ProdNo"].ToString();
strProdID = dsPalletInfo.Tables[0].Rows[iAccessPos]["ProdID"].ToString();
}
strPalletNumber = strPalletNumber.Trim();
strPalletID = strPalletID.Trim();
strPIndex = strPIndex.Trim();
strProdNo = strProdNo.Trim();
strProdID = strProdID.Trim();
cmd[0] = new SqlCommand("INSERT INTO HIST_TestResultData_" + iProcNum.ToString() + " (LogAccessKey, ProcNo, PalletNumber, PalletID, PIndex, ProdNo, ProdID, TestID, LogDataPath, LogData, Status) VALUES (@LogAccessKey, @ProcNo, @PalletNumber, @PalletID, @PIndex, @ProdNo, @ProdID, @TestID, @LogDataPath, @LogData, @Status)");
cmd[1] = new SqlCommand("INSERT INTO HIST_TestResultData (LogAccessKey, ProcNo, PalletNumber, PalletID, PIndex, ProdNo, ProdID, TestID, LogDataPath, LogData, Status) VALUES (@LogAccessKey, @ProcNo, @PalletNumber, @PalletID, @PIndex, @ProdNo, @ProdID, @TestID, @LogDataPath, @LogData, @Status)");
if (strSetAddLogKey.Length == 0)
strOutLogKey = SetNumber.ToString() + "-" + iProcNum.ToString();
else
strOutLogKey = SetNumber.ToString() + "-" + iProcNum.ToString() + "-" + strSetAddLogKey;
SqlParameter param0 = new SqlParameter("@LogAccessKey", SqlDbType.NVarChar, 64);
param0.Value = strOutLogKey;
cmd[0].Parameters.Add(param0);
/*
* ProcNo : 공정 코드 180 ~ 290
*/
param0 = new SqlParameter("@ProcNo", SqlDbType.BigInt);
param0.Value = iProcNum;
cmd[0].Parameters.Add(param0);
param0 = new SqlParameter("@PalletNumber", SqlDbType.NVarChar, 20);
param0.Value = strPalletNumber;
cmd[0].Parameters.Add(param0);
param0 = new SqlParameter("@PalletID", SqlDbType.NVarChar, 30);
param0.Value = strPalletID;
cmd[0].Parameters.Add(param0);
param0 = new SqlParameter("@PIndex", SqlDbType.TinyInt);
param0.Value = Convert.ToByte(strPIndex);
cmd[0].Parameters.Add(param0);
param0 = new SqlParameter("@ProdNo", SqlDbType.NVarChar, 30);
param0.Value = strProdNo;
cmd[0].Parameters.Add(param0);
param0 = new SqlParameter("@ProdID", SqlDbType.NVarChar, 50);
param0.Value = strProdID;
cmd[0].Parameters.Add(param0);
/*
* TestID 공정 위치별 ID
*/
param0 = new SqlParameter("@TestID", SqlDbType.NVarChar, 20);
param0.Value = strTestID;
cmd[0].Parameters.Add(param0);
param0 = new SqlParameter("@LogDataPath", SqlDbType.NVarChar, 256);
param0.Value = strFilePath;
cmd[0].Parameters.Add(param0);
param0 = new SqlParameter("@LogData", SqlDbType.VarBinary, -1);
param0.Value = ucDataArray; // byte[]로 지정함
cmd[0].Parameters.Add(param0);
param0 = new SqlParameter("@Status", SqlDbType.TinyInt);
param0.Value = iSetStatus;
cmd[0].Parameters.Add(param0);
//
//
SqlParameter param1 = new SqlParameter("@LogAccessKey", SqlDbType.NVarChar, 64);
param1.Value = strOutLogKey;
cmd[1].Parameters.Add(param1);
/*
* ProcNo : 공정 코드 180 ~ 290
*/
param1 = new SqlParameter("@ProcNo", SqlDbType.BigInt);
param1.Value = iProcNum;
cmd[1].Parameters.Add(param1);
param1 = new SqlParameter("@PalletNumber", SqlDbType.NChar, 20);
param1.Value = strPalletNumber;
cmd[1].Parameters.Add(param1);
param1 = new SqlParameter("@PalletID", SqlDbType.NChar, 30);
param1.Value = strPalletID;
cmd[1].Parameters.Add(param1);
param1 = new SqlParameter("@PIndex", SqlDbType.TinyInt);
param1.Value = Convert.ToByte(strPIndex);
cmd[1].Parameters.Add(param1);
param1 = new SqlParameter("@ProdNo", SqlDbType.NChar, 30);
param1.Value = strProdNo;
cmd[1].Parameters.Add(param1);
param1 = new SqlParameter("@ProdID", SqlDbType.NChar, 50);
param1.Value = strProdID;
cmd[1].Parameters.Add(param1);
/*
* TestID 공정 위치별 ID
*/
param1 = new SqlParameter("@TestID", SqlDbType.NChar, 20);
param1.Value = strTestID;
cmd[1].Parameters.Add(param1);
param1 = new SqlParameter("@LogDataPath", SqlDbType.NVarChar, 256);
param1.Value = strNullPath;
cmd[1].Parameters.Add(param1);
param1 = new SqlParameter("@LogData", SqlDbType.VarBinary, -1);
param1.Value = ucNullByte; // byte[]로 지정함
cmd[1].Parameters.Add(param1);
param1 = new SqlParameter("@Status", SqlDbType.TinyInt);
param1.Value = iSetStatus;
cmd[1].Parameters.Add(param1);
}
}
return cmd;
}
public string QueryMakePPIInfo(string strTableName, string strProdNo, string strPalletID)
{
string strQueryInfo = string.Empty;
//오늘 부터 10일 이내 데이터만 필요시
strQueryInfo = "SELECT A.PalletID, A.PIndex, A.ProdID, A.Result AS RESULT, A.UpdateDT " +
"FROM " + strTableName + " AS A " +
"INNER JOIN" +
"(" +
"SELECT MAX(UpdateDT) AS LAST_DATE, B.ProdID " +
"FROM " + strTableName + " AS B WHERE ProdID = '" + strProdNo + "' " +
"GROUP BY ProdID" +
") AS SUB " +
"ON A.UpdateDT = SUB.LAST_DATE " +
//"AND SUB.LAST_DATE BETWEEN CONVERT(VARCHAR, GETDATE() - 10, 112) AND CONVERT(VARCHAR, GETDATE(), 112) " +
"AND A.ProdID = SUB.ProdID " +
"AND A.PalletID = '" + strPalletID + "';";
/*
if (strPalletID.Length > 0 && iPalletIndex > 0)
{
strQueryInfo = "SELECT A.PalletID, A.PIndex, A.ProdID, A.Result AS RESULT, A.UpdateDT " +
"FROM " + strTableName + " AS A " +
"INNER JOIN" +
"(" +
"SELECT MAX(UpdateDT) AS LAST_DATE, B.ProdID " +
"FROM " + strTableName + " AS B WHERE ProdID = '" + strProdNo + "' " +
"GROUP BY ProdID" +
") AS SUB " +
"ON A.UpdateDT = SUB.LAST_DATE " +
"AND SUB.LAST_DATE BETWEEN CONVERT(VARCHAR, GETDATE() - 15, 112) AND CONVERT(VARCHAR, GETDATE(), 112) " +
"AND A.ProdID = SUB.ProdID " +
"AND A.PalletID = '" + strPalletID + "';";
}
else
{
strQueryInfo = "SELECT A.PalletID, A.PIndex, A.ProdID, A.Result AS RESULT, A.UpdateDT " +
"FROM " + strTableName + " AS A " +
"INNER JOIN" +
"(" +
"SELECT MAX(UpdateDT) AS LAST_DATE, B.ProdID " +
"FROM " + strTableName + " AS B WHERE ProdID = '" + strProdNo + "' " +
"GROUP BY ProdID" +
") AS SUB " +
"ON A.UpdateDT = SUB.LAST_DATE " +
"AND SUB.LAST_DATE BETWEEN CONVERT(VARCHAR, GETDATE() - 15, 112) AND CONVERT(VARCHAR, GETDATE(), 112) " +
"AND A.ProdID = SUB.ProdID";
}
*/
return strQueryInfo;
}
}
}

660
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common.Protocol/Smart Inhibitor 1th/CustomMakeProtocol_SIA.cs Normal file
View File

@ -0,0 +1,660 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SystemX.Net;
using SystemX.Net.BaseProtocol;
namespace SystemX.Common.Protocol.SIA
{
using ParamElement = Tuple<SqlDbType, int, byte, byte>;
public class HISTTesterSummary
{
public string StationName { set; get; }
public string TestType { set; get; }
public string Version { set; get; }
public string ProdCode { set; get; }
public int TestListFileNo { set; get; }
public int TestListVariantNo { set; get; }
public string TestListCntID { set; get; }
public int StepVersion { set; get; }
public string Host { set; get; }
public string Section { set; get; }
public string ProdNoC { set; get; }
public string ProdNoP { set; get; }
public string TestCode { set; get; }
public string TestListFileName { set; get; }
public string ProductID { set; get; }
public string Result { set; get; }
public string Duration { set; get; }
public DateTime TestDT { set; get; }
}
public class HISTLogSummary
{
public Int64 AccessStart { set; get; }
public Int64 AccessEnd { set; get; }
public Int64 LogNo { set; get; }
public int LogCount { set; get; }
public string StationName { set; get; }
public string TestType { set; get; }
public string Version { set; get; }
public string ProdCode { set; get; }
public int TestListFileNo { set; get; }
public int TestListVariantNo { set; get; }
public string TestListCntID { set; get; }
public int StepVersion { set; get; }
public string Host { set; get; }
public string Section { set; get; }
public string ProdNoC { set; get; }
public string ProdNoP { set; get; }
public string TestCode { set; get; }
public string TestListFileName { set; get; }
public string ProductID { set; get; }
public string Result { set; get; }
public string Duration { set; get; }
public DateTime TestDT { set; get; }
}
public static class ParamSet
{
public static Dictionary<string, ParamElement> fParam= new Dictionary<string, ParamElement>();
public static void TesterSummaryField()
{
fParam.Clear();
fParam = new Dictionary<string, ParamElement>();
fParam.Add("StationName", new ParamElement(SqlDbType.NVarChar, 128, 0, 0));
fParam.Add("TestType", new ParamElement(SqlDbType.NVarChar, 8, 0, 0));
fParam.Add("Version", new ParamElement(SqlDbType.NVarChar, 4, 0, 0));
fParam.Add("ProdCode", new ParamElement(SqlDbType.NVarChar, 4, 0, 0));
fParam.Add("TestListFileNo", new ParamElement(SqlDbType.Int, 0, 0, 0));
fParam.Add("TestListVariantNo", new ParamElement(SqlDbType.Int, 0, 0, 0));
fParam.Add("TestListCntID", new ParamElement(SqlDbType.NVarChar, 256, 0, 0));
fParam.Add("StepVersion", new ParamElement(SqlDbType.Int, 0, 0, 0));
fParam.Add("HostID", new ParamElement(SqlDbType.NVarChar, 64, 0, 0));
fParam.Add("Section", new ParamElement(SqlDbType.NVarChar, 64, 0, 0));
fParam.Add("ProdNo_C", new ParamElement(SqlDbType.NVarChar, 32, 0, 0));
fParam.Add("ProdNo_P", new ParamElement(SqlDbType.NVarChar, 32, 0, 0));
fParam.Add("Testcode", new ParamElement(SqlDbType.NVarChar, 16, 0, 0));
fParam.Add("TestListFileName", new ParamElement(SqlDbType.NVarChar, 256, 0, 0));
fParam.Add("ProductID", new ParamElement(SqlDbType.NVarChar, 64, 0, 0));
fParam.Add("Result", new ParamElement(SqlDbType.NVarChar, 16, 0, 0));
fParam.Add("Duration", new ParamElement(SqlDbType.NVarChar, 16, 0, 0));
fParam.Add("TestDT", new ParamElement(SqlDbType.DateTime2, 7, 0, 0));
}
public static void LogSummaryField()
{
fParam.Clear();
fParam = new Dictionary<string, ParamElement>();
fParam.Add("AccessStart", new ParamElement(SqlDbType.BigInt, 0, 0, 0));
fParam.Add("AccessEnd", new ParamElement(SqlDbType.BigInt, 0, 0, 0));
fParam.Add("LogNo", new ParamElement(SqlDbType.BigInt, 0, 0, 0));
fParam.Add("LogCount", new ParamElement(SqlDbType.Int, 0, 0, 0));
fParam.Add("StationName", new ParamElement(SqlDbType.NVarChar, 128, 0, 0));
fParam.Add("TestType", new ParamElement(SqlDbType.NVarChar, 8, 0, 0));
fParam.Add("Version", new ParamElement(SqlDbType.NVarChar, 4, 0, 0));
fParam.Add("ProdCode", new ParamElement(SqlDbType.NVarChar, 4, 0, 0));
fParam.Add("TestListFileNo", new ParamElement(SqlDbType.Int, 0, 0, 0));
fParam.Add("TestListVariantNo", new ParamElement(SqlDbType.Int, 0, 0, 0));
fParam.Add("TestListCntID", new ParamElement(SqlDbType.NVarChar, 256, 0, 0));
fParam.Add("StepVersion", new ParamElement(SqlDbType.Int, 0, 0, 0));
fParam.Add("HostID", new ParamElement(SqlDbType.NVarChar, 64, 0, 0));
fParam.Add("Section", new ParamElement(SqlDbType.NVarChar, 64, 0, 0));
fParam.Add("ProdNo_C", new ParamElement(SqlDbType.NVarChar, 32, 0, 0));
fParam.Add("ProdNo_P", new ParamElement(SqlDbType.NVarChar, 32, 0, 0));
fParam.Add("Testcode", new ParamElement(SqlDbType.NVarChar, 16, 0, 0));
fParam.Add("TestListFileName", new ParamElement(SqlDbType.NVarChar, 256, 0, 0));
fParam.Add("ProductID", new ParamElement(SqlDbType.NVarChar, 64, 0, 0));
fParam.Add("Result", new ParamElement(SqlDbType.NVarChar, 16, 0, 0));
fParam.Add("Duration", new ParamElement(SqlDbType.NVarChar, 16, 0, 0));
fParam.Add("TestDT", new ParamElement(SqlDbType.DateTime2, 7, 0, 0));
}
public static void TestResultField()
{
fParam.Clear();
fParam = new Dictionary<string, ParamElement>();
fParam.Add("AccessKey", new ParamElement(SqlDbType.BigInt, 0, 0, 0));
fParam.Add("StepID", new ParamElement(SqlDbType.BigInt, 0, 0, 0));
fParam.Add("MeasVal", new ParamElement(SqlDbType.Decimal, 0, 15, 5));
fParam.Add("MeasValStr", new ParamElement(SqlDbType.NVarChar, 1024, 0, 0));
fParam.Add("Message", new ParamElement(SqlDbType.NVarChar, 2048, 0, 0));
fParam.Add("GlobalMin", new ParamElement(SqlDbType.NVarChar, 1024, 0, 0));
fParam.Add("GlobalMax", new ParamElement(SqlDbType.NVarChar, 1024, 0, 0));
fParam.Add("Result", new ParamElement(SqlDbType.NVarChar, 16, 0, 0));
fParam.Add("SpentTime", new ParamElement(SqlDbType.NVarChar, 64, 0, 0));
fParam.Add("DataDT", new ParamElement(SqlDbType.DateTime2, 7, 0, 0));
}
public static SqlParameter GetMakeSqlParameterInfo(Dictionary<string, ParamElement> refField, string strSetName, object objValue)
{
if (refField.ContainsKey(strSetName))
{
SqlParameter param = null;
if (refField[strSetName].Item2 != 0)
param = new SqlParameter("@" + strSetName, refField[strSetName].Item1, refField[strSetName].Item2);
else
param = new SqlParameter("@" + strSetName, refField[strSetName].Item1);
if (refField[strSetName].Item1 == SqlDbType.Decimal)
{
param.Precision = refField[strSetName].Item3;
param.Scale = refField[strSetName].Item4;
}
param.Value = objValue;
return param;
}
else
return null;
}
}
public static class LogParamInfo
{
public static readonly int MessageLength = 2048;
public static readonly int MessageValLength = 1024;
public static string STEP = "";
public static string POSITION = "";
public static string MO = "";
public static string FNC_NAME = "";
public static string MIN = "";
public static string MEASURE = "";
public static string MAX = "";
public static string DIM = "";
public static string CHECK = "";
public static string SPENT_TIME = "";
public static string INFO = "";
public static bool GLOBAL_SPEC = false;
public static string VRFY_MIN = "";
public static string VRFY_MAX = "";
}
public class CustomProtocol_ : BASE_PROTOCOL
{
public CustomProtocol_() : base()
{
}
public CustomProtocol_(ushort usGetCommnad, ushort usGetSubCommand) : base(usGetCommnad, usGetSubCommand)
{
}
public CustomProtocol_(PROTOCOL_CODE SET_CODE) : base(SET_CODE)
{
}
public string CheckTestListUpdate(string strProdC, string strTestCode, string strTestType, string strVersion, string strProdCode)
{
StringBuilder sbSetQuery = new StringBuilder();
/*
sbSetQuery.Append("SELECT A.TestListNo, A.ProdNo_C, B.ProdNo_P, B.UpdateDT, D.TestCode, " +
"B.TestType, B.Version, B.ProdCode FROM PROD_Release AS A WITH(NOLOCK) ");
*/
sbSetQuery.Append("SELECT A.VariantNo AS 'TestListNo', A.ProdNo_C, B.ProdNo_P, B.UpdateDT, D.TestCode, " +
"E.TestType, E.Version, E.ProdCode, B.TestListFileNo, A.VariantNo, E.UpdateDT AS 'TestListFileUpdateDT' FROM PROD_Release AS A WITH(NOLOCK) ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM [PROD_Variant] WITH(NOLOCK)) AS B ");
sbSetQuery.Append("ON A.VariantNo = B.No ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM [PROD_Group] WITH(NOLOCK)) AS C ");
sbSetQuery.Append("ON B.GroupNo = C.No ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM [STAT_TestCode] WITH(NOLOCK)) AS D ");
sbSetQuery.Append("ON A.TestCodeNo = D.No ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM [STOR_TestListFile] WITH(NOLOCK)) AS E ");
sbSetQuery.Append("ON B.TestListFileNo = E.No ");
sbSetQuery.Append("WHERE A.ProdNo_C = '" + strProdC + "' ");
if (strTestCode.Length > 0)
sbSetQuery.Append("AND D.TestCode = '" + strTestCode + "' ");
if (strTestType.Length > 0)
sbSetQuery.Append("AND E.TestType = '" + strTestType + "' ");
if (strVersion.Length > 0)
sbSetQuery.Append("AND E.Version = '" + strVersion + "' ");
if (strProdCode.Length > 0)
sbSetQuery.Append("AND E.ProdCode = '" + strProdCode + "' ");
return sbSetQuery.ToString();
/*
string[] strGetTestListFindInfo = new string[3];
strGetTestListFindInfo[0] = strTestType;
strGetTestListFindInfo[1] = strVersion;
strGetTestListFindInfo[2] = strProdCode;
bool bFirstAppend = false;
int iParameterCnt = 0;
for (int i = 0; i < strGetTestListFindInfo.Length; i++)
{
if (strGetTestListFindInfo[i].Length > 0)
{
iParameterCnt++;
if (bFirstAppend == false)
{
bFirstAppend = true;
sbSetQuery.Append("WHERE ");
}
if (iParameterCnt > 1)
sbSetQuery.Append("AND ");
switch (i)
{
case 0:
sbSetQuery.Append("TestType = '" + strGetTestListFindInfo[i] + "' ");
break;
case 1:
sbSetQuery.Append("Version = '" + strGetTestListFindInfo[i] + "' ");
break;
case 2:
sbSetQuery.Append("ProdCode = '" + strGetTestListFindInfo[i] + "' ");
break;
}
}
}
sbSetQuery.Append(") AS B ");
sbSetQuery.Append("ON B.No = A.TestListNo ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM PROD_Group AS Y WITH(NOLOCK)) AS C ");
sbSetQuery.Append("ON C.No = B.GroupNo ");
if (strTestCode.Length > 0)
sbSetQuery.Append("INNER JOIN(SELECT * FROM STAT_TestCode AS Z WITH(NOLOCK) WHERE Z.TestCode = '" + strTestCode + "') AS D ");
else
sbSetQuery.Append("INNER JOIN(SELECT * FROM STAT_TestCode AS Z WITH(NOLOCK)) AS D ");
sbSetQuery.Append("ON A.ProdNo_C = '" + strProdC + "' AND B.No = A.TestListNo AND D.No = A.TestCodeNo;");
*/
return sbSetQuery.ToString();
}
public string QueryFindTestList(PROCESS_PACKET getPaket, bool bJustCheck = false)
{
StringBuilder sbSetQuery = new StringBuilder();
/*
if (bJustCheck)
{
sbSetQuery.Append("SELECT A.ProdNo_C, B.ProdNo_P, B.UpdateDT, D.TestCode, D.Gate1, D.Gate2, " +
"B.FileName, A.RegUserComment, E.Description, C.GroupName, C.ModelName, " +
"A.TestListNo, A.Config, " +
"B.TestType, B.Version, B.ProdCode, B.UseTLPosition FROM PROD_Release AS A ");
}
else
{
sbSetQuery.Append("SELECT A.ProdNo_C, B.ProdNo_P, B.UpdateDT, D.TestCode, D.Gate1, D.Gate2, " +
"B.FileName, A.RegUserComment, E.Description, C.GroupName, C.ModelName, " +
"A.TestListNo, A.Config, " +
"B.TestType, B.Version, B.ProdCode, B.TestListData, B.UseTLPosition FROM PROD_Release AS A ");
}
*/
if (bJustCheck)
{
sbSetQuery.Append("SELECT A.ProdNo_C, B.ProdNo_P, B.UpdateDT, D.TestCode, D.Gate1, D.Gate2, " +
"E.FileName, A.RegUserComment, E.Description, C.GroupName, C.ModelName, " +
"A.VariantNo AS 'TestListNo', A.Config, " +
"E.TestType, E.Version, E.ProdCode, B.UseTLPosition, B.TestListFileNo, E.UpdateDT AS 'TestListFileUpdateDT', A.VariantNo FROM [PROD_Release] AS A WITH(NOLOCK) ");
}
else
{
sbSetQuery.Append("SELECT A.ProdNo_C, B.ProdNo_P, B.UpdateDT, D.TestCode, D.Gate1, D.Gate2, " +
"E.FileName, A.RegUserComment, E.Description, C.GroupName, C.ModelName, " +
"A.VariantNo AS 'TestListNo', A.Config, " +
"E.TestType, E.Version, E.ProdCode, E.TestListData, B.UseTLPosition, B.TestListFileNo, E.UpdateDT AS 'TestListFileUpdateDT', A.VariantNo FROM [PROD_Release] AS A WITH(NOLOCK) ");
}
sbSetQuery.Append("INNER JOIN(SELECT * FROM [PROD_Variant] WITH(NOLOCK)) AS B ");
sbSetQuery.Append("ON A.VariantNo = B.No ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM [PROD_Group] WITH(NOLOCK)) AS C ");
sbSetQuery.Append("ON B.GroupNo = C.No ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM [STAT_TestCode] WITH(NOLOCK)) AS D ");
sbSetQuery.Append("ON A.TestCodeNo = D.No ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM [STOR_TestListFile] WITH(NOLOCK)) AS E ");
sbSetQuery.Append("ON B.TestListFileNo = E.No ");
sbSetQuery.Append("WHERE A.ProdNo_C = '" + getPaket.objProdNo_C[0].Data + "' ");
if (getPaket.objTestCode[0].Data.Length > 0)
sbSetQuery.Append("AND D.TestCode = '" + getPaket.objTestCode[0].Data + "' ");
if (getPaket.objTestType[0].Data.Length > 0)
sbSetQuery.Append("AND E.TestType = '" + getPaket.objTestType[0].Data + "' ");
if (getPaket.objTestListFileVersion[0].Data.Length > 0)
sbSetQuery.Append("AND E.Version = '" + getPaket.objTestListFileVersion[0].Data + "' ");
if (getPaket.objProductionCode[0].Data.Length > 0)
sbSetQuery.Append("AND E.ProdCode = '" + getPaket.objProductionCode[0].Data + "' ");
return sbSetQuery.ToString();
/*
string[] strGetTestListFindInfo = new string[3];
strGetTestListFindInfo[0] = getPaket.objTestType[0].Data;
strGetTestListFindInfo[1] = getPaket.objTestListFileVersion[0].Data;
strGetTestListFindInfo[2] = getPaket.objProductionCode[0].Data;
bool bFirstAppend = false;
int iParameterCnt = 0;
for (int i = 0; i < strGetTestListFindInfo.Length; i++)
{
if (strGetTestListFindInfo[i].Length > 0)
{
iParameterCnt++;
if (bFirstAppend == false)
{
bFirstAppend = true;
sbSetQuery.Append("WHERE ");
}
if (iParameterCnt > 1)
sbSetQuery.Append("AND ");
switch (i)
{
case 0:
sbSetQuery.Append("TestType = '" + strGetTestListFindInfo[i] + "' ");
break;
case 1:
sbSetQuery.Append("Version = '" + strGetTestListFindInfo[i] + "' ");
break;
case 2:
sbSetQuery.Append("ProdCode = '" + strGetTestListFindInfo[i] + "' ");
break;
}
}
}
*/
}
public string QuerySelectTestListData(PROCESS_PACKET getPaket, int nLoadPosition)
{
StringBuilder sbSetQuery = new StringBuilder();
sbSetQuery.Append("SELECT A.ProdNo_C, B.ProdNo_P, B.UpdateDT, E.UpdateDT AS 'TestListFileUpdateDT', D.TestCode, D.Gate1, D.Gate2, " +
"E.FileName, A.RegUserComment, E.Description, C.GroupName, C.ModelName, " +
"A.VariantNo, A.VariantNo AS 'TestListNo', A.Config, " +
"E.TestType, E.Version, E.ProdCode, ");
switch (nLoadPosition)
{
case 1: sbSetQuery.Append("F.TestListData1 AS 'TestListData', "); break;
case 2: sbSetQuery.Append("F.TestListData2 AS 'TestListData', "); break;
case 3: sbSetQuery.Append("F.TestListData3 AS 'TestListData', "); break;
case 4: sbSetQuery.Append("F.TestListData4 AS 'TestListData', "); break;
case 5: sbSetQuery.Append("F.TestListData5 AS 'TestListData', "); break;
case 6: sbSetQuery.Append("F.TestListData6 AS 'TestListData', "); break;
case 7: sbSetQuery.Append("F.TestListData7 AS 'TestListData', "); break;
case 8: sbSetQuery.Append("F.TestListData8 AS 'TestListData', "); break;
case 9: sbSetQuery.Append("F.TestListData9 AS 'TestListData', "); break;
case 10: sbSetQuery.Append("F.TestListData10 AS 'TestListData', "); break;
}
sbSetQuery.Append("B.TestListFileNo, B.UseTLPosition FROM [PROD_Release] AS A WITH(NOLOCK) ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM [PROD_Variant] WITH(NOLOCK)) AS B ");
sbSetQuery.Append("ON A.VariantNo = B.No ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM [PROD_Group] WITH(NOLOCK)) AS C ");
sbSetQuery.Append("ON B.GroupNo = C.No ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM [STAT_TestCode] WITH(NOLOCK)) AS D ");
sbSetQuery.Append("ON A.TestCodeNo = D.No ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM [STOR_TestListFile] WITH(NOLOCK)) AS E ");
sbSetQuery.Append("ON B.TestListFileNo = E.No ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM [HIST_TestListFile] WITH(NOLOCK)) AS F ");
sbSetQuery.Append("ON B.TestListFileNo = F.TestListFileNo ");
sbSetQuery.Append("WHERE A.ProdNo_C = '" + getPaket.objProdNo_C[0].Data + "' ");
if (getPaket.objTestCode[0].Data.Length > 0)
sbSetQuery.Append("AND D.TestCode = '" + getPaket.objTestCode[0].Data + "' ");
if (getPaket.objTestType[0].Data.Length > 0)
sbSetQuery.Append("AND E.TestType = '" + getPaket.objTestType[0].Data + "' ");
if (getPaket.objTestListFileVersion[0].Data.Length > 0)
sbSetQuery.Append("AND E.Version = '" + getPaket.objTestListFileVersion[0].Data + "' ");
if (getPaket.objProductionCode[0].Data.Length > 0)
sbSetQuery.Append("AND E.ProdCode = '" + getPaket.objProductionCode[0].Data + "' ");
/*
string[] strGetTestListFindInfo = new string[3];
strGetTestListFindInfo[0] = getPaket.objTestType[0].Data;
strGetTestListFindInfo[1] = getPaket.objTestListFileVersion[0].Data;
strGetTestListFindInfo[2] = getPaket.objProductionCode[0].Data;
bool bFirstAppend = false;
int iParameterCnt = 0;
for (int i = 0; i < strGetTestListFindInfo.Length; i++)
{
if (strGetTestListFindInfo[i].Length > 0)
{
iParameterCnt++;
if (bFirstAppend == false)
{
bFirstAppend = true;
sbSetQuery.Append("WHERE ");
}
if (iParameterCnt > 1)
sbSetQuery.Append("AND ");
switch (i)
{
case 0:
sbSetQuery.Append("TestType = '" + strGetTestListFindInfo[i] + "' ");
break;
case 1:
sbSetQuery.Append("Version = '" + strGetTestListFindInfo[i] + "' ");
break;
case 2:
sbSetQuery.Append("ProdCode = '" + strGetTestListFindInfo[i] + "' ");
break;
}
}
}
sbSetQuery.Append(") AS B ");
sbSetQuery.Append("ON B.No = A.TestListNo ");
sbSetQuery.Append("INNER JOIN(SELECT * FROM PROD_Group AS Y) AS C ");
sbSetQuery.Append("ON C.No = B.GroupNo ");
sbSetQuery.Append("INNER JOIN(SELECT* FROM HIST_TestList) AS K ON K.TestListNo = A.TestListNo ");
if (getPaket.objTestCode[0].Data.Length > 0)
sbSetQuery.Append("INNER JOIN(SELECT * FROM STAT_TestCode AS Z WHERE Z.TestCode = '" + getPaket.objTestCode[0].Data + "') AS D ");
else
sbSetQuery.Append("INNER JOIN(SELECT * FROM STAT_TestCode AS Z) AS D ");
sbSetQuery.Append("ON A.ProdNo_C = '" + getPaket.objProdNo_C[0].Data + "' AND B.No = A.TestListNo AND D.No = A.TestCodeNo;");
*/
return sbSetQuery.ToString();
}
public SqlCommand LoginInfoSummaryInsert(
string strHostID,
string strSection,
bool bConnectState)
{
string columns = "TestType,Version,ProdCode,TestListFileNo,TestListVariantNo,StepVersion,HostID,Section,ProdNo_C,ProdNo_P,Testcode,TestListFileName,ProductID,Result,Duration";
string values = string.Join(",", columns.Split(',').Select(c => string.Format("@{0}", c)));
string sqlCommand = string.Format("INSERT INTO [HIST_TesterSummary] ({0}) VALUES ({1})", columns, values);
ParamSet.TesterSummaryField();
SqlCommand cmd = new SqlCommand(sqlCommand);
SqlParameter[] setParams = new SqlParameter[columns.Split(',').Count()];
setParams[0] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestType", "-");
setParams[1] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Version", "-");
setParams[2] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProdCode", "-");
setParams[3] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListFileNo", -1);
setParams[4] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListVariantNo", -1);
setParams[5] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "StepVersion", -1);
setParams[6] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "HostID", strHostID);
setParams[7] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Section", strSection);
setParams[8] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProdNo_C", "-");
setParams[9] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProdNo_P", "-");
setParams[10] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Testcode", "-");
setParams[11] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListFileName", "-");
if (bConnectState)
setParams[12] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProductID", "PowerON");
else
setParams[12] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProductID", "PowerOFF");
setParams[13] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Result", "-");
setParams[14] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Duration", "-");
cmd.Parameters.AddRange(setParams);
return cmd;
}
public SqlCommand QueryTestListInfoSummaryInsert(
//Int64 No,
string strHostID,
string strSection,
string strTestListCntID,
int nResultType,
string strProdNo_C = "-",
string strTestType = "-",
string strVersion = "-",
string strProdCode = "-",
string strTestcode = "-",
int nTestListFileNo = -1,
int nTestListVariantNo = -1,
string strProdNo_P = "-",
string strTestlistFile = "-")
{
string columns = "TestType,Version,ProdCode,TestListFileNo,TestListVariantNo,TestListCntID,StepVersion,HostID,Section,ProdNo_C,ProdNo_P,Testcode,TestListFileName,ProductID,Result,Duration";
string values = string.Join(",", columns.Split(',').Select(c => string.Format("@{0}", c)));
string sqlCommand = string.Format("INSERT INTO [HIST_TesterSummary] ({0}) VALUES ({1})", columns, values);
if (strProdNo_C.Length <= 0) strProdNo_C = "-";
if (strTestType.Length <= 0) strTestType = "-";
if (strVersion.Length <= 0) strVersion = "-";
if (strProdCode.Length <= 0) strProdCode = "-";
if (strTestcode.Length <= 0) strTestcode = "-";
if (strProdNo_P.Length <= 0) strProdNo_P = "-";
if (strTestlistFile.Length <= 0) strTestlistFile = "-";
ParamSet.TesterSummaryField();
SqlCommand cmd = new SqlCommand(sqlCommand);
SqlParameter[] setParams = new SqlParameter[columns.Split(',').Count()];
//setParams[0] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestID", No);
setParams[0] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestType", strTestType);
setParams[1] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Version", strVersion);
setParams[2] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProdCode", strProdCode);
setParams[3] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListFileNo", nTestListFileNo);
setParams[4] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListVariantNo", nTestListVariantNo);
setParams[5] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListCntID", strTestListCntID);
setParams[6] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "StepVersion", -1);
setParams[7] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "HostID", strHostID);
setParams[8] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Section", strSection);
setParams[9] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProdNo_C", strProdNo_C);
setParams[10] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProdNo_P", strProdNo_P);
setParams[11] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Testcode", strTestcode);
setParams[12] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListFileName", strTestlistFile);
setParams[13] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProductID", "QUERY");
switch (nResultType)
{
case 0: setParams[14] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Result", "FAIL"); break;
case 1: setParams[14] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Result", "FIND"); break;
case 2: setParams[14] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Result", "CHECK"); break;
case 3: setParams[14] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Result", "ERROR"); break;
default: setParams[14] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Result", "-"); break;
}
setParams[15] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Duration", "-");
cmd.Parameters.AddRange(setParams);
return cmd;
}
public SqlCommand LogDataSummaryInsert(HISTLogSummary itemSummary)
{
string columns = string.Empty;
if(itemSummary.TestListCntID == string.Empty)
columns = "StationName,TestType,Version,ProdCode,TestListFileNo,TestListVariantNo,StepVersion,HostID,Section,ProdNo_C,ProdNo_P,Testcode,TestListFileName,ProductID,Result,Duration,TestDT";
else
columns = "StationName,TestType,Version,ProdCode,TestListFileNo,TestListVariantNo,TestListCntID,StepVersion,HostID,Section,ProdNo_C,ProdNo_P,Testcode,TestListFileName,ProductID,Result,Duration,TestDT";
string values = string.Join(",", columns.Split(',').Select(c => string.Format("@{0}", c)));
string sqlCommand = string.Format("INSERT INTO [HIST_LogSummary] ({0}) VALUES ({1})", columns, values);
ParamSet.LogSummaryField();
SqlCommand cmd = new SqlCommand(sqlCommand);
SqlParameter[] setParams = new SqlParameter[columns.Split(',').Count()];
if (itemSummary.TestListCntID == string.Empty)
{
setParams[0] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "StationName", itemSummary.StationName);
setParams[1] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestType", itemSummary.TestType);
setParams[2] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Version", itemSummary.Version);
setParams[3] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProdCode", itemSummary.ProdCode);
setParams[4] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListFileNo", itemSummary.TestListFileNo);
setParams[5] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListVariantNo", itemSummary.TestListVariantNo);
setParams[6] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "StepVersion", itemSummary.StepVersion);
setParams[7] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "HostID", itemSummary.Host);
setParams[8] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Section", itemSummary.Section);
setParams[9] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProdNo_C", itemSummary.ProdNoC);
setParams[10] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProdNo_P", itemSummary.ProdNoP);
setParams[11] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Testcode", itemSummary.TestCode);
setParams[12] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListFileName", itemSummary.TestListFileName);
setParams[13] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProductID", itemSummary.ProductID);
setParams[14] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Result", itemSummary.Result);
setParams[15] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Duration", itemSummary.Duration);
setParams[16] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestDT", itemSummary.TestDT);
}
else
{
setParams[0] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "StationName", itemSummary.StationName);
setParams[1] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestType", itemSummary.TestType);
setParams[2] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Version", itemSummary.Version);
setParams[3] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProdCode", itemSummary.ProdCode);
setParams[4] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListFileNo", itemSummary.TestListFileNo);
setParams[5] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListVariantNo", itemSummary.TestListVariantNo);
setParams[6] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListCntID", itemSummary.TestListCntID);
setParams[7] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "StepVersion", itemSummary.StepVersion);
setParams[8] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "HostID", itemSummary.Host);
setParams[9] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Section", itemSummary.Section);
setParams[10] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProdNo_C", itemSummary.ProdNoC);
setParams[11] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProdNo_P", itemSummary.ProdNoP);
setParams[12] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Testcode", itemSummary.TestCode);
setParams[13] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestListFileName", itemSummary.TestListFileName);
setParams[14] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "ProductID", itemSummary.ProductID);
setParams[15] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Result", itemSummary.Result);
setParams[16] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "Duration", itemSummary.Duration);
setParams[17] = ParamSet.GetMakeSqlParameterInfo(ParamSet.fParam, "TestDT", itemSummary.TestDT);
}
cmd.Parameters.AddRange(setParams);
return cmd;
}
}
}

141
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Archive.cs Normal file
View File

@ -0,0 +1,141 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
// 데이터 압축/해제 관련
namespace SystemX.Common.Archive
{
public static class XDataArchive
{
public static byte[] CompressDeflateByteToByte(byte[] ucData)
{
byte[] ucCompressedByte;
using (MemoryStream ms = new MemoryStream())
{
using (DeflateStream ds = new DeflateStream(ms, CompressionMode.Compress))
{
ds.Write(ucData, 0, ucData.Length);
}
ucCompressedByte = ms.ToArray();
}
return ucCompressedByte;
}
public static byte[] CompressGZipByteToByte(byte[] ucData)
{
byte[] ucCompressedByte;
using (MemoryStream ms = new MemoryStream())
{
using (GZipStream gs = new GZipStream(ms, CompressionMode.Compress))
{
gs.Write(ucData, 0, ucData.Length);
}
ucCompressedByte = ms.ToArray();
}
return ucCompressedByte;
}
public static byte[] DecompressDeflateByteToByte(byte[] ucCompressedData)
{
byte[] ucDecompressedByte;
MemoryStream resultStream = new MemoryStream();
using (MemoryStream ms = new MemoryStream(ucCompressedData))
{
using (DeflateStream ds = new DeflateStream(ms, CompressionMode.Decompress))
{
ds.CopyTo(resultStream);
ds.Close();
ucDecompressedByte = resultStream.ToArray();
}
}
return ucDecompressedByte;
}
public static byte[] DecompressGZipByteToByte(byte[] ucCompressedData)
{
byte[] ucDecompressedByte;
MemoryStream resultStream = new MemoryStream();
using (MemoryStream ms = new MemoryStream(ucCompressedData))
{
using (GZipStream gs = new GZipStream(ms, CompressionMode.Decompress))
{
gs.CopyTo(resultStream);
gs.Close();
ucDecompressedByte = resultStream.ToArray();
}
}
return ucDecompressedByte;
}
public static byte[] CompressDatasetToByte(DataSet ds)
{
//1. 데이터셋 Serialize
ds.RemotingFormat = SerializationFormat.Binary;
BinaryFormatter bf = new BinaryFormatter();
MemoryStream ms = new MemoryStream();
bf.Serialize(ms, ds);
byte[] inbyt = ms.ToArray();
//2. 데이터 압축
System.IO.MemoryStream objStream = new MemoryStream();
System.IO.Compression.DeflateStream objZS = new System.IO.
Compression.DeflateStream(objStream, System.IO.Compression.
CompressionMode.Compress);
objZS.Write(inbyt, 0, inbyt.Length);
objZS.Flush();
objZS.Close();
//3. 데이터 리턴
return objStream.ToArray();
}
public static DataSet DecompressByteToDataset(byte[] bytDs)
{
DataSet outDs = new DataSet();
MemoryStream inMs = new MemoryStream(bytDs);
inMs.Seek(0, 0); //스트림으로 가져오기
//1. 압축객체 생성- 압축 풀기
DeflateStream zipStream = new DeflateStream(inMs,
CompressionMode.Decompress, true);
byte[] outByt = ReadFullStreamToByte(zipStream);
zipStream.Flush();
zipStream.Close();
MemoryStream outMs = new MemoryStream(outByt);
outMs.Seek(0, 0); //2. 스트림으로 다시변환
outDs.RemotingFormat = SerializationFormat.Binary;
//3. 데이터셋으로 Deserialize
BinaryFormatter bf = new BinaryFormatter();
outDs = (DataSet)bf.Deserialize(outMs, null);
return outDs;
}
private static byte[] ReadFullStreamToByte(Stream stream)
{
//스트림을 Byte 배열로 변환
byte[] buffer = new byte[1000000];
using (MemoryStream ms = new MemoryStream())
{
while (true)
{
int read = stream.Read(buffer, 0, buffer.Length);
if (read <= 0)
return ms.ToArray();
ms.Write(buffer, 0, read);
}
}
}
}
}

34
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/DataTableQuery.cs Normal file
View File

@ -0,0 +1,34 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.Net.Platform.Common
{
public static class DataTableQuery
{
public static List<DataRow> FindDataRow(DataTable dtTable, string strKeyName, string strFindingValue)
{
List<DataRow> adrResult = (from dtRow in dtTable.AsEnumerable() where dtRow[strKeyName].ToString() == strFindingValue select dtRow).ToList();
return adrResult;
}
public static int GetDataRowHandle(DataTable dtTable, string strKeyFieldName, string strComparingValue)
{
int nIdx = 0;
foreach (DataRow dtRow in dtTable.AsEnumerable())
{
if (dtRow[strKeyFieldName].ToString() == strComparingValue)
return nIdx;
nIdx++;
}
return -1;
}
}
}

158
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Event/EventBase.cs Normal file
View File

@ -0,0 +1,158 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Runtime.InteropServices;
using System.Windows.Forms;
namespace SystemX.Net.Platform.Common.Event
{
public interface ISysXEventField : ISynchronizeInvoke
{
void ProcessEvent(IObservableEvent evt);
}
public class OSCAREventHandler : ISubscribable
{
public Subject<IObservableEvent> ApplicationSubject = new Subject<IObservableEvent>();
protected List<IDisposable> _applicationSubscriptions = new List<IDisposable>();
public ISysXEventField TheApplicationTarget { get; set; }
public static OSCAREventHandler TheApplication { get; private set; }
public OSCAREventHandler(ISysXEventField eventField)
{
Contract.Requires(eventField is Form);
Contract.Requires(TheApplication == null);
TheApplication = this;
TheApplicationTarget = eventField;
var observable = Observable
.Interval(TimeSpan.FromSeconds(1))
.Take(5);
var observer = System.Reactive.Observer.Create<long>(
x => Console.WriteLine("Value published to subject #1: {0}", x),
() => Console.WriteLine("Sequence Completed."));
AddSubscription(ApplicationSubject.Subscribe(evt => OnApplicationEvent(evt)));
}
/// <summary>
/// Applicatino event 처리.
/// Note: ObservableEventTask{Starting, Finished} 는 별도 subscription 을 통해서 처리 됨.
/// </summary>
/// <param name="evt"></param>
private void OnApplicationEvent(IObservableEvent evt)
{
// 샘플 코드
bool onMainThread = !TheApplicationTarget.InvokeRequired;
//System.Media.SystemSounds.Beep.Play();
// thread 상에서 호출되었다면, main UI thread 상에서 수행되도록 한다.
//TheApplicationForm.Do(() =>
//{
//logger.Info($"Application got event : {evt}");
//((IOSCAREventField)TheApplicationForm).HandleStationEvent(evt);
ProcessObservableEventHandler(evt);
//});
}
protected delegate void ObservableEventHandler(IObservableEvent evt);
private void ProcessObservableEventHandler(IObservableEvent evt)
{
if (TheApplicationTarget.InvokeRequired)
{
ObservableEventHandler delState = new ObservableEventHandler(ProcessObservableEventHandler);
(TheApplicationTarget as Control).Invoke(delState, evt);
}
else
{
TheApplicationTarget.ProcessEvent(evt);
}
}
public void AddSubscription(IDisposable subscription)
{
_applicationSubscriptions.Add(subscription);
}
public void Dispose()
{
Dispose(true); // true : 명시적 dispose 호출
GC.SuppressFinalize(this); // 사용자에 의해서 명시적으로 dispose 되었으므로, GC 는 이 객체에 대해서 손대지 말것을 알림.
}
private bool _disposed;
protected virtual void Dispose(bool disposing)
{
if (_disposed)
return;
if (disposing)
{
// AwaitTermination() call hangs. Need to check Akka document.
// CommonApplication.ActorSystem.AwaitTermination();
_applicationSubscriptions.ForEach(s => s.Dispose());
}
_disposed = true;
}
}
public class TestEvent : IObservableEvent
{
public string Process { private set; get; }
public string Path { set; get; }
public TestEvent(string process, string strPath)
{
Process = process;
Path = strPath;
}
}
/// <summary>
/// Rx event 에 대한 subscribe 가 가능한 객체가 구현해야 할 interface
/// Dispose 시에 모든 subscription 을 dispose 해야 한다.
/// </summary>
public interface ISubscribable : IDisposable
{
/* Usage sample
private List<IDisposable> _subscriptions = new List<IDisposable>();
public void AddSubscription(IDisposable subscription) { _subscriptions.Add(subscription); }
// Requires disposal of subscriptions on Dispose() method
*
*/
void AddSubscription(IDisposable subscription);
}
/// <summary> Configuration interface </summary>
[Guid("8501C86A-61E7-4F92-B90A-1779CCF6AAF3")]
[InterfaceType(ComInterfaceType.InterfaceIsDual)]
[ComVisible(true)]
public interface IConfiguration : ICloneable
{
/// <summary> Save configuration to file </summary>
void QSave(string fileName);
/// <summary> Load configuration from file </summary>
void QLoad(string fileName);
}
/// <summary>
/// Rx: System.Reactive.Subjects.Subject 에 대한 base interface
/// </summary>
[ComVisible(false)]
public interface IObservableEvent
{
}
public interface IObservableUIEvent : IObservableEvent { }
}

22
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Event/FuncEventHandler.cs Normal file
View File

@ -0,0 +1,22 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.Net.Platform.Common.Event
{
public class FunctionEventHandler
{
public FunctionEventHandler() { }
public delegate void evtReceiveHandler(object sender, object data);
public event evtReceiveHandler OnReceive;
public void DoReceive(object sender, object data)
{
if (OnReceive != null)
OnReceive(sender, data);
}
}
}

63
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Event/PauseToken.cs Normal file
View File

@ -0,0 +1,63 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace SystemX.Net.Platform.Common.Event
{
public class PauseTokenSource
{
private volatile TaskCompletionSource<bool> m_paused;
internal static readonly Task s_completedTask = Task.FromResult(true);
public void Pause()
{
Interlocked.CompareExchange(
ref m_paused, new TaskCompletionSource<bool>(), null);
}
public void Resume()
{
while (true)
{
var tcs = m_paused;
if (tcs == null) return;
if (Interlocked.CompareExchange(ref m_paused, null, tcs) == tcs)
{
tcs.SetResult(true);
break;
}
}
}
public bool IsPaused
{
get { return m_paused != null; }
}
public PauseToken Token { get { return new PauseToken(this); } }
internal Task WaitWhilePausedAsync()
{
var cur = m_paused;
return cur != null ? cur.Task : s_completedTask;
}
}
public struct PauseToken
{
private readonly PauseTokenSource m_source;
internal PauseToken(PauseTokenSource source) { m_source = source; }
public bool IsPaused { get { return m_source != null && m_source.IsPaused; } }
public Task WaitWhilePausedAsync()
{
return IsPaused ?
m_source.WaitWhilePausedAsync() :
PauseTokenSource.s_completedTask;
}
}
}

153
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Extension/EmAsync.cs Normal file
View File

@ -0,0 +1,153 @@
using System;
using System.Threading;
using System.Threading.Tasks;
namespace SystemX.Net.Platform.Common.ExtensionMethods
{
public static class EmAsync
{
public static TResult WaitResultAsyncFunction<TResult>(this Func<Task<TResult>> function)
{
var task = Task.Run(() => function());
task.Wait();
return task.Result;
}
public static void WaitAsyncFunction(this Func<Task> function)
{
function().Wait();
}
//private static Action WrapExceptionSafe(this Action action, Action<Exception> exceptionHandler)
//{
// return new Action(() =>
// {
// try
// {
// action();
// }
// catch (Exception ex)
// {
// if (exceptionHandler == null)
// {
// if ( FormAppCommon.UISynchronizationContext == null )
// MessageBox.Show(ex.Message, "Exception occurred!", MessageBoxButtons.OK, MessageBoxIcon.Error);
// else
// FormAppCommon.UISynchronizationContext.Send(ignore => UnhandledExceptionHandler.ShowUnhandledException(ex), null);
// }
// else
// exceptionHandler(ex);
// }
// });
//}
//public static Func<Task<T>> WrapExceptionSafe<T>(this Func<Task<T>> function, Action<Exception> exceptionHandler)
//{
// return new Func<Task<T>>(() =>
// {
// try
// {
// return function();
// }
// catch (Exception ex)
// {
// if (exceptionHandler == null)
// {
// if (FormAppCommon.UISynchronizationContext == null)
// MessageBox.Show(ex.Message, "Exception occurred!", MessageBoxButtons.OK, MessageBoxIcon.Error);
// else
// FormAppCommon.UISynchronizationContext.Send(ignore => UnhandledExceptionHandler.ShowUnhandledException(ex), null);
// }
// else
// exceptionHandler(ex);
// return null;
// }
// });
//}
///// <summary>
///// 단순히 Task.Run(()=>{}) 수행시, exception 을 catch 할수 없으므로, 다음 extension 을 사용해서 해결함
///// </summary>
///// <param name="action"></param>
///// <param name="exceptionHandler"></param>
//public static Task ExceptionSafeTaskRun(this Action action, Action<Exception> exceptionHandler=null)
//{
// return Task.Run(WrapExceptionSafe(action, exceptionHandler));
//}
//public static Task<T> ExceptionSafeTaskRun<T>(this Func<Task<T>> function, Action<Exception> exceptionHandler=null)
//{
// return Task.Run(WrapExceptionSafe(function, exceptionHandler));
//}
//private static void HandleException(this Task task)
//{
// var ex = task.Exception;
// if (ex != null)
// {
// System.Diagnostics.Trace.WriteLine(ex.ToString());
// Globals.Logger?.Error(ex.ToString());
// }
//}
///// <summary>
///// Disabling CS4014
///// http://stackoverflow.com/questions/22629951/suppressing-warning-cs4014-because-this-call-is-not-awaited-execution-of-the
///// warning CS4014: Because this call is not awaited, execution of the current method continues before the call is completed.
///// Consider applying the 'await' operator to the result of the call.
///// </summary>
///// <param name="task"></param>
//public static void Forget(this Task task)
//{
// // Async in C# 5.0, pp.57
// // Task 를 실행만 하고, await 하지 않는 fire & forget 모델에서, exception 이 발생하였을 경우를 체크 하기 위한 용도.
// task.ContinueWith(ant => HandleException(ant));
//}
/// <summary>
/// http://stackoverflow.com/questions/2565166/net-best-way-to-execute-a-lambda-on-ui-thread-after-a-delay
/// </summary>
/// Usage
/// <code>
/// SynchronizationContext.Current.Post(TimeSpan.FromSeconds(1), () => textBlock.Text="Done");
/// </code>
public static void Post(this SynchronizationContext context, TimeSpan delay, Action action)
{
System.Threading.Timer timer = null;
timer = new System.Threading.Timer((ignore) =>
{
timer.Dispose();
context.Post(ignore2 => action(), null);
}, null, delay, TimeSpan.FromMilliseconds(-1));
}
/// <summary>
/// Executes action after delay.
/// C# 5.0 in a Nutshell, pp. 573
/// </summary>
/// <param name="action"></param>
/// <param name="delayMillisec"></param>
/// <returns></returns>
public static Task ExecuteWithDelay(this Action action, int delayMillisec)
{
return Task.Delay(delayMillisec).ContinueWith(ant => action);
}
/// <summary>
/// pp.20. Concurrency in C# Cookbook
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value"></param>
/// <returns></returns>
public static Task<T> FromResult<T>(this T value)
{
return Task.FromResult(value);
}
}
}

161
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Extension/EmBitmap.cs Normal file
View File

@ -0,0 +1,161 @@
using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
namespace SystemX.Net.Platform.Common.ExtensionMethods
{
/// <summary>
///
/// </summary>
/// http://stackoverflow.com/questions/2368757/easy-way-to-convert-a-bitmap-and-png-image-to-text-and-vice-versa
/// http://www.developerfusion.com/thread/47978/how-can-i-convert-image-type-to-bitmap-type-in-cnet/
/// http://stackoverflow.com/questions/10442269/scaling-a-system-drawing-bitmap-to-a-given-size-while-maintaining-aspect-ratio
public static class EmBitmap
{
public static string EncodeToString(this Bitmap bitmap)
{
if ( bitmap == null )
return String.Empty;
MemoryStream memoryStream = new MemoryStream();
bitmap.Save(memoryStream, ImageFormat.Png);
byte[] bitmapBytes = memoryStream.GetBuffer();
return Convert.ToBase64String(bitmapBytes, Base64FormattingOptions.InsertLineBreaks);
}
public static Bitmap FromEncodedString(string bitmapString)
{
byte[] bitmapBytes = Convert.FromBase64String(bitmapString);
MemoryStream memoryStream = new MemoryStream(bitmapBytes);
return new Bitmap(Image.FromStream(memoryStream));
}
public static Bitmap Resize(this Bitmap bitmap, int width)
{
double height = width * ((double)bitmap.Height / bitmap.Width);
return new Bitmap(bitmap, new Size(width, (int)height));
}
public static Icon ToIcon(this Bitmap bitmap)
{
return Icon.FromHandle(bitmap.GetHicon());
}
public static Bitmap ToBitmap(this Image image)
{
return (Bitmap) image;
}
public static Icon ToIcon(this Image image)
{
return Icon.FromHandle(((Bitmap)image).GetHicon());
}
}
public class ImageHelper
{
#region CropUnwantedBackground
public static Bitmap CropUnwantedBackground(Bitmap bmp)
{
var backColor = GetMatchedBackColor(bmp);
if (backColor.HasValue)
{
var bounds = GetImageBounds(bmp, backColor);
var diffX = bounds[1].X - bounds[0].X + 1;
var diffY = bounds[1].Y - bounds[0].Y + 1;
var croppedBmp = new Bitmap(diffX, diffY);
var g = Graphics.FromImage(croppedBmp);
var destRect = new Rectangle(0, 0, croppedBmp.Width, croppedBmp.Height);
var srcRect = new Rectangle(bounds[0].X, bounds[0].Y, diffX, diffY);
g.DrawImage(bmp, destRect, srcRect, GraphicsUnit.Pixel);
return croppedBmp;
}
else
{
return null;
}
}
#endregion
#region Private Methods
#region GetImageBounds
private static Point[] GetImageBounds(Bitmap bmp, Color? backColor)
{
//--------------------------------------------------------------------
// Finding the Bounds of Crop Area bu using Unsafe Code and Image Proccesing
Color c;
int width = bmp.Width, height = bmp.Height;
bool upperLeftPointFounded = false;
var bounds = new Point[2];
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
c = bmp.GetPixel(x, y);
bool sameAsBackColor = ((c.R <= backColor.Value.R * 1.1 && c.R >= backColor.Value.R * 0.9) &&
(c.G <= backColor.Value.G * 1.1 && c.G >= backColor.Value.G * 0.9) &&
(c.B <= backColor.Value.B * 1.1 && c.B >= backColor.Value.B * 0.9));
if (!sameAsBackColor)
{
if (!upperLeftPointFounded)
{
bounds[0] = new Point(x, y);
bounds[1] = new Point(x, y);
upperLeftPointFounded = true;
}
else
{
if (x > bounds[1].X)
bounds[1].X = x;
else if (x < bounds[0].X)
bounds[0].X = x;
if (y >= bounds[1].Y)
bounds[1].Y = y;
}
}
}
}
return bounds;
}
#endregion
#region GetMatchedBackColor
private static Color? GetMatchedBackColor(Bitmap bmp)
{
// Getting The Background Color by checking Corners of Original Image
var corners = new Point[]{
new Point(0, 0),
new Point(0, bmp.Height - 1),
new Point(bmp.Width - 1, 0),
new Point(bmp.Width - 1, bmp.Height - 1)
}; // four corners (Top, Left), (Top, Right), (Bottom, Left), (Bottom, Right)
for (int i = 0; i < 4; i++)
{
var cornerMatched = 0;
var backColor = bmp.GetPixel(corners[i].X, corners[i].Y);
for (int j = 0; j < 4; j++)
{
var cornerColor = bmp.GetPixel(corners[j].X, corners[j].Y);// Check RGB with some offset
if ((cornerColor.R <= backColor.R * 1.1 && cornerColor.R >= backColor.R * 0.9) &&
(cornerColor.G <= backColor.G * 1.1 && cornerColor.G >= backColor.G * 0.9) &&
(cornerColor.B <= backColor.B * 1.1 && cornerColor.B >= backColor.B * 0.9))
{
cornerMatched++;
}
}
if (cornerMatched > 2)
{
return backColor;
}
}
return null;
}
#endregion
#endregion
}
}

75
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Extension/EmComparable.cs Normal file
View File

@ -0,0 +1,75 @@
using System;
using System.Diagnostics.Contracts;
using System.Linq;
namespace SystemX.Net.Platform.Common.ExtensionMethods
{
public static class EmComparable
{
/// <summary>
/// [min, max]
/// value 값이 from, to 사이에 존재하는지를 검사한다.
/// http://stackoverflow.com/questions/8776624/if-value-in-rangex-y-function-c-sharp
/// </summary>
[Pure]
public static bool InClosedRange<T>(this T val, T min, T max) where T : IComparable<T>
{
Contract.Requires(min.CompareTo(max) <= 0);
return min.CompareTo(val) <= 0 && val.CompareTo(max) <= 0;
}
[Pure]
public static bool InRange<T>(this T val, T min, T max) where T : IComparable<T>
{
return val.InClosedRange(min, max);
}
/// <summary> [min, max) </summary>
[Pure]
public static bool InClampRange<T>(this T val, T min, T max) where T : IComparable<T>
{
Contract.Requires(min.CompareTo(max) <= 0);
return min.CompareTo(val) <= 0 && val.CompareTo(max) < 0;
}
/// <summary> (min, max) </summary>
[Pure]
public static bool InOpenRange<T>(this T val, T min, T max) where T : IComparable<T>
{
Contract.Requires(min.CompareTo(max) <= 0);
return min.CompareTo(val) < 0 && val.CompareTo(max) < 0;
}
[Pure]
public static bool EpsilonEqual(this double value1, double value2, double epsilon = Double.Epsilon)
{
return Math.Abs(value1 - value2) < epsilon;
}
[Pure]
public static bool EpsilonEqual(this float value1, float value2, float epsilon = Single.Epsilon)
{
return Math.Abs(value1 - value2) < epsilon;
}
/// <summary> Key 값이 set 에 포함되는지 여부를 검사한다. </summary>
[Pure]
public static bool IsOneOf(this IComparable key, params IComparable[] set)
{
return set.Any(e => e.CompareTo(key) == 0);
}
public static bool IsOneOf(this object key, params object[] set)
{
return set.Any(e => e == key);
}
public static bool IsOneOf(this Type type, params Type[] set)
{
return set.Any(t => t.IsAssignableFrom(type));
}
}
}

427
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Extension/EmControl.cs Normal file
View File

@ -0,0 +1,427 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Runtime.InteropServices;
namespace SystemX.Net.Platform.Common.ExtensionMethods
{
/// <summary>
/// http://lostechies.com/derickbailey/2011/01/24/asynchronous-control-updates-in-c-net-winforms/
/// </summary>
public static class EmControl
{
public static void Do<TControl>(this TControl control, Action<TControl> action)
where TControl : Control
{
try
{
if (control.InvokeRequired)
{
try
{
control.Invoke(action, control);
}
catch (Exception ex)
{
if (ex is ObjectDisposedException)
Trace.WriteLine(ex);
else
throw;
}
}
else if (control.IsHandleCreated)
action(control);
else
{
Console.WriteLine("Error : Before windows handle created.. 창 핸들을 만들기 전까지는....");
Trace.WriteLine("Error : Before windows handle created.. 창 핸들을 만들기 전까지는....");
}
}
catch (Exception ex)
{
Trace.WriteLine($"Exception on Control.Do(): {ex}");
}
}
/// <summary>
/// Control.Invoke is synchronous
/// </summary>
/// <param name="control"></param>
/// <param name="action"></param>
public static void Do(this Control control, Action action)
{
try
{
if (control.InvokeRequired)
{
try
{
control.Invoke(action);
}
catch (Exception ex)
{
if (ex is ObjectDisposedException)
Trace.WriteLine(ex);
else
throw;
}
}
else if (control.IsHandleCreated)
action();
else
{
Console.WriteLine("Error : Before windows handle created (2).. 창 핸들을 만들기 전까지는....");
Trace.WriteLine("Error : Before windows handle created (2).. 창 핸들을 만들기 전까지는....");
}
}
catch (Exception ex)
{
Trace.WriteLine($"Exception on Control.Do(): {ex}");
}
}
public static void Do(this SynchronizationContext context, Action action)
{
context.Send(ignore => { action(); }, null);
}
public static void DoAsync(this SynchronizationContext context, Action action)
{
context.Post(ignore => { action(); }, null);
}
public static SynchronizationContext GetSynchronizationContext(this Control control)
{
SynchronizationContext context = null;
control.Do(() =>
{
context = SynchronizationContext.Current;
});
return context;
}
public static TaskScheduler GetTaskScheduler(this Control control)
{
TaskScheduler scheduler = null;
control.Do(() =>
{
scheduler = TaskScheduler.FromCurrentSynchronizationContext();
});
return scheduler;
}
/// <summary>
/// form 에 대해서, 아직 창 핸들이 만들어 지지 않은 경우, form 이 보여진 후에 해당 action 을 수행한다.
/// </summary>
/// <param name="form"></param>
/// <param name="action"></param>
public static void DoNowOrLater(this Form form, Action action)
{
if (form.InvokeRequired)
form.Invoke(action);
else if (form.IsHandleCreated)
action();
else
form.Shown += (sender, args) => { action(); };
}
public static async Task DoAsync(this Control control, Action action)
{
try
{
if (control.InvokeRequired)
await Task.Factory.FromAsync(control.BeginInvoke(action), result => { });
else if (control.IsHandleCreated)
action();
else
Console.WriteLine("Error : 창 핸들을 만들기 전까지는....");
}
catch (Exception ex)
{
Trace.WriteLine($"Exception on Control.Do(): {ex}");
}
}
/// <summary>
/// How to get return value when BeginInvoke/Invoke is called in C#
/// http://stackoverflow.com/questions/2214002/how-to-get-return-value-when-begininvoke-invoke-is-called-in-c-sharp
/// </summary>
public static T DoGet<T>(this Control control, Func<T> func)
{
if (control.InvokeRequired)
return (T)control.Invoke(func);
return func();
}
public static IEnumerable<Control> CollectAncestors(this Control control, bool includeMe = false)
{
if (includeMe)
yield return control;
if (control == null || control.Parent == null)
yield break;
foreach (var ancestor in control.Parent.CollectAncestors(true))
yield return ancestor;
}
public static IEnumerable<Control> CollectAncestorsTo(this Control control, Control stopAncestorControl,
bool includeMe = false)
{
if (includeMe)
yield return control;
if (control == stopAncestorControl || control.Parent == null)
yield break;
foreach (var ancestor in control.Parent.CollectAncestorsTo(stopAncestorControl, true))
yield return ancestor;
}
public static IEnumerable<Control> CollectChildren(this Control control, bool includeMe = false)
{
if (includeMe)
yield return control;
foreach (var child in control.Controls.Cast<Control>())
{
foreach (var descendant in child.CollectChildren(true))
yield return descendant;
}
if (control is TabControl)
{
var tab = (TabControl) control;
foreach (var page in tab.TabPages.Cast<TabPage>())
{
foreach (var descendant in page.CollectChildren(true))
{
yield return descendant;
}
}
}
}
public static IEnumerable<T> CollectChildren<T>(this Control control, bool includeMe = false) where T : Control
{
return control.CollectChildren(includeMe).OfType<T>();
//if (includeMe && control is T)
// yield return control as T;
//foreach (var child in control.Controls.Cast<Control>())
//{
// foreach (var descendant in child.CollectChildren<T>(true))
// yield return descendant;
//}
//if (control is TabControl)
//{
// var tab = (TabControl)control;
// foreach (var page in tab.TabPages.Cast<TabPage>())
// {
// foreach (var descendant in page.CollectChildren<T>(true))
// {
// yield return descendant;
// }
// }
//}
}
/// <summary>
/// reference 의 LT 좌표 기준으로, control 의 LT 좌표의 offset 값을 반환한다.
/// </summary>
/// <param name="control"></param>
/// <param name="reference"></param>
/// <returns></returns>
public static Point GetRelativePoint(this Control control, Control reference)
{
return reference.PointToClient(control.PointToScreen(control.Location));
}
public static Rectangle GetRelativeRectangle(this Control control, Control reference)
{
return reference.RectangleToClient(control.RectangleToScreen(control.ClientRectangle));
}
public static void SetBackgroundImage(this Control control, Image image)
{
if (control.BackgroundImage != null)
control.BackgroundImage.Dispose();
control.BackgroundImage = image;
}
public static void MakeTransparent(this Control control)
{
try
{
if (control is Button)
((Button) control).FlatStyle = FlatStyle.Flat;
control.ForceMakeTransparent();
control.BackColor = Color.Transparent;
}
catch (Exception)
{
}
}
/// <summary>
/// http://solvedstack.com/questions/transparency-for-windows-forms-textbox
/// <c>
/// bool itWorked = SetStyle(xControl, ControlStyles.SupportsTransparentBackColor, true);
/// </c>
/// </summary>
/// <param name="control"></param>
/// <param name="style"></param>
/// <param name="value"></param>
/// <returns></returns>
public static bool ForceSetStyle(this Control control, ControlStyles style, bool value)
{
Type typeTB = typeof (Control);
System.Reflection.MethodInfo misSetStyle = typeTB.GetMethod("SetStyle",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
if (misSetStyle != null && control != null)
{
misSetStyle.Invoke(control, new object[] {style, value});
return true;
}
return false;
}
public static bool ForceMakeTransparent(this Control control, bool transparent = true)
{
return control.ForceSetStyle(ControlStyles.SupportsTransparentBackColor, transparent);
}
/// <summary>
/// http://stackoverflow.com/questions/435433/what-is-the-preferred-way-to-find-focused-control-in-winforms-app
/// </summary>
/// <param name="control"></param>
/// <returns></returns>
public static Control FindFocusedControl(this Control control)
{
var container = control as IContainerControl;
while (container != null)
{
control = container.ActiveControl;
container = control as IContainerControl;
}
return control;
}
// http://stackoverflow.com/questions/4747935/c-sharp-winform-check-if-control-is-physicaly-visible
[DllImport("user32.dll")]
static extern IntPtr WindowFromPoint(POINT Point);
[StructLayout(LayoutKind.Sequential)]
public struct POINT
{
public int X;
public int Y;
public POINT(int x, int y) { X = x; Y = y; }
public static implicit operator Point(POINT p) => new Point(p.X, p.Y);
public static implicit operator POINT(Point p) => new POINT(p.X, p.Y);
}
/// control 이 실제로 사용자에게 보이는지 여부를 반환
public static bool IsControlVisibleToUser(this Control control)
{
return control.DoGet(() =>
{
if (!control.IsHandleCreated)
return false;
var pos = control.PointToScreen(control.Location);
var pointsToCheck = new POINT[] {
pos,
new Point(pos.X + control.Width - 1, pos.Y),
new Point(pos.X, pos.Y + control.Height - 1),
new Point(pos.X + control.Width - 1, pos.Y + control.Height - 1),
new Point(pos.X + control.Width/2, pos.Y + control.Height/2),
};
foreach (var p in pointsToCheck)
{
var hwnd = WindowFromPoint(p);
var other = Control.FromChildHandle(hwnd);
if (other == null)
continue;
if (control == other || control.Contains(other))
return true;
}
return false;
});
}
#region Detect cursor
//// http://stackoverflow.com/questions/586479/is-there-a-quick-way-to-get-the-control-thats-under-the-mouse
//[DllImport("user32.dll")]
//private static extern IntPtr WindowFromPoint(Point pnt);
//public static Control ControlUnderPoint(this Point pt)
//{
// IntPtr hWnd = WindowFromPoint(pt);
// if (hWnd != IntPtr.Zero)
// return Control.FromHandle(hWnd);
// return null;
//}
//public static Control ControlUnderMouseCursor()
//{
// return Control.MousePosition.ControlUnderPoint();
//}
/// <summary> Checks whether mouse is over given control </summary>
public static bool IsMouseOver(this Control control)
{
return control.ClientRectangle.Contains(control.PointToClient(Cursor.Position));
}
/// <summary> Collects controls under mouse cursor </summary>
public static IEnumerable<Control> GetChildrenUnderMouse(this Control parent)
{
foreach (var c in parent.Controls.Cast<Control>())
{
if (c.IsMouseOver())
yield return c;
foreach (var cc in GetChildrenUnderMouse(c))
yield return cc;
}
}
#endregion
/// Button 에 image 를 입힌다. text 는 왼쪽, image 는 오른쪽
public static void AddImage(this Button button, Image image)
{
button.Image = image;
button.ImageAlign = ContentAlignment.MiddleRight;
button.TextAlign = ContentAlignment.MiddleLeft;
}
}
}

21
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Extension/EmEventHandler.cs Normal file
View File

@ -0,0 +1,21 @@
using System;
namespace SystemX.Net.Platform.Common.ExtensionMethods
{
public static class EmEventHandler
{
public static void Handle(this EventHandler eventHandler, object sender, EventArgs eventArgs)
{
var handler = eventHandler;
if (handler != null)
handler(sender, eventArgs);
}
public static void Handle<T>(this EventHandler<T> eventHandler, object sender, T eventArgs)
{
var handler = eventHandler;
if ( handler != null )
handler(sender, eventArgs);
}
}
}

133
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Extension/EmGeneral.cs Normal file
View File

@ -0,0 +1,133 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Reflection;
using System.Windows.Forms;
namespace SystemX.Net.Platform.Common.ExtensionMethods
{
public static class EmGeneral
{
/// <summary>Indicates whether the specified array is null or has a length of zero.</summary>
/// <param name="array">The array to test.</param>
/// <returns>true if the array parameter is null or has a length of zero; otherwise, false.</returns>
[Pure]
public static bool IsNullOrEmpty(this Array array)
{
return (array == null || array.Length == 0);
}
[Pure]
public static bool IsNullOrEmpty(this IEnumerable enumerable)
{
return (enumerable == null || enumerable.Cast<object>().Count() == 0);
}
[Pure]
public static bool NonNullAny<TSource>(this IEnumerable<TSource> source)
{
if (source == null)
return false;
return source.Any();
}
[Pure]
public static bool NonNullAny<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
if (source == null)
return false;
return source.Any(predicate);
}
[Pure]
public static int Clamp(this int val, int min, int max)
{
return val > max ? max : val < min ? min : val;
}
public static double Clamp(this double val, double min, double max)
{
return val > max ? max : val < min ? min : val;
}
[Pure]
public static bool XOR(this bool val1, bool val2)
{
return (val1 && !val2) || (!val1 && val2);
}
[Pure]
public static bool XOR(this object obj1, object obj2)
{
return (obj1 != null && obj2 == null) || (obj1 == null && obj2 != null);
}
[Pure]
public static bool Toggle(this bool fact, bool toggle)
{
return toggle ? ! fact : fact;
}
[Pure]
public static string NonNullEmptySelector(this string str1, string str2)
{
return String.IsNullOrEmpty(str1) ? str2 : str1;
}
[Pure]
public static bool NonNullEqual(this string str1, string str2)
{
return !String.IsNullOrEmpty(str1) && !String.IsNullOrEmpty(str2) && str1 == str2;
}
[Pure]
public static bool NullableEqual(this string str1, string str2)
{
return (str1.IsNullOrEmpty() && str2.IsNullOrEmpty()) || NonNullEqual(str1, str2);
}
public static bool HasTrueValue(this Nullable<bool> nullable)
{
return nullable.HasValue && nullable.Value;
}
}
/// <summary>
/// http://stackoverflow.com/questions/12447156/how-can-i-set-the-column-width-of-a-property-grid
/// </summary>
public static class PropertyGridColumnWidthSetter
{
public static void SetLabelColumnWidth(this PropertyGrid grid, int width)
{
if (grid == null)
return;
FieldInfo fi = grid.GetType().GetField("gridView", BindingFlags.Instance | BindingFlags.NonPublic);
if (fi == null)
return;
Control view = fi.GetValue(grid) as Control;
if (view == null)
return;
MethodInfo mi = view.GetType().GetMethod("MoveSplitterTo", BindingFlags.Instance | BindingFlags.NonPublic);
if (mi == null)
return;
mi.Invoke(view, new object[] {width});
}
}
}

374
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Extension/EmLinq.cs Normal file
View File

@ -0,0 +1,374 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
namespace SystemX.Net.Platform.Common.ExtensionMethods
{
/// <summary>
/// Linq extension methods
/// </summary>
public static partial class EmLinq
{
// http://stackoverflow.com/questions/1883920/call-a-function-for-each-value-in-a-generic-c-sharp-collection
/// <summary>
/// Generic IEnumerable ForEach extension : typename T is optional. deducible from source
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="action"></param>
public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
{
foreach (T item in source)
action(item);
}
public static void Iter<T>(this IEnumerable<T> source, Action<T> action) => ForEach(source, action);
public static void Iter<T>(this IEnumerable<T> source, Action<T, int> action)
{
int i = 0;
foreach (T item in source)
action(item, i++);
}
/// <summary>
/// Lazy Foreach : Not evaluated until on demand
/// </summary>
public static IEnumerable<T> ForEachTee<T>(this IEnumerable<T> source, Action<T> action)
{
foreach (T item in source)
{
action(item);
yield return item;
}
}
/// <summary>
/// Non-Generic IEnumerable ForEach extension : typename T should be provided.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="action"></param>
public static void ForEach<T>(this IEnumerable source, Action<T> action)
{
foreach (T item in source)
action(item);
}
/// <summary>
/// Non-Generic IEnumerable ForEach extension : typename T should be provided.
/// Lazy Foreach : Not evaluated until on demand
/// </summary>
public static IEnumerable ForEachTee<T>(this IEnumerable source, Action<T> action)
{
foreach (T item in source)
{
action(item);
yield return item;
}
}
/// <summary>
/// Non-Generic IEnumerable Select extension : typename T should be provided.
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="source"></param>
/// <param name="selector"></param>
/// <returns></returns>
public static IEnumerable<TResult> SelectEx<TSource, TResult>(this IEnumerable source, Func<TSource, TResult> selector)
{
foreach (TSource item in source)
yield return selector(item);
}
/// <summary>
/// TResult type 의 enumerable 중에서 TNotCheckType type 이 아닌 것들만 골라서 반환한다. (System.Linq.OfType 의 negation)
/// <para/> System.Linq.SkipWhile() 구문과 같은 역할
/// <para/> TNotCheck 는 TResult type 이어야 함.
/// </summary>
/// <typeparam name="TResult">enumerable 들의 base type. 동시에 반환될 enumerable 의 type</typeparam>
/// <typeparam name="TNotCheckType">제외할 type</typeparam>
/// <param name="source"></param>
/// <returns></returns>
public static IEnumerable<TResult> OfNotType<TResult, TNotCheckType>(this IEnumerable source) where TNotCheckType : TResult
{
if (source == null) throw new ArgumentNullException("source");
return OfNotTypeIterator<TResult, TNotCheckType>(source);
}
private static IEnumerable<TResult> OfNotTypeIterator<TResult, TNotCheckType>(IEnumerable source)
{
foreach (object obj in source)
{
if (!(obj is TNotCheckType))
yield return (TResult)obj;
}
}
/// <summary>
/// Select Non null element from enumerable
/// </summary>
public static IEnumerable<TResult> OfNotNull<TResult>(this IEnumerable<TResult> source) where TResult : class
{
if (source == null) throw new ArgumentNullException("source");
foreach (var s in source)
{
if ( s != null )
yield return s;
}
}
// http://stackoverflow.com/questions/2471588/how-to-get-index-using-linq
public static Nullable<int> FindIndex<T>(this IEnumerable<T> items, Predicate<T> predicate)
{
int index = 0;
foreach (var item in items)
{
if (predicate(item))
return index;
index++;
}
return null;
}
public static HashSet<T> ToHashSet<T>(this IEnumerable<T> items)
{
var hash = new HashSet<T>();
items.ForEach(i => hash.Add(i));
return hash;
}
/// <summary>
/// 두개의 set 이 동일한지 비교. see SequenceEqual
/// </summary>
public static bool SetEqual<T>(this IEnumerable<T> first, IEnumerable<T> second)
{
HashSet<T> firstSet = first.ToHashSet();
foreach (var e in second)
{
if (!firstSet.Contains(e))
return false;
}
HashSet<T> secondSet = second.ToHashSet();
foreach (var e in first)
{
if (!secondSet.Contains(e))
return false;
}
return true;
}
public static bool RemoveTail(this IList list)
{
if (list.IsNullOrEmpty())
return false;
list.RemoveAt(list.Count - 1);
return true;
}
public static T[] ConcatArrays<T>(params T[][] list)
{
var result = new T[list.Sum(a => a.Length)];
int offset = 0;
for (int x = 0; x < list.Length; x++)
{
list[x].CopyTo(result, offset);
offset += list[x].Length;
}
return result;
}
private static Tuple<bool, T> ExtractFirst<T>(this IEnumerable<T> seq)
{
using (var enumerator = seq.GetEnumerator())
{
if (enumerator.MoveNext())
return Tuple.Create(true, enumerator.Current); // => return new Tuple<bool, T>(..) 와 동일
return Tuple.Create(false, default(T));
}
}
/// <summary>
/// http://stackoverflow.com/questions/4354902/check-that-all-items-of-ienumerablet-has-the-same-value-using-linq
/// </summary>
public static bool AllEqual<T>(this IEnumerable<T> source, T target)
{
using (var enumerator = source.GetEnumerator())
{
if (!enumerator.MoveNext())
{
// empty case
return true;
}
var comparer = EqualityComparer<T>.Default;
do
{
if (!comparer.Equals(target, enumerator.Current))
return false;
} while (enumerator.MoveNext());
return true;
}
}
public static bool AllEqual<T>(this IEnumerable<T> source)
{
var pr = source.ExtractFirst();
if (pr.Item1)
return AllEqual(source, pr.Item2);
// empty case
return true;
}
public static T Tee<T>(this T input, Action action)
{
action();
return input;
}
public static T Tee<T>(this T input, Action<T> action)
{
action(input);
return input;
}
public static bool ForAll<T>(this IEnumerable<T> source, Func<T, bool> predicate)
{
foreach (var s in source)
{
if (!predicate(s))
return false;
}
return true;
}
public static bool ForAll<T>(this IEnumerable<T> source, Func<T, int, bool> predicate)
{
int i = 0;
foreach (var s in source)
{
if (!predicate(s, i++))
return false;
}
return true;
}
public static bool NoForAll<T>(this IEnumerable<T> source, Func<T, bool> predicate)
{
foreach (var s in source)
{
if (predicate(s))
return false;
}
return true;
}
/// <summary>
/// source 를 n 개씩 분할한 sequence 를 반환
/// http://stackoverflow.com/questions/419019/split-list-into-sublists-with-linq
/// </summary>
public static IEnumerable<IEnumerable<T>> SplitByN<T>(this IEnumerable<T> source, int n)
{
return source
.Select((x, i) => new { Index = i, Value = x })
.GroupBy(x => x.Index / n)
.Select(x => x.Select(v => v.Value))
;
}
public static IEnumerable<T> EveryNth<T>(this IEnumerable<T> source, int n)
{
return source.Where((v, i) => i % n == 0);
}
public static IEnumerable<TResult> Zip2<TS1, TS2, TResult>(
this IEnumerable<TS1> s1,
IEnumerable<TS2> s2,
Func<TS1, TS2, TResult> resultSelector) => s1.Zip(s2, resultSelector);
public static IEnumerable<TResult> Zip3<TS1, TS2, TS3, TResult>(
this IEnumerable<TS1> s1,
IEnumerable<TS2> s2,
IEnumerable<TS3> s3,
Func<TS1, TS2, TS3, TResult> resultSelector)
{
using (var e1 = s1.GetEnumerator())
using (var e2 = s2.GetEnumerator())
using (var e3 = s3.GetEnumerator())
{
while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext())
yield return resultSelector(e1.Current, e2.Current, e3.Current);
}
}
public static IEnumerable<TResult> Zip4<TS1, TS2, TS3, TS4, TResult>(
this IEnumerable<TS1> s1,
IEnumerable<TS2> s2,
IEnumerable<TS3> s3,
IEnumerable<TS4> s4,
Func<TS1, TS2, TS3, TS4, TResult> resultSelector)
{
using (var e1 = s1.GetEnumerator())
using (var e2 = s2.GetEnumerator())
using (var e3 = s3.GetEnumerator())
using (var e4 = s4.GetEnumerator())
{
while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext())
yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current);
}
}
public static IEnumerable<int> MinMaxRange(int min, int hop, int max)
{
if (hop <= 0)
throw new ArgumentException("hop counter should be positive.");
for (int i = min; i <= max; i += hop)
yield return i;
}
public static IEnumerable<int> MinMaxRange(int min, int max) => Enumerable.Range(min, max - min);
public static IEnumerable<string> HexRange(int start, int count)
{
foreach (var h in Enumerable.Range(start, count))
{
yield return $"{h:X}";
}
}
/// <summary>
/// Enumerable 의 laziness 를 강제로 실행시켜 evaluation 시킴.
/// </summary>
public static IEnumerable<T> Realize<T>(this IEnumerable<T> seq)
{
//var count = seq.Count(); // count 만으로는, 즉석 evaluation 이 안되는 경우가 존재...???...
var array = seq.ToArray();
return array;
}
}
}

771
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/MemoryMappedFileControl.cs Normal file
View File

@ -0,0 +1,771 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Threading;
using System.Runtime.InteropServices;
using SystemX.Net.BaseProtocol;
using SystemX.Common.Serialization;
using static SystemX.Net.Platform.Common.Util.LogMessage;
namespace SystemX.Net.Platform.SystemX.Common
{
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct InfoLogMappedPacket
{
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1024, ArraySubType = UnmanagedType.Bool)]
public bool[] bLogDataReady;
}
//------------------------------------------------------------------------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct LogMappedPacket
{
//Use State
[MarshalAs(UnmanagedType.Bool)]
public bool bSectionUse;
//Host
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objLogType;
//This File Process Result 1
[MarshalAs(UnmanagedType.Bool)]
public bool bLogFileReadComplete;
//This File Process Result 2
[MarshalAs(UnmanagedType.Bool)]
public bool bLogFileProcessComplete;
//Number
[MarshalAs(UnmanagedType.I4)]
public int nNumber;
//Use Log Process Time
[MarshalAs(UnmanagedType.Bool)]
public bool bShowCpLogProcessTime;
//COMMAND 포트 번호
[MarshalAs(UnmanagedType.I4)]
public int nCommandPort;
//STREAM 포트 번호
[MarshalAs(UnmanagedType.I4)]
public int nStreamPort;
//Station ID
[MarshalAs(UnmanagedType.I4)]
public int nStationID;
//Host
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_64[] objHost;
//Section
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_64[] objSection;
//Option File Name
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_64[] objOptionFileName;
//Option File Name
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objOptionFileExtension;
//Station Name
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_64[] objStationName;
//Prod P
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objProdPNo;
//Prod C
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objProdCNo;
//Test Type
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objTestType;
//Test Code
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objTestCode;
//Version
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objVersion;
//Prod Code
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objProdCode;
//Test List Variant No
[MarshalAs(UnmanagedType.I4)]
public int nTestListVariantNo;
//Test List Load Cnt ID
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_256[] objResultTestListCntID;
public byte[] Data() { return ucLogData; }
//Test List Variant No
[MarshalAs(UnmanagedType.I4)]
public int nLogDataSize;
//Log File 1MB 까지
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1024000, ArraySubType = UnmanagedType.U1)]
public byte[] ucLogData;
}
//------------------------------------------------------------------------------------------
public class CMapParameter
{
public string strSetEnterMutexName;
public string strSetAccessMutexName;
public string strSetPath;
public string strSetFileName;
public string strSetMapName;
}
public class SharedMemory
{
//Keep the mutex as static to prevent early garbage collection
public const int nMaxStationSize = 8;
//Keep the mutex as static to prevent early garbage collection
public const int nMaxInfoFullAccessSize = 1024;
protected byte[] ucCurrentArr;
protected int nSize;
private bool bDisposed;
protected CMapParameter ParameterMap;
public SharedMemory(CMapParameter SetParameter)
{
bDisposed = false;
ParameterMap = new CMapParameter();
ParameterMap.strSetEnterMutexName = SetParameter.strSetEnterMutexName;
ParameterMap.strSetAccessMutexName = SetParameter.strSetAccessMutexName;
ParameterMap.strSetPath = SetParameter.strSetPath;
ParameterMap.strSetFileName = SetParameter.strSetFileName;
ParameterMap.strSetMapName = SetParameter.strSetMapName;
}
protected byte[] StructToByte(object obj)
{
int size = Marshal.SizeOf(obj);
byte[] arr = new byte[size];
IntPtr ptr = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(obj, ptr, true);
Marshal.Copy(ptr, arr, 0, size);
Marshal.FreeHGlobal(ptr);
return arr;
}
protected T ByteToStruct<T>(byte[] buffer) where T : struct
{
int size = Marshal.SizeOf(typeof(T));
if (size > buffer.Length)
throw new Exception();
IntPtr ptr = Marshal.AllocHGlobal(size);
Marshal.Copy(buffer, 0, ptr, size);
T obj = (T)Marshal.PtrToStructure(ptr, typeof(T));
Marshal.FreeHGlobal(ptr);
return obj;
}
}
public class LogSharedMemory : SharedMemory, IDisposable
{
//private static object _numLock;
//private static Mutex _mutex;
private static Mutex _mutexSub;
private bool bDisposed;
public LogSharedMemory(CMapParameter SetParameter) : base(SetParameter)
{
bDisposed = false;
}
static LogSharedMemory()
{
}
public void Set(int nPos, LogMappedPacket value)
{
bool bSubMutexResult = true;
try
{
if (!Mutex.TryOpenExisting(ParameterMap.strSetAccessMutexName + nPos.ToString("D03"), out _mutexSub))
{
_mutexSub = new Mutex(true, ParameterMap.strSetAccessMutexName + nPos.ToString("D03"));
}
else
{
bSubMutexResult = _mutexSub.WaitOne();
if (bSubMutexResult == false)
throw new Exception("LogSharedMemory.Set failed Mutex WaitOne().");
}
//
try
{
ucCurrentArr = StructToByte(value);
nSize = ucCurrentArr.Count();
//access memory mapped file (need persistence)
using (var memMapFile = MemoryMappedFile.CreateFromFile(
@ParameterMap.strSetPath + ParameterMap.strSetFileName + nPos.ToString("D03"), //file location
FileMode.OpenOrCreate, //create new file if not exist, open if exist
ParameterMap.strSetMapName + nPos.ToString("D03"), //map name
nSize * nMaxStationSize)) //size
{
//update the number to memory view
using (var stream = memMapFile.CreateViewStream())
using (var writer = new BinaryWriter(stream))
{
writer.Seek(value.nStationID * nSize, SeekOrigin.Begin);
writer.Write(ucCurrentArr);
}
}
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + " [SystemX.Net.Platform.SystemX.Common : LogSharedMemory.Set[1]] " + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
finally
{
//release the mutex for other process to access the memory mapped file
if (bSubMutexResult)
{
if (_mutexSub != null)
_mutexSub.ReleaseMutex();
}
}
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + " [SystemX.Net.Platform.SystemX.Common : LogSharedMemory.Set[2]] " + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
finally
{
//release the mutex for other process to access the memory mapped file
//if (_mutex != null)
// _mutex.ReleaseMutex();
}
}
public bool CheckFile(int nPos)
{
bool bCheckResult = false;
bool bSubMutexResult = true;
try
{
if (!Mutex.TryOpenExisting(ParameterMap.strSetAccessMutexName + nPos.ToString("D03"), out _mutexSub))
{
_mutexSub = new Mutex(true, ParameterMap.strSetAccessMutexName + nPos.ToString("D03"));
}
else
{
bSubMutexResult = _mutexSub.WaitOne(100);
if (bSubMutexResult == false)
throw new Exception("LogSharedMemory.CheckFile failed Mutex WaitOne().");
}
//
if (File.Exists(@ParameterMap.strSetPath + ParameterMap.strSetFileName + nPos.ToString("D03")))
bCheckResult = true;
else
bCheckResult = false;
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + " [SystemX.Net.Platform.SystemX.Common : LogSharedMemory.CheckFile] " + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
bCheckResult = false;
}
finally
{
//release the mutex for other process to access the memory mapped file
if (bSubMutexResult)
{
if (_mutexSub != null)
_mutexSub.ReleaseMutex();
}
}
return bCheckResult;
}
public LogMappedPacket? Get(int nPos, int nStPos, out bool bFindProcessNeedLogResult, int nSetSize = int.MinValue)
{
LogMappedPacket? GetMappedFile = null;
bFindProcessNeedLogResult = false;
byte[] ucGetArr = null;
bool bSubMutexResult = true;
try
{
if (!Mutex.TryOpenExisting(ParameterMap.strSetAccessMutexName + nPos.ToString("D03"), out _mutexSub))
{
_mutexSub = new Mutex(true, ParameterMap.strSetAccessMutexName + nPos.ToString("D03"));
}
else
{
bSubMutexResult = _mutexSub.WaitOne();
if (bSubMutexResult == false)
throw new Exception("LogSharedMemory.Get failed Mutex WaitOne().");
}
//
try
{
if (nSetSize != int.MinValue)
nSize = nSetSize;
//access memory mapped file (need persistence)
using (var memMapFile = MemoryMappedFile.CreateFromFile(
@ParameterMap.strSetPath + ParameterMap.strSetFileName + nPos.ToString("D03"), //file location
FileMode.Open, //create new file if not exist, open if exist
ParameterMap.strSetMapName + nPos.ToString("D03"), //map name
nSize * nMaxStationSize)) //size
{
//get last number from memory view
using (var stream = memMapFile.CreateViewStream())
using (var reader = new BinaryReader(stream))
{
stream.Seek(nStPos * nSize, SeekOrigin.Begin);
ucGetArr = reader.ReadBytes(nSize);
GetMappedFile = ByteToStruct<LogMappedPacket>(ucGetArr);
if (GetMappedFile.Value.bSectionUse)
{
if (GetMappedFile.Value.bLogFileReadComplete == false)
bFindProcessNeedLogResult = true;
}
}
}
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + " [SystemX.Net.Platform.SystemX.Common : LogSharedMemory.Get[1]] " + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
finally
{
/*if (File.Exists(@"D:\CpServerXLogSharedMemoryMap" + nPos.ToString("D03")))
File.Delete(@"D:\CpServerXLogSharedMemoryMap" + nPos.ToString("D03"));*/
//release the mutex for other process to access the memory mapped file
if (bSubMutexResult)
{
if (_mutexSub != null)
_mutexSub.ReleaseMutex();
}
}
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + " [SystemX.Net.Platform.SystemX.Common : LogSharedMemory.Get[2]] " + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
finally
{
//release the mutex for other process to access the memory mapped file
/*
if (_mutex != null)
_mutex.ReleaseMutex();
*/
}
return GetMappedFile;
}
public void Dispose()
{
if (!bDisposed)
{
//Manage
//Unmanage
//
if (_mutexSub != null)
{
_mutexSub.Dispose();
_mutexSub = null;
}
bDisposed = true;
}
}
}
public class InfoLogSharedMemory : SharedMemory, IDisposable
{
private static Mutex _mutex;
private static Mutex _mutexSub;
//private static object _numLock;
private bool bDisposed;
public InfoLogSharedMemory(CMapParameter SetParameter) : base(SetParameter)
{
bDisposed = false;
}
static InfoLogSharedMemory()
{
}
public void Set(InfoLogMappedPacket value)
{
bool bSubMutexResult = true;
try
{
if (!Mutex.TryOpenExisting(ParameterMap.strSetAccessMutexName, out _mutexSub))
{
_mutexSub = new Mutex(true, ParameterMap.strSetAccessMutexName);
}
else
{
bSubMutexResult = _mutexSub.WaitOne();
if (bSubMutexResult == false)
throw new Exception("InfoLogSharedMemory.Set failed Mutex WaitOne().");
}
//
try
{
ucCurrentArr = StructToByte(value);
nSize = ucCurrentArr.Count();
//access memory mapped file (need persistence)
using (var memMapFile = MemoryMappedFile.CreateFromFile(
@ParameterMap.strSetPath + ParameterMap.strSetFileName, //file location
FileMode.OpenOrCreate, //create new file if not exist, open if exist
ParameterMap.strSetMapName, //map name
nSize)) //size
{
//update the number to memory view
using (var stream = memMapFile.CreateViewStream())
using (var writer = new BinaryWriter(stream))
{
writer.Seek(0, SeekOrigin.Begin);
writer.Write(ucCurrentArr);
}
}
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + " [SystemX.Net.Platform.SystemX.Common : InfoLogSharedMemory.Set InfoLogMappedPacket[1]] " + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
finally
{
//release the mutex for other process to access the memory mapped file
if (bSubMutexResult)
{
if (_mutexSub != null)
_mutexSub.ReleaseMutex();
}
}
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + " [SystemX.Net.Platform.SystemX.Common : InfoLogSharedMemory.Set InfoLogMappedPacket[2]] " + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
finally
{
//release the mutex for other process to access the memory mapped file
}
}
public void Set(bool[] value)
{
bool bSubMutexResult = true;
try
{
if (!Mutex.TryOpenExisting(ParameterMap.strSetAccessMutexName, out _mutexSub))
{
_mutexSub = new Mutex(true, ParameterMap.strSetAccessMutexName);
}
else
{
bSubMutexResult = _mutexSub.WaitOne();
if (bSubMutexResult == false)
throw new Exception("InfoLogSharedMemory.Set failed Mutex WaitOne().");
}
//
try
{
InfoLogMappedPacket InfoLogMapFile = new InfoLogMappedPacket();
int nSetSize = Marshal.SizeOf(InfoLogMapFile);
byte[] ucSetLogArray = new byte[nSetSize];
InfoLogMapFile = (InfoLogMappedPacket)SystemXNetSerialization.RawDeSerialize(ucSetLogArray, InfoLogMapFile.GetType());
Array.Copy(value, 0, InfoLogMapFile.bLogDataReady, 0, nMaxInfoFullAccessSize);
ucCurrentArr = StructToByte(InfoLogMapFile);
nSize = ucCurrentArr.Count();
//access memory mapped file (need persistence)
using (var memMapFile = MemoryMappedFile.CreateFromFile(
@ParameterMap.strSetPath + ParameterMap.strSetFileName, //file location
FileMode.OpenOrCreate, //create new file if not exist, open if exist
ParameterMap.strSetMapName, //map name
nSize)) //size
{
//update the number to memory view
using (var stream = memMapFile.CreateViewStream())
using (var writer = new BinaryWriter(stream))
{
writer.Seek(0, SeekOrigin.Begin);
writer.Write(ucCurrentArr);
}
}
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + " [SystemX.Net.Platform.SystemX.Common : InfoLogSharedMemory.Set bool[][1]] " + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
finally
{
//release the mutex for other process to access the memory mapped file
if (bSubMutexResult)
{
if (_mutexSub != null)
_mutexSub.ReleaseMutex();
}
}
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + " [SystemX.Net.Platform.SystemX.Common : InfoLogSharedMemory.Set bool[][2]] " + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
finally
{
//release the mutex for other process to access the memory mapped file
}
}
public bool ForceCheckFile()
{
bool bCheckResult = false;
bool bSubMutexResult = true;
try
{
if (!Mutex.TryOpenExisting(ParameterMap.strSetAccessMutexName, out _mutexSub))
{
_mutexSub = new Mutex(true, ParameterMap.strSetAccessMutexName);
}
else
{
bSubMutexResult = _mutexSub.WaitOne();
if (bSubMutexResult == false)
throw new Exception("InfoLogSharedMemory.CheckFile failed Mutex WaitOne().");
}
//
if (File.Exists(@ParameterMap.strSetPath + ParameterMap.strSetFileName))
bCheckResult = true;
else
bCheckResult = false;
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + " [SystemX.Net.Platform.SystemX.Common : InfoLogSharedMemory.CheckFile] " + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
bCheckResult = false;
}
finally
{
//release the mutex for other process to access the memory mapped file
if (bSubMutexResult)
{
if (_mutexSub != null)
_mutexSub.ReleaseMutex();
}
}
return bCheckResult;
}
public bool CheckExistsInfoFile()
{
if (File.Exists(@ParameterMap.strSetPath + ParameterMap.strSetFileName))
return true;
else
return false;
}
public bool CheckFile()
{
bool bCheckResult = false;
bool bSubMutexResult = true;
try
{
if (!Mutex.TryOpenExisting(ParameterMap.strSetAccessMutexName, out _mutexSub))
{
_mutexSub = new Mutex(true, ParameterMap.strSetAccessMutexName);
}
else
{
bSubMutexResult = _mutexSub.WaitOne(100);
if (bSubMutexResult == false)
throw new Exception("InfoLogSharedMemory.CheckFile failed Mutex WaitOne().");
}
//
if (File.Exists(@ParameterMap.strSetPath + ParameterMap.strSetFileName))
bCheckResult = true;
else
bCheckResult = false;
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + " [SystemX.Net.Platform.SystemX.Common : InfoLogSharedMemory.CheckFile] " + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
bCheckResult = false;
}
finally
{
//release the mutex for other process to access the memory mapped file
if (bSubMutexResult)
{
if (_mutexSub != null)
_mutexSub.ReleaseMutex();
}
}
return bCheckResult;
}
public bool[] Get(out bool bFindInfoLogResult, int nSetSize = int.MinValue)
{
bFindInfoLogResult = false;
bool[] bGetInfoLogStation = new bool[nMaxInfoFullAccessSize];
byte[] ucGetArr = null;
bool bSubMutexResult = true;
try
{
if (!Mutex.TryOpenExisting(ParameterMap.strSetAccessMutexName, out _mutexSub))
{
_mutexSub = new Mutex(true, ParameterMap.strSetAccessMutexName);
}
else
{
bSubMutexResult = _mutexSub.WaitOne();
if (bSubMutexResult == false)
throw new Exception("InfoLogSharedMemory.Get failed Mutex WaitOne().");
}
//
try
{
if (nSetSize != int.MinValue)
nSize = nSetSize;
//access memory mapped file (need persistence)
using (var memMapFile = MemoryMappedFile.CreateFromFile(
@ParameterMap.strSetPath + ParameterMap.strSetFileName, //file location
FileMode.Open, //create new file if not exist, open if exist
ParameterMap.strSetMapName, //map name
nSize)) //size
{
//get last number from memory view
using (var stream = memMapFile.CreateViewStream())
using (var reader = new BinaryReader(stream))
{
stream.Seek(0, SeekOrigin.Begin);
ucGetArr = reader.ReadBytes(nSize);
InfoLogMappedPacket GetInfoMappedFile = ByteToStruct<InfoLogMappedPacket>(ucGetArr);
Array.Copy(GetInfoMappedFile.bLogDataReady, 0, bGetInfoLogStation, 0, nMaxInfoFullAccessSize);
bFindInfoLogResult = true;
}
}
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + " [SystemX.Net.Platform.SystemX.Common : InfoLogSharedMemory.Get[1]] " + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
finally
{
/*if (File.Exists(@"D:\CpServerXLogSharedMemoryMap" + nPos.ToString("D03")))
File.Delete(@"D:\CpServerXLogSharedMemoryMap" + nPos.ToString("D03"));*/
//release the mutex for other process to access the memory mapped file
if (bSubMutexResult)
{
if (_mutexSub != null)
_mutexSub.ReleaseMutex();
}
}
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + " [SystemX.Net.Platform.SystemX.Common : InfoLogSharedMemory.Get[2]] " + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
finally
{
//release the mutex for other process to access the memory mapped file
}
return bGetInfoLogStation;
}
public void Dispose()
{
if (!bDisposed)
{
//Manage
//
//Unmanag
if (_mutexSub != null)
{
_mutexSub.Dispose();
_mutexSub = null;
}
bDisposed = true;
}
}
}
}

216
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/PacketControl/Common.cs Normal file
View File

@ -0,0 +1,216 @@
using System;
using System.CodeDom;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Remoting.Messaging;
using System.Text;
using System.Threading.Tasks;
using SystemX.Common.Archive;
using SystemX.Common.Serialization;
using SystemX.Net.BaseProtocol;
using static SystemX.Net.Platform.Common.Util.LogMessage;
//STATIC 일반적으로 쓸 공용
namespace SystemX.Common
{
public class ResultEventArgs : EventArgs
{
public bool bProcReuslt { get; set; }
public ResultEventArgs(bool bGetResult)
{
bProcReuslt = bGetResult;
}
~ResultEventArgs()
{
}
}
public class ScheduleEvent : EventArgs
{
public int CALL_NUMBER { get; set; }
public bool PROCESS_RESULT { get; set; }
public string STATE_MSG { get; set; }
public byte nLABEL { get; set; }
public ScheduleEvent(int iCallNumer, bool bState, string strMsg, byte nLabel)
{
CALL_NUMBER = iCallNumer;
PROCESS_RESULT = bState;
STATE_MSG = strMsg;
nLABEL = nLabel;
}
~ScheduleEvent()
{
}
}
public delegate void SendRecvCallEvent(byte[] sender, ScheduleEvent e);
public delegate void SocketCallEvent(object sender, ScheduleEvent e);
//SystemXNetCommons
public static partial class XCommons
{
[DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)]
static extern int memcmp(byte[] b1, byte[] b2, long count);
public static bool ByteArrayCompare(byte[] ucArr1, byte[] ucArr2)
{
if (ucArr1 == null || ucArr2 == null)
return false;
if (ucArr1.Length != ucArr2.Length)
return false;
// Validate buffers are the same length.
// This also ensures that the count does not exceed the length of either buffer.
return (memcmp(ucArr1, ucArr2, ucArr1.Length) == 0);
}
public const int PAD_SIZE = 12;
private const int HEAD_SIZE = 8;
private const int TAIL_SIZE = 4;
public static bool isHasRow(DataSet ds)
{
return (ds != null) ? ds.Tables.Cast<DataTable>().Any(table => table.Rows.Count != 0) : false;
}
public static bool isHasRow(DataTable dt)
{
return (dt != null) ? dt.Rows.Count > 0 : false;
}
//
// 요약:
// 패킷 압축 및 마샬링 패킷 마샬링 및 압축 해제시
public class CommonPacketMarshalException : Exception
{
public CommonPacketMarshalException()
{
}
public CommonPacketMarshalException(string message)
: base(message)
{
}
public CommonPacketMarshalException(string message, Exception inner)
: base(message, inner)
{
}
}
public static BASE_PROTOCOL GetHeaderProtocol(int iSize, byte[] CompressMarshalByteStream)
{
byte[] ucDecompressGetByte = new byte[1];
byte[] getRowByte = new byte[iSize - PAD_SIZE];
BASE_PROTOCOL SET_PROTOCOL = new BASE_PROTOCOL();
try
{
try
{
Array.Copy(CompressMarshalByteStream, HEAD_SIZE, getRowByte, 0, iSize - PAD_SIZE);
HEADER_PACKET GetHeaderPacket = new HEADER_PACKET();
int iHeaderSize = Marshal.SizeOf(GetHeaderPacket);
byte[] ucHeaderMake = new byte[iHeaderSize];
GetHeaderPacket = (HEADER_PACKET)SystemXNetSerialization.RawDeSerialize(ucHeaderMake, GetHeaderPacket.GetType());
int iHeadLeng = Marshal.SizeOf(GetHeaderPacket);
byte[] ucHeadBytes = new byte[iHeadLeng];
Array.Copy(getRowByte, 0, ucHeadBytes, 0, iHeadLeng);
GetHeaderPacket = (HEADER_PACKET)SystemXNetSerialization.RawDeSerialize(ucHeadBytes, GetHeaderPacket.GetType());
SET_PROTOCOL = (new BASE_PROTOCOL(GetHeaderPacket.usCommand, GetHeaderPacket.usSubCommand, GetHeaderPacket.uiOptionCommand));
}
catch (Exception e)
{
//throw new CommonPacketMarshalException("General packet marshalling failed.[SystemX.Common : SystemXNetCommons.GetHeaderProtocol]");
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"General packet marshalling failed.[SystemX.Common : SystemXNetCommons.GetHeaderProtocol]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
}
finally
{
;//Until unused
}
return SET_PROTOCOL;
}
public static HEADER_PACKET GetHeaderPacket(int iSize, byte[] CompressMarshalByteStream)
{
byte[] ucDecompressGetByte = new byte[1];
byte[] getRowByte = new byte[iSize - PAD_SIZE];
HEADER_PACKET GetHeaderPacket = new HEADER_PACKET();
try
{
try
{
Array.Copy(CompressMarshalByteStream, HEAD_SIZE, getRowByte, 0, iSize - PAD_SIZE);
GetHeaderPacket = new HEADER_PACKET();
int iHeaderSize = Marshal.SizeOf(GetHeaderPacket);
byte[] ucHeaderMake = new byte[iHeaderSize];
GetHeaderPacket = (HEADER_PACKET)SystemXNetSerialization.RawDeSerialize(ucHeaderMake, GetHeaderPacket.GetType());
int iHeadLeng = Marshal.SizeOf(GetHeaderPacket);
byte[] ucHeadBytes = new byte[iHeadLeng];
Array.Copy(getRowByte, 0, ucHeadBytes, 0, iHeadLeng);
GetHeaderPacket = (HEADER_PACKET)SystemXNetSerialization.RawDeSerialize(ucHeadBytes, GetHeaderPacket.GetType());
}
catch (Exception e)
{
//throw new CommonPacketMarshalException("General packet marshalling failed.[SystemX.Common : SystemXNetCommons.GetHeaderPacket]");
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"General packet marshalling failed.[SystemX.Common : SystemXNetCommons.GetHeaderPacket]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
}
finally
{
;//Until unused
}
return GetHeaderPacket;
}
private static byte[] HeadTailMake(uint uiPacketSize, byte[] HeadBuff, byte[] BodyBuff)
{
byte[] ucSetStreamBytes = new byte[uiPacketSize + PAD_SIZE];
ucSetStreamBytes[0] = 0x0D;
ucSetStreamBytes[1] = 0x02;
ucSetStreamBytes[2] = (byte)(uiPacketSize >> 24);
ucSetStreamBytes[3] = (byte)(uiPacketSize >> 16);
ucSetStreamBytes[4] = (byte)(uiPacketSize >> 8);
ucSetStreamBytes[5] = (byte)(uiPacketSize >> 0);
ucSetStreamBytes[6] = 0x08;
ucSetStreamBytes[7] = 0x0A;
Array.Copy(HeadBuff, 0, ucSetStreamBytes, 8, HeadBuff.Count());
Array.Copy(BodyBuff, 0, ucSetStreamBytes, HeadBuff.Count() + HEAD_SIZE, BodyBuff.Count());
ucSetStreamBytes[ucSetStreamBytes.Length - 4] = 0x0D;
ucSetStreamBytes[ucSetStreamBytes.Length - 3] = 0x02;
ucSetStreamBytes[ucSetStreamBytes.Length - 2] = 0x08;
ucSetStreamBytes[ucSetStreamBytes.Length - 1] = 0x0A;
return ucSetStreamBytes;
}
}
}

271
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/PacketControl/PacketMakeFrom.cs Normal file
View File

@ -0,0 +1,271 @@
using System;
using System.CodeDom;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Remoting.Messaging;
using System.Text;
using System.Threading.Tasks;
using SystemX.Common.Archive;
using SystemX.Common.Serialization;
using SystemX.Net.BaseProtocol;
using static SystemX.Net.Platform.Common.Util.LogMessage;
namespace SystemX.Common
{
public static partial class XCommons
{
public static T ByteStreamToSpecialObject<T>(BASE_PROTOCOL.PROTOCOL_CODE GET_CODE, int iSize, byte[] MarshalByteStream)
{
byte[] getDataByte = new byte[1];
byte[] getRawByte = new byte[iSize - PAD_SIZE];
int iRawDataSize;
object getObj = null;
try
{
try
{
Array.Copy(MarshalByteStream, HEAD_SIZE, getRawByte, 0, iSize - PAD_SIZE);
HEADER_PACKET GetHeaderPacket = new HEADER_PACKET();
int iHeadLeng = Marshal.SizeOf(GetHeaderPacket);
byte[] ucHeadBytes = new byte[iHeadLeng];
Array.Copy(getRawByte, 0, ucHeadBytes, 0, iHeadLeng);
iRawDataSize = getRawByte.Count();
GetHeaderPacket = (HEADER_PACKET)SystemXNetSerialization.RawDeSerialize(ucHeadBytes, GetHeaderPacket.GetType());
getDataByte = new byte[GetHeaderPacket.uiDataLength];
object getPacket = SystemXNetSerialization.SelectPacket(GetHeaderPacket.uiDataLength);
if (getPacket == null) throw new Exception("SystemXNetSerialization.SelectPacket Failed.");
int iBodySize = Marshal.SizeOf(getPacket);
byte[] ucBodyArray = new byte[iBodySize];
Array.Copy(getRawByte, iHeadLeng, ucBodyArray, 0, iBodySize); // iRawDataSize - iHeadLeng);
getPacket = Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucBodyArray, getPacket.GetType()), getPacket.GetType());
getPacket = SystemXNetSerialization.RawDeSerialize(ucBodyArray, getPacket.GetType());
Array.Copy((byte[])getPacket.GetType().GetMethod("Data").Invoke(getPacket, null), getDataByte, GetHeaderPacket.uiDataLength);
byte[] ucSpecialObjArray = XDataArchive.DecompressDeflateByteToByte(getDataByte);
if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.CONNECT_STATE)
{
PING_PACKET PingPacket = new PING_PACKET();
PingPacket = (PING_PACKET)Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, PingPacket.GetType()), PingPacket.GetType());
PingPacket = (PING_PACKET)SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, PingPacket.GetType());
getObj = PingPacket;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.MIDDLEWARE_MESSAGE)
{
MESSAGE_PACKET MessagePacket = new MESSAGE_PACKET();
MessagePacket = (MESSAGE_PACKET)Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, MessagePacket.GetType()), MessagePacket.GetType());
MessagePacket = (MESSAGE_PACKET)SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, MessagePacket.GetType());
getObj = MessagePacket;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.HOST_INFO_CHECK)
{
SYSTEM_HOST_PACKET HostInfoPacket = new SYSTEM_HOST_PACKET();
HostInfoPacket = (SYSTEM_HOST_PACKET)Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, HostInfoPacket.GetType()), HostInfoPacket.GetType());
HostInfoPacket = (SYSTEM_HOST_PACKET)SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, HostInfoPacket.GetType());
getObj = HostInfoPacket;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.SYNC_TIME_SERVER)
{
TIME_PACKET timePacket = new TIME_PACKET();
timePacket = (TIME_PACKET)Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, timePacket.GetType()), timePacket.GetType());
timePacket = (TIME_PACKET)SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, timePacket.GetType());
getObj = timePacket;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.ETC)
{
USER_PACKET UserDataPacket = new USER_PACKET();
UserDataPacket = (USER_PACKET)Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, UserDataPacket.GetType()), UserDataPacket.GetType());
UserDataPacket = (USER_PACKET)SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, UserDataPacket.GetType());
getObj = UserDataPacket;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.PROCESS_QUERY)
{
PROCESS_PACKET ProcessDataPacket = new PROCESS_PACKET();
ProcessDataPacket = (PROCESS_PACKET)Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, ProcessDataPacket.GetType()), ProcessDataPacket.GetType());
ProcessDataPacket = (PROCESS_PACKET)SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, ProcessDataPacket.GetType());
getObj = ProcessDataPacket;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.SYSTEM_QUERY)
{
QUERY_PACKET SystemQueryPacket = new QUERY_PACKET();
SystemQueryPacket = (QUERY_PACKET)Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, SystemQueryPacket.GetType()), SystemQueryPacket.GetType());
SystemQueryPacket = (QUERY_PACKET)SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, SystemQueryPacket.GetType());
getObj = SystemQueryPacket;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.USER_QUERY)
{
QUERY_PACKET SystemQueryPacket = new QUERY_PACKET();
SystemQueryPacket = (QUERY_PACKET)Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, SystemQueryPacket.GetType()), SystemQueryPacket.GetType());
SystemQueryPacket = (QUERY_PACKET)SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, SystemQueryPacket.GetType());
getObj = SystemQueryPacket;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.TRANSFER_RESULT)
{
TRANSFER_PACKET TransferResult = new TRANSFER_PACKET();
TransferResult = (TRANSFER_PACKET)Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, TransferResult.GetType()), TransferResult.GetType());
TransferResult = (TRANSFER_PACKET)SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, TransferResult.GetType());
getObj = TransferResult;
}
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.INITILALIZE_INFO)
{
COMM_INFO_PACKET CommInfoPacket = new COMM_INFO_PACKET();
CommInfoPacket = (COMM_INFO_PACKET)Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, CommInfoPacket.GetType()), CommInfoPacket.GetType());
CommInfoPacket = (COMM_INFO_PACKET)SystemXNetSerialization.RawDeSerialize(ucSpecialObjArray, CommInfoPacket.GetType());
getObj = CommInfoPacket;
}
else
getObj = null;
}
catch (Exception e)
{
//throw new CommonPacketMarshalException("General packet marshalling failed.[SystemX.Common : SystemXNetCommons.ByteStreamToUserObject]");
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"General packet marshalling failed.[SystemX.Common : SystemXNetCommons.ByteStreamToUserObject]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
}
finally
{
;//Until unused
}
return (T)Convert.ChangeType(getObj, typeof(T));
}
public static bool GetSimpleResponsResult(int iSize, byte[] CompressMarshalByteStream)
{
byte[] getDataByte = new byte[1];
byte[] getRawByte = new byte[iSize - PAD_SIZE];
bool bResponsResult = false;
try
{
try
{
Array.Copy(CompressMarshalByteStream, HEAD_SIZE, getRawByte, 0, iSize - PAD_SIZE);
HEADER_PACKET GetHeaderPacket = new HEADER_PACKET();
int iHeaderSize = Marshal.SizeOf(GetHeaderPacket);
byte[] ucHeaderMake = new byte[iHeaderSize];
GetHeaderPacket = (HEADER_PACKET)SystemXNetSerialization.RawDeSerialize(ucHeaderMake, GetHeaderPacket.GetType());
int iHeadLeng = Marshal.SizeOf(GetHeaderPacket);
byte[] ucHeadBytes = new byte[iHeadLeng];
Array.Copy(getRawByte, 0, ucHeadBytes, 0, iHeadLeng);
GetHeaderPacket = (HEADER_PACKET)SystemXNetSerialization.RawDeSerialize(ucHeadBytes, GetHeaderPacket.GetType());
getDataByte = new byte[GetHeaderPacket.uiDataLength];
object getPacket = SystemXNetSerialization.SelectPacket(GetHeaderPacket.uiDataLength);
if (getPacket == null) throw new Exception("SystemXNetSerialization.SelectPacket Failed.");
int iBodySize = Marshal.SizeOf(getPacket);
byte[] ucBodyArray = new byte[iBodySize];
Array.Copy(getRawByte, iHeadLeng, ucBodyArray, 0, iBodySize); // - iHeadLeng);
getPacket = Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucBodyArray, getPacket.GetType()), getPacket.GetType());
getPacket = SystemXNetSerialization.RawDeSerialize(ucBodyArray, getPacket.GetType());
Array.Copy((byte[])getPacket.GetType().GetMethod("Data").Invoke(getPacket, null), getDataByte, GetHeaderPacket.uiDataLength);
bResponsResult = GetHeaderPacket.bResponsState;
}
catch (Exception e)
{
//throw new CommonPacketMarshalException("General packet marshalling failed.[SystemX.Common : SystemXNetCommons.ByteStreamToObject]");
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"General packet marshalling failed.[SystemX.Common : SystemXNetCommons.ByteStreamToObject]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
}
finally
{
;//Until unused
}
return bResponsResult;
}
public static T ByteStreamToObject<T>(BASE_PROTOCOL.PROTOCOL_CODE GET_CODE, int iSize, byte[] CompressMarshalByteStream)
{
byte[] getDataByte = new byte[1];
byte[] getRawByte = new byte[iSize - PAD_SIZE];
object getObj = null;
try
{
try
{
Array.Copy(CompressMarshalByteStream, HEAD_SIZE, getRawByte, 0, iSize - PAD_SIZE);
HEADER_PACKET GetHeaderPacket = new HEADER_PACKET();
int iHeaderSize = Marshal.SizeOf(GetHeaderPacket);
byte[] ucHeaderMake = new byte[iHeaderSize];
GetHeaderPacket = (HEADER_PACKET)SystemXNetSerialization.RawDeSerialize(ucHeaderMake, GetHeaderPacket.GetType());
int iHeadLeng = Marshal.SizeOf(GetHeaderPacket);
byte[] ucHeadBytes = new byte[iHeadLeng];
Array.Copy(getRawByte, 0, ucHeadBytes, 0, iHeadLeng);
GetHeaderPacket = (HEADER_PACKET)SystemXNetSerialization.RawDeSerialize(ucHeadBytes, GetHeaderPacket.GetType());
getDataByte = new byte[GetHeaderPacket.uiDataLength];
object getPacket = SystemXNetSerialization.SelectPacket(GetHeaderPacket.uiDataLength);
if (getPacket == null) throw new Exception("SystemXNetSerialization.SelectPacket Failed.");
int iBodySize = Marshal.SizeOf(getPacket);
byte[] ucBodyArray = new byte[iBodySize];
Array.Copy(getRawByte, iHeadLeng, ucBodyArray, 0, iBodySize); // - iHeadLeng);
getPacket = Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucBodyArray, getPacket.GetType()), getPacket.GetType());
getPacket = SystemXNetSerialization.RawDeSerialize(ucBodyArray, getPacket.GetType());
Array.Copy((byte[])getPacket.GetType().GetMethod("Data").Invoke(getPacket, null), getDataByte, GetHeaderPacket.uiDataLength);
if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.FILE_TRANSFER)
getObj = getDataByte; //XDataArchive.DecompressDeflateByteToByte(getDataByte);
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.DATASET_TRANSEFER)
getObj = XDataArchive.DecompressByteToDataset(getDataByte);
else if (GET_CODE == BASE_PROTOCOL.PROTOCOL_CODE.RAW_SIZE)
getObj = getDataByte;
}
catch (Exception e)
{
//throw new CommonPacketMarshalException("General packet marshalling failed.[SystemX.Common : COMMON.ByteStreamToObject]");
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"General packet marshalling failed.[SystemX.Common : COMMON.ByteStreamToObject]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
}
finally
{
;//Until unused
}
return (T)Convert.ChangeType(getObj, typeof(T));
}
}
}

644
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/PacketControl/PacketMakeTo.cs Normal file
View File

@ -0,0 +1,644 @@
using System;
using System.CodeDom;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Remoting.Messaging;
using System.Text;
using System.Threading.Tasks;
using SystemX.Common.Archive;
using SystemX.Common.Serialization;
using SystemX.Net.BaseProtocol;
using static SystemX.Net.Platform.Common.Util.LogMessage;
namespace SystemX.Common
{
public static partial class XCommons
{
public static byte[] SpecialObjectToByteStream(BASE_PROTOCOL SET_PROTOCOL, object refObj)
{
byte[] ucGetStreamBytes = new byte[1];
try
{
try
{
int iSize = Marshal.SizeOf(refObj);
byte[] SendBuffer = SystemXNetSerialization.RawSerialize(refObj, Marshal.SizeOf(refObj));
var memoryStream = new MemoryStream(SendBuffer);
byte[] getSendCompressFileByte = new byte[1];
getSendCompressFileByte = XDataArchive.CompressDeflateByteToByte(SendBuffer);
iSize = getSendCompressFileByte.Count();
HEADER_PACKET setHeader = new HEADER_PACKET();
int iHeaderSize = Marshal.SizeOf(setHeader);
byte[] ucHeaderMake = new byte[iHeaderSize];
setHeader = (HEADER_PACKET)SystemXNetSerialization.RawDeSerialize(ucHeaderMake, setHeader.GetType());
iHeaderSize = Marshal.SizeOf(setHeader);
setHeader.usCommand = SET_PROTOCOL.COMMAND;
setHeader.usSubCommand = SET_PROTOCOL.SUB_COMMAND;
setHeader.uiOptionCommand = SET_PROTOCOL.OPTION_COMMAND;
setHeader.uiHeaderLength = (uint)iHeaderSize;
setHeader.uiDataLength = (uint)iSize;
setHeader.objOptionName[0].Data = "-";
setHeader.objOptionExtension[0].Data = "-";
setHeader.uiSourDataNum = 0;
setHeader.uiDestDataNum = 0;
byte[] SendHeadBuffer = SystemXNetSerialization.RawSerialize(setHeader, Marshal.SizeOf(setHeader));
object getPacket = SystemXNetSerialization.SelectPacket(setHeader.uiDataLength);
if (getPacket == null) throw new Exception("SystemXNetSerialization.SelectPacket Failed.");
int iBodySize = Marshal.SizeOf(getPacket);
byte[] ucBodyArray = new byte[iBodySize];
getPacket = Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucBodyArray, getPacket.GetType()), getPacket.GetType());
Array.Copy(getSendCompressFileByte, (byte[])getPacket.GetType().GetMethod("Data").Invoke(getPacket, null), getSendCompressFileByte.Count());
setHeader.uiBodyLength = (uint)iBodySize;
setHeader.uiPacketLength = (uint)(iHeaderSize + iBodySize);
byte[] SendBodyBuffer = SystemXNetSerialization.RawSerialize(getPacket, Marshal.SizeOf(getPacket));
ucGetStreamBytes = HeadTailMake(setHeader.uiPacketLength, SendHeadBuffer, SendBodyBuffer);
//string strMessage = Encoding.Unicode.GetString(ucGetFileBytes, 0, ucGetFileBytes.Length) + "\r\n";
}
catch (Exception e)
{
//throw new CommonPacketMarshalException("General packet marshalling failed.[SystemX.Common : SystemXNetCommons.UserObjectToByteStream]");
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"General packet marshalling failed.[SystemX.Common : SystemXNetCommons.UserObjectToByteStream]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
}
finally
{
;//Until unused
}
return ucGetStreamBytes;
}
public static byte[] SetSimpleResponsPacket(BASE_PROTOCOL SET_PROTOCOL, bool bState)
{
byte[] ucGetStreamBytes = new byte[1];
try
{
try
{
if (SET_PROTOCOL.GET_CURRENT_PROTOCOL == BASE_PROTOCOL.PROTOCOL_CODE.SIMPLE_RESPONSE)
{
;//
}
else if (SET_PROTOCOL.GET_CURRENT_PROTOCOL == BASE_PROTOCOL.PROTOCOL_CODE.RAW_END)
{
;//
}
else
return null;
var bytes = new byte[1];
HEADER_PACKET setHeader = new HEADER_PACKET();
int iHeaderSize = Marshal.SizeOf(setHeader);
byte[] ucHeaderMake = new byte[iHeaderSize];
setHeader = (HEADER_PACKET)SystemXNetSerialization.RawDeSerialize(ucHeaderMake, setHeader.GetType());
iHeaderSize = Marshal.SizeOf(setHeader);
setHeader.usCommand = SET_PROTOCOL.COMMAND;
setHeader.usSubCommand = SET_PROTOCOL.SUB_COMMAND;
setHeader.uiOptionCommand = SET_PROTOCOL.OPTION_COMMAND;
setHeader.bResponsState = bState;
setHeader.usHeader = 1;
setHeader.uiHeaderLength = (uint)iHeaderSize;
setHeader.uiDataLength = 512;
setHeader.objOptionName[0].Data = "-";
setHeader.objOptionExtension[0].Data = "-";
setHeader.uiSourDataNum = 0;
setHeader.uiDestDataNum = 0;
object getPacket = SystemXNetSerialization.SelectPacket(512);
if (getPacket == null) throw new Exception("SystemXNetSerialization.SelectPacket Failed.");
int iBodySize = Marshal.SizeOf(getPacket);
byte[] ucBodyArray = new byte[iBodySize];
getPacket = Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucBodyArray, getPacket.GetType()), getPacket.GetType());
setHeader.uiBodyLength = (uint)iBodySize;
setHeader.uiPacketLength = (uint)(iHeaderSize + iBodySize);
byte[] SendHeadBuffer = SystemXNetSerialization.RawSerialize(setHeader, Marshal.SizeOf(setHeader));
byte[] SendBodyBuffer = SystemXNetSerialization.RawSerialize(getPacket, Marshal.SizeOf(getPacket));
ucGetStreamBytes = HeadTailMake(setHeader.uiPacketLength, SendHeadBuffer, SendBodyBuffer);
//string strMessage = Encoding.Unicode.GetString(ucGetFileBytes, 0, ucGetFileBytes.Length) + "\r\n";
}
catch (Exception e)
{
//throw new CommonPacketMarshalException("General packet marshalling failed.[SystemX.Common : SystemXNetCommons.SimpleObjectToByteStream]");
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"General packet marshalling failed.[SystemX.Common : SystemXNetCommons.SimpleObjectToByteStream]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
}
finally
{
;//Until unused
}
return ucGetStreamBytes;
}
public static byte[] ObjectToByteStream(BASE_PROTOCOL SET_PROTOCOL, object refObj, CP_PACKET? getCPPacket = null,
ushort usPalletIndex = 0, int iRecordsAffected = 1, bool bHasRows = true, int iFieldCount = 1, params string[] strParameters)
{
byte[] ucGetStreamBytes = new byte[1];
try
{
try
{
string refObjGetPos = string.Empty;
string strGetFileName = string.Empty;
string strGetExtension = string.Empty;
MemoryStream ms = null;
//
SqlDataReader sqlReader = null;
DataSet ds = new DataSet();
DataTable dt = new DataTable();
bool bCheckPos = true;
bool bResponsSetState = true;
if (SET_PROTOCOL.GET_CURRENT_PROTOCOL == BASE_PROTOCOL.PROTOCOL_CODE.FILE_TRANSFER)
{
if (refObj is MemoryStream)
{
ms = (MemoryStream)refObj;
if (ms == null)
{
bCheckPos = false;
//throw new Exception("MemoryStream not initialize.. " + refObjGetPos);
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"MemoryStream not initialize." + refObjGetPos + " [SystemX.Common : SystemXNetCommons.ObjectToByteStream]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
}
else
{
refObjGetPos = (string)refObj;
if (File.Exists(@refObjGetPos) == false)
{
bCheckPos = false;
//throw new Exception("The file cannot be found. " + refObjGetPos);
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"The file cannot be found." + refObjGetPos + " [SystemX.Common : SystemXNetCommons.ObjectToByteStream]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
else
{
strGetFileName = Path.GetFileNameWithoutExtension(@refObjGetPos);
strGetExtension = Path.GetExtension(@refObjGetPos);
}
}
}
else if (SET_PROTOCOL.GET_CURRENT_PROTOCOL == BASE_PROTOCOL.PROTOCOL_CODE.DATASET_TRANSEFER)
{
if (refObj is SqlDataReader)
{
sqlReader = (SqlDataReader)refObj;
bResponsSetState = false;
if (sqlReader != null)
{
if (sqlReader.RecordsAffected > 0)
bResponsSetState = true;
else if (sqlReader.HasRows == true)
bResponsSetState = true;
else if (sqlReader.FieldCount > 0)
bResponsSetState = true;
else
bResponsSetState = false;
dt.Load(sqlReader);
ds.Tables.Add(dt);
}
}
else if (refObj is DataTable)
{
dt = (DataTable)refObj;
bResponsSetState = false;
if (dt != null)
{
if (iRecordsAffected > 0)
bResponsSetState = true;
else if (bHasRows == true)
bResponsSetState = true;
else if (iFieldCount > 0)
bResponsSetState = true;
else
bResponsSetState = false;
ds.Tables.Add(dt);
}
}
else if (refObj is DataSet)
{
ds = (DataSet)refObj;
bResponsSetState = false;
if (ds != null)
{
if (iRecordsAffected > 0)
bResponsSetState = true;
else if (bHasRows == true)
bResponsSetState = true;
else if (iFieldCount > 0)
bResponsSetState = true;
else
bResponsSetState = false;
}
}
else
{
;//
}
}
if (bCheckPos)
{
var bytes = new byte[1];
if (SET_PROTOCOL.GET_CURRENT_PROTOCOL == BASE_PROTOCOL.PROTOCOL_CODE.FILE_TRANSFER)
{
if (ms != null)
bytes = ms.ToArray();
else
bytes = File.ReadAllBytes(@refObjGetPos);
}
else if (SET_PROTOCOL.GET_CURRENT_PROTOCOL == BASE_PROTOCOL.PROTOCOL_CODE.DATASET_TRANSEFER)
bytes = XDataArchive.CompressDatasetToByte(ds);
var memoryStream = new MemoryStream(bytes);
byte[] getSendOrgFileByte = memoryStream.ToArray();
byte[] getSendCompressFileByte = new byte[1];
if (SET_PROTOCOL.GET_CURRENT_PROTOCOL == BASE_PROTOCOL.PROTOCOL_CODE.FILE_TRANSFER)
getSendCompressFileByte = XDataArchive.CompressDeflateByteToByte(getSendOrgFileByte);
else if (SET_PROTOCOL.GET_CURRENT_PROTOCOL == BASE_PROTOCOL.PROTOCOL_CODE.DATASET_TRANSEFER)
getSendCompressFileByte = memoryStream.ToArray();
HEADER_PACKET setHeader = new HEADER_PACKET();
int iHeaderSize = Marshal.SizeOf(setHeader);
byte[] ucHeaderMake = new byte[iHeaderSize];
setHeader = (HEADER_PACKET)SystemXNetSerialization.RawDeSerialize(ucHeaderMake, setHeader.GetType());
iHeaderSize = Marshal.SizeOf(setHeader);
//Various Parameter
int nParamPos = 0;
foreach (string strParam in strParameters)
{
switch (nParamPos)
{
case 0: setHeader.objVarParam1[0].Data = strParam; break;
case 1: setHeader.objVarParam2[0].Data = strParam; break;
case 2: setHeader.objVarParam3[0].Data = strParam; break;
}
nParamPos++;
}
setHeader.bResponsState = bResponsSetState;
setHeader.usPalletIndex = usPalletIndex;
setHeader.usCommand = SET_PROTOCOL.COMMAND;
setHeader.usSubCommand = SET_PROTOCOL.SUB_COMMAND;
setHeader.uiOptionCommand = SET_PROTOCOL.OPTION_COMMAND;
setHeader.uiHeaderLength = (uint)iHeaderSize;
setHeader.uiDataLength = (uint)getSendCompressFileByte.Count();
setHeader.objOptionName[0].Data = "-";
setHeader.objOptionExtension[0].Data = "-";
if (getCPPacket == null)
{
setHeader.objCP_Packet[0].objStationName[0].Data = "-";
setHeader.objCP_Packet[0].objProdNo_P[0].Data = "-";
setHeader.objCP_Packet[0].objProdNo_C[0].Data = "-";
setHeader.objCP_Packet[0].objTestType[0].Data = "-";
setHeader.objCP_Packet[0].objTestCode[0].Data = "-";
setHeader.objCP_Packet[0].objVersion[0].Data = "-";
setHeader.objCP_Packet[0].objProdCode[0].Data = "-";
setHeader.objCP_Packet[0].uiTestListNo = 0;
}
else
{
setHeader.objCP_Packet[0].objStationName[0].Data = getCPPacket.Value.objStationName[0].Data;
setHeader.objCP_Packet[0].objProdNo_P[0].Data = getCPPacket.Value.objProdNo_P[0].Data;
setHeader.objCP_Packet[0].objProdNo_C[0].Data = getCPPacket.Value.objProdNo_C[0].Data;
setHeader.objCP_Packet[0].objTestType[0].Data = getCPPacket.Value.objTestType[0].Data;
setHeader.objCP_Packet[0].objTestCode[0].Data = getCPPacket.Value.objTestCode[0].Data;
setHeader.objCP_Packet[0].objVersion[0].Data = getCPPacket.Value.objVersion[0].Data;
setHeader.objCP_Packet[0].objProdCode[0].Data = getCPPacket.Value.objProdCode[0].Data;
setHeader.objCP_Packet[0].uiTestListNo = getCPPacket.Value.uiTestListNo;
}
if (SET_PROTOCOL.GET_CURRENT_PROTOCOL == BASE_PROTOCOL.PROTOCOL_CODE.FILE_TRANSFER)
{
if (strGetFileName != string.Empty)
{
setHeader.objOptionName[0].Data = strGetFileName;
setHeader.objOptionExtension[0].Data = strGetExtension;
}
}
setHeader.uiSourDataNum = 0;
setHeader.uiDestDataNum = 0;
object getPacket = SystemXNetSerialization.SelectPacket(setHeader.uiDataLength);
if (getPacket == null) throw new Exception("SystemXNetSerialization.SelectPacket Failed.");
int iBodySize = Marshal.SizeOf(getPacket);
byte[] ucBodyArray = new byte[iBodySize];
getPacket = Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucBodyArray, getPacket.GetType()), getPacket.GetType());
Array.Copy(getSendCompressFileByte, (byte[])getPacket.GetType().GetMethod("Data").Invoke(getPacket, null), getSendCompressFileByte.Count());
setHeader.uiBodyLength = (uint)iBodySize;
setHeader.uiPacketLength = (uint)(iHeaderSize + iBodySize);
byte[] SendHeadBuffer = SystemXNetSerialization.RawSerialize(setHeader, Marshal.SizeOf(setHeader));
byte[] SendBodyBuffer = SystemXNetSerialization.RawSerialize(getPacket, Marshal.SizeOf(getPacket));
ucGetStreamBytes = HeadTailMake(setHeader.uiPacketLength, SendHeadBuffer, SendBodyBuffer);
//string strMessage = Encoding.Unicode.GetString(ucGetFileBytes, 0, ucGetFileBytes.Length) + "\r\n";
}
}
catch (Exception e)
{
//throw new CommonPacketMarshalException("General packet marshalling failed.[SystemX.Common : SystemXNetCommons.ObjectToByteStream]");
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"General packet marshalling failed.[SystemX.Common : SystemXNetCommons.ObjectToByteStream]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
}
finally
{
;//Until unused
}
return ucGetStreamBytes;
}
public static List<byte[]> ObjectToByteStreamList(BASE_PROTOCOL SET_PROTOCOL, object refObj, CP_PACKET? getCPPacket = null,
ushort usPalletIdx = 0, params string[] strParameters)
{
List<byte[]> listStreamRawData = new List<byte[]>();
byte[] ucGetStreamBytes = new byte[1];
try
{
try
{
string refObjGetPos = string.Empty;
string strGetFileName = string.Empty;
string strGetExtension = string.Empty;
bool bCheckPos = true;
// 1 = File, 2 = DataSet
int iSelectType = 0;
if (refObj is string)
{
refObjGetPos = (string)refObj;
if (File.Exists(@refObjGetPos) == false)
{
bCheckPos = false;
//throw new Exception("The file cannot be found. " + refObjGetPos);
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"The file cannot be found. " + refObjGetPos + " [SystemX.Common : SystemXNetCommons.ObjectToByteStreamList]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
else
{
strGetFileName = Path.GetFileNameWithoutExtension(@refObjGetPos);
strGetExtension = Path.GetExtension(@refObjGetPos);
iSelectType = 1;
}
}
else if (refObj is DataSet)
{
strGetFileName = "";
strGetExtension = "";
iSelectType = 2;
}
else
bCheckPos = false;
if (bCheckPos)
{
var bytes = new byte[1];
switch (iSelectType)
{
case 1:
bytes = File.ReadAllBytes(@refObjGetPos);
break;
case 2:
bytes = XDataArchive.CompressDatasetToByte(refObj as DataSet);
break;
}
/*
try
{
Bitmap xBitmap = new Bitmap(@refObjGetPos);
using (var stream = new MemoryStream())
{
stream.Seek(0, SeekOrigin.Begin);
xBitmap.Save(stream, xBitmap.RawFormat);
bytes = stream.ToArray();
}
//ImageConverter _imageConverter = new ImageConverter();
//bytes = (byte[])_imageConverter.ConvertTo(xBitmap, typeof(byte[]));
}
catch (Exception e)
{
bytes = File.ReadAllBytes(@refObjGetPos);
}
*/
var memoryStream = new MemoryStream(bytes);
//moryStream.Seek(0, SeekOrigin.Begin);
//byte[] getSendOrgFileByte = memoryStream.ToArray();
//byte[] getSendCompressFileByte = new byte[1];
//getSendCompressFileByte = XNetArchive.CompressGZipByteToByte(getSendOrgFileByte);
//getSendCompressFileByte = bytes;
if (iSelectType == 1)
{
byte[] getSendCompressFileByte = XDataArchive.CompressGZipByteToByte(memoryStream.ToArray());
memoryStream = new MemoryStream(getSendCompressFileByte);
}
memoryStream.Seek(0, SeekOrigin.Begin);
/*
if (memoryStream.Length < SystemXNetSerialization.MAX_PACKET_SIZE)
{
//throw new Exception("The file use normal send mode. " + refObjGetPos);
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"The file use normal send mode. " + refObjGetPos + " [SystemX.Common : SystemXNetCommons.ObjectToByteStreamList]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
*/
int iFileSize = (int)memoryStream.Length;
int iRemainSize = (int)memoryStream.Length;
uint uiMakeCnt = (uint)(Math.Ceiling((double)((double)iFileSize / (double)SystemXNetSerialization.MAX_PACKET_SIZE)));
int iSendPos = 0;
for (uint i = 0; i < uiMakeCnt; i++)
{
byte[] ucSendData = null;
if (iRemainSize >= SystemXNetSerialization.MAX_PACKET_SIZE)
{
ucSendData = new byte[SystemXNetSerialization.MAX_PACKET_SIZE];
int iRead = memoryStream.Read(ucSendData, 0, SystemXNetSerialization.MAX_PACKET_SIZE);
//Array.Copy(getSendCompressFileByte, iSendPos, ucSendData, 0, SystemXNetSerialization.MAX_PACKET_SIZE);
iSendPos += SystemXNetSerialization.MAX_PACKET_SIZE;
iRemainSize -= SystemXNetSerialization.MAX_PACKET_SIZE;
}
else
{
ucSendData = new byte[iRemainSize];
int iRead = memoryStream.Read(ucSendData, 0, iRemainSize);
//Array.Copy(getSendCompressFileByte, iSendPos, ucSendData, 0, iRemainSize);
iSendPos += iRemainSize;
iRemainSize -= iRemainSize;
}
HEADER_PACKET setHeader = new HEADER_PACKET();
int iHeaderSize = Marshal.SizeOf(setHeader);
byte[] ucHeaderMake = new byte[iHeaderSize];
setHeader = (HEADER_PACKET)SystemXNetSerialization.RawDeSerialize(ucHeaderMake, setHeader.GetType());
iHeaderSize = Marshal.SizeOf(setHeader);
//Various Parameter
int nParamPos = 0;
foreach (string strParam in strParameters)
{
switch (nParamPos)
{
case 0: setHeader.objVarParam1[0].Data = strParam; break;
case 1: setHeader.objVarParam2[0].Data = strParam; break;
case 2: setHeader.objVarParam3[0].Data = strParam; break;
}
nParamPos++;
}
if (iSelectType == 1)
setHeader.usPalletIndex = usPalletIdx;
else if (iSelectType == 2)
setHeader.usPalletIndex = ushort.MaxValue;
setHeader.usCommand = SET_PROTOCOL.COMMAND;
setHeader.usSubCommand = SET_PROTOCOL.SUB_COMMAND;
setHeader.uiOptionCommand = SET_PROTOCOL.OPTION_COMMAND;
setHeader.uiHeaderLength = (uint)iHeaderSize;
setHeader.uiDataLength = (uint)ucSendData.Count();
if (getCPPacket == null)
{
setHeader.objCP_Packet[0].objStationName[0].Data = "-";
setHeader.objCP_Packet[0].objProdNo_P[0].Data = "-";
setHeader.objCP_Packet[0].objProdNo_C[0].Data = "-";
setHeader.objCP_Packet[0].objTestType[0].Data = "-";
setHeader.objCP_Packet[0].objTestCode[0].Data = "-";
setHeader.objCP_Packet[0].objVersion[0].Data = "-";
setHeader.objCP_Packet[0].objProdCode[0].Data = "-";
setHeader.objCP_Packet[0].uiTestListNo = 0;
}
else
{
setHeader.objCP_Packet[0].objStationName[0].Data = getCPPacket.Value.objStationName[0].Data;
setHeader.objCP_Packet[0].objProdNo_P[0].Data = getCPPacket.Value.objProdNo_P[0].Data;
setHeader.objCP_Packet[0].objProdNo_C[0].Data = getCPPacket.Value.objProdNo_C[0].Data;
setHeader.objCP_Packet[0].objTestType[0].Data = getCPPacket.Value.objTestType[0].Data;
setHeader.objCP_Packet[0].objTestCode[0].Data = getCPPacket.Value.objTestCode[0].Data;
setHeader.objCP_Packet[0].objVersion[0].Data = getCPPacket.Value.objVersion[0].Data;
setHeader.objCP_Packet[0].objProdCode[0].Data = getCPPacket.Value.objProdCode[0].Data;
setHeader.objCP_Packet[0].uiTestListNo = getCPPacket.Value.uiTestListNo;
}
setHeader.objOptionName[0].Data = strGetFileName;
setHeader.objOptionExtension[0].Data = strGetExtension;
setHeader.uiSourDataNum = i + 1;
setHeader.uiDestDataNum = uiMakeCnt;
object getPacket = SystemXNetSerialization.SelectPacket(setHeader.uiDataLength);
if (getPacket == null) throw new Exception("SystemXNetSerialization.SelectPacket Failed.");
int iBodySize = Marshal.SizeOf(getPacket);
byte[] ucBodyArray = new byte[iBodySize];
getPacket = Convert.ChangeType(SystemXNetSerialization.RawDeSerialize(ucBodyArray, getPacket.GetType()), getPacket.GetType());
Array.Copy(ucSendData, (byte[])getPacket.GetType().GetMethod("Data").Invoke(getPacket, null), ucSendData.Count());
setHeader.uiBodyLength = (uint)iBodySize;
setHeader.uiPacketLength = (uint)(iHeaderSize + iBodySize);
byte[] SendHeadBuffer = SystemXNetSerialization.RawSerialize(setHeader, Marshal.SizeOf(setHeader));
byte[] SendBodyBuffer = SystemXNetSerialization.RawSerialize(getPacket, Marshal.SizeOf(getPacket));
ucGetStreamBytes = HeadTailMake(setHeader.uiPacketLength, SendHeadBuffer, SendBodyBuffer);
listStreamRawData.Add(ucGetStreamBytes);
}
//string strMessage = Encoding.Unicode.GetString(ucGetFileBytes, 0, ucGetFileBytes.Length) + "\r\n";
}
}
catch (Exception e)
{
//throw new CommonPacketMarshalException("General packet marshalling failed.[SystemX.Common : COMMON.ObjectToByteStreamList]");
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"General packet marshalling failed.[SystemX.Common : COMMON.ObjectToByteStreamList]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
}
finally
{
;//Until unused
}
return listStreamRawData;
}
}
}

465
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Serialization.cs Normal file
View File

@ -0,0 +1,465 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
using SystemX.Net.BaseProtocol;
//프로토콜 직렬화/역직렬화 기능
//기본 프로토콜 정의 포함
namespace SystemX.Common.Serialization
{
public static class SystemXNetSerialization
{
private const int MAX_STEP_PACKET_SIZE = 256000;
public const int MAX_PACKET_SIZE = 512000; //1024000 <- 256000 <- 65536;
//public const int MAX_PACKET_SIZE = 256000; //1024000 <- 256000 <- 65536;
public const int PACKET_NUM = 251; // 250 <- 64;
public static object SelectPacket(uint uiDataSize)
{
object objPacket = null;
//uint uiLowBytes = 0;
//uint uiHighBytes = 1024;
//
/*
FieldInfo field = typeof(StructureToMarshalFrom).GetField("_value1");
object[] attributes = field.GetCustomAttributes(typeof(MarshalAsAttribute), false);
MarshalAsAttribute marshal = (MarshalAsAttribute) attributes[0];
int sizeConst = marshal.SizeConst
*/
int iPacketPos = GetPacketPos(uiDataSize);
objPacket = SetPacketObject(iPacketPos);
/*
for (int i = 0; i < PACKET_NUM; i++)
{
uiLowBytes = (uint)(1024 * i);
uiHighBytes = (uint)(1024 * (i + 1));
if (uiDataSize >= uiLowBytes && uiDataSize <= uiHighBytes)
{
objPacket = SetPacketObject(i);
break;
}
}
*/
return objPacket;
}
public static int SelectPacketSize(PACKET_SIZE SET_SIZE)
{
object objPacket = null;
int iSetSize = 0;
objPacket = SetPacketObject((int)SET_SIZE);
HEADER_PACKET HeaderPacket = new HEADER_PACKET();
int iHeadSize = Marshal.SizeOf(HeaderPacket);
int iPacketSize = 0;
if (objPacket != null)
iPacketSize = Marshal.SizeOf(objPacket);
iSetSize = iHeadSize + iPacketSize;
return iSetSize;
}
//------------------------------------------------------------------------------------------
private static int GetPacketPos(uint uiDataSize)
{
int uiGetSizeMajor = -1;
/*uiGetSizeMajor = (int)(uiDataSize / 1024);
int uiGetSizeMinor = (int)(uiDataSize % 1024);
if (uiGetSizeMajor == 0)
uiGetSizeMajor = 0;
if (uiGetSizeMinor == 0)
uiGetSizeMajor -= 1;*/
if (uiDataSize > MAX_STEP_PACKET_SIZE)
{
if (uiDataSize <= 512000) uiGetSizeMajor = 250;
/*
else if (uiDataSize <= 1024000) uiGetSizeMajor = 251;
else if (uiDataSize <= 2048000) uiGetSizeMajor = 252;
else if (uiDataSize <= 3072000) uiGetSizeMajor = 253;
else if (uiDataSize <= 4096000) uiGetSizeMajor = 254;
else if (uiDataSize <= 5120000) uiGetSizeMajor = 255;
else if (uiDataSize <= 6144000) uiGetSizeMajor = 256;
else if (uiDataSize <= 7168000) uiGetSizeMajor = 257;
else if (uiDataSize <= 8192000) uiGetSizeMajor = 258;
else if (uiDataSize <= 9216000) uiGetSizeMajor = 259;
else if (uiDataSize <= 10240000) uiGetSizeMajor = 260;
*/
}
else
{
uiGetSizeMajor = (int)(uiDataSize / 1024);
int uiGetSizeMinor = (int)(uiDataSize % 1024);
if (uiGetSizeMajor == 0)
uiGetSizeMajor = 0;
if (uiGetSizeMinor == 0)
uiGetSizeMajor -= 1;
}
return uiGetSizeMajor;
}
//------------------------------------------------------------------------------------------
private static object SetPacketObject(int iSelectPos)
{
object objPacket = null;
switch (iSelectPos)
{
case 0: objPacket = new DATA_PACKET_1024(); break;
case 1: objPacket = new DATA_PACKET_2048(); break;
case 2: objPacket = new DATA_PACKET_3072(); break;
case 3: objPacket = new DATA_PACKET_4096(); break;
case 4: objPacket = new DATA_PACKET_5120(); break;
case 5: objPacket = new DATA_PACKET_6144(); break;
case 6: objPacket = new DATA_PACKET_7168(); break;
case 7: objPacket = new DATA_PACKET_8192(); break;
case 8: objPacket = new DATA_PACKET_9216(); break;
case 9: objPacket = new DATA_PACKET_10240(); break;
case 10: objPacket = new DATA_PACKET_11264(); break;
case 11: objPacket = new DATA_PACKET_12288(); break;
case 12: objPacket = new DATA_PACKET_13312(); break;
case 13: objPacket = new DATA_PACKET_14336(); break;
case 14: objPacket = new DATA_PACKET_15360(); break;
case 15: objPacket = new DATA_PACKET_16384(); break;
case 16: objPacket = new DATA_PACKET_17408(); break;
case 17: objPacket = new DATA_PACKET_18432(); break;
case 18: objPacket = new DATA_PACKET_19456(); break;
case 19: objPacket = new DATA_PACKET_20480(); break;
case 20: objPacket = new DATA_PACKET_21504(); break;
case 21: objPacket = new DATA_PACKET_22528(); break;
case 22: objPacket = new DATA_PACKET_23552(); break;
case 23: objPacket = new DATA_PACKET_24576(); break;
case 24: objPacket = new DATA_PACKET_25600(); break;
case 25: objPacket = new DATA_PACKET_26624(); break;
case 26: objPacket = new DATA_PACKET_27648(); break;
case 27: objPacket = new DATA_PACKET_28672(); break;
case 28: objPacket = new DATA_PACKET_29696(); break;
case 29: objPacket = new DATA_PACKET_30720(); break;
case 30: objPacket = new DATA_PACKET_31744(); break;
case 31: objPacket = new DATA_PACKET_32768(); break;
case 32: objPacket = new DATA_PACKET_33792(); break;
case 33: objPacket = new DATA_PACKET_34816(); break;
case 34: objPacket = new DATA_PACKET_35840(); break;
case 35: objPacket = new DATA_PACKET_36864(); break;
case 36: objPacket = new DATA_PACKET_37888(); break;
case 37: objPacket = new DATA_PACKET_38912(); break;
case 38: objPacket = new DATA_PACKET_39936(); break;
case 39: objPacket = new DATA_PACKET_40960(); break;
case 40: objPacket = new DATA_PACKET_41984(); break;
case 41: objPacket = new DATA_PACKET_43008(); break;
case 42: objPacket = new DATA_PACKET_44032(); break;
case 43: objPacket = new DATA_PACKET_45056(); break;
case 44: objPacket = new DATA_PACKET_46080(); break;
case 45: objPacket = new DATA_PACKET_47104(); break;
case 46: objPacket = new DATA_PACKET_48128(); break;
case 47: objPacket = new DATA_PACKET_49152(); break;
case 48: objPacket = new DATA_PACKET_50176(); break;
case 49: objPacket = new DATA_PACKET_51200(); break;
case 50: objPacket = new DATA_PACKET_52224(); break;
case 51: objPacket = new DATA_PACKET_53248(); break;
case 52: objPacket = new DATA_PACKET_54272(); break;
case 53: objPacket = new DATA_PACKET_55296(); break;
case 54: objPacket = new DATA_PACKET_56320(); break;
case 55: objPacket = new DATA_PACKET_57344(); break;
case 56: objPacket = new DATA_PACKET_58368(); break;
case 57: objPacket = new DATA_PACKET_59392(); break;
case 58: objPacket = new DATA_PACKET_60416(); break;
case 59: objPacket = new DATA_PACKET_61440(); break;
case 60: objPacket = new DATA_PACKET_62464(); break;
case 61: objPacket = new DATA_PACKET_63488(); break;
case 62: objPacket = new DATA_PACKET_64512(); break;
case 63: objPacket = new DATA_PACKET_65536(); break;
case 64: objPacket = new DATA_PACKET_66560(); break;
case 65: objPacket = new DATA_PACKET_67584(); break;
case 66: objPacket = new DATA_PACKET_68608(); break;
case 67: objPacket = new DATA_PACKET_69632(); break;
case 68: objPacket = new DATA_PACKET_70656(); break;
case 69: objPacket = new DATA_PACKET_71680(); break;
case 70: objPacket = new DATA_PACKET_72704(); break;
case 71: objPacket = new DATA_PACKET_73728(); break;
case 72: objPacket = new DATA_PACKET_74752(); break;
case 73: objPacket = new DATA_PACKET_75776(); break;
case 74: objPacket = new DATA_PACKET_76800(); break;
case 75: objPacket = new DATA_PACKET_77824(); break;
case 76: objPacket = new DATA_PACKET_78848(); break;
case 77: objPacket = new DATA_PACKET_79872(); break;
case 78: objPacket = new DATA_PACKET_80896(); break;
case 79: objPacket = new DATA_PACKET_81920(); break;
case 80: objPacket = new DATA_PACKET_82944(); break;
case 81: objPacket = new DATA_PACKET_83968(); break;
case 82: objPacket = new DATA_PACKET_84992(); break;
case 83: objPacket = new DATA_PACKET_86016(); break;
case 84: objPacket = new DATA_PACKET_87040(); break;
case 85: objPacket = new DATA_PACKET_88064(); break;
case 86: objPacket = new DATA_PACKET_89088(); break;
case 87: objPacket = new DATA_PACKET_90112(); break;
case 88: objPacket = new DATA_PACKET_91136(); break;
case 89: objPacket = new DATA_PACKET_92160(); break;
case 90: objPacket = new DATA_PACKET_93184(); break;
case 91: objPacket = new DATA_PACKET_94208(); break;
case 92: objPacket = new DATA_PACKET_95232(); break;
case 93: objPacket = new DATA_PACKET_96256(); break;
case 94: objPacket = new DATA_PACKET_97280(); break;
case 95: objPacket = new DATA_PACKET_98304(); break;
case 96: objPacket = new DATA_PACKET_99328(); break;
case 97: objPacket = new DATA_PACKET_100352(); break;
case 98: objPacket = new DATA_PACKET_101376(); break;
case 99: objPacket = new DATA_PACKET_102400(); break;
case 100: objPacket = new DATA_PACKET_103424(); break;
case 101: objPacket = new DATA_PACKET_104448(); break;
case 102: objPacket = new DATA_PACKET_105472(); break;
case 103: objPacket = new DATA_PACKET_106496(); break;
case 104: objPacket = new DATA_PACKET_107520(); break;
case 105: objPacket = new DATA_PACKET_108544(); break;
case 106: objPacket = new DATA_PACKET_109568(); break;
case 107: objPacket = new DATA_PACKET_110592(); break;
case 108: objPacket = new DATA_PACKET_111616(); break;
case 109: objPacket = new DATA_PACKET_112640(); break;
case 110: objPacket = new DATA_PACKET_113664(); break;
case 111: objPacket = new DATA_PACKET_114688(); break;
case 112: objPacket = new DATA_PACKET_115712(); break;
case 113: objPacket = new DATA_PACKET_116736(); break;
case 114: objPacket = new DATA_PACKET_117760(); break;
case 115: objPacket = new DATA_PACKET_118784(); break;
case 116: objPacket = new DATA_PACKET_119808(); break;
case 117: objPacket = new DATA_PACKET_120832(); break;
case 118: objPacket = new DATA_PACKET_121856(); break;
case 119: objPacket = new DATA_PACKET_122880(); break;
case 120: objPacket = new DATA_PACKET_123904(); break;
case 121: objPacket = new DATA_PACKET_124928(); break;
case 122: objPacket = new DATA_PACKET_125952(); break;
case 123: objPacket = new DATA_PACKET_126976(); break;
case 124: objPacket = new DATA_PACKET_128000(); break;
case 125: objPacket = new DATA_PACKET_129024(); break;
case 126: objPacket = new DATA_PACKET_130048(); break;
case 127: objPacket = new DATA_PACKET_131072(); break;
case 128: objPacket = new DATA_PACKET_132096(); break;
case 129: objPacket = new DATA_PACKET_133120(); break;
case 130: objPacket = new DATA_PACKET_134144(); break;
case 131: objPacket = new DATA_PACKET_135168(); break;
case 132: objPacket = new DATA_PACKET_136192(); break;
case 133: objPacket = new DATA_PACKET_137216(); break;
case 134: objPacket = new DATA_PACKET_138240(); break;
case 135: objPacket = new DATA_PACKET_139264(); break;
case 136: objPacket = new DATA_PACKET_140288(); break;
case 137: objPacket = new DATA_PACKET_141312(); break;
case 138: objPacket = new DATA_PACKET_142336(); break;
case 139: objPacket = new DATA_PACKET_143360(); break;
case 140: objPacket = new DATA_PACKET_144384(); break;
case 141: objPacket = new DATA_PACKET_145408(); break;
case 142: objPacket = new DATA_PACKET_146432(); break;
case 143: objPacket = new DATA_PACKET_147456(); break;
case 144: objPacket = new DATA_PACKET_148480(); break;
case 145: objPacket = new DATA_PACKET_149504(); break;
case 146: objPacket = new DATA_PACKET_150528(); break;
case 147: objPacket = new DATA_PACKET_151552(); break;
case 148: objPacket = new DATA_PACKET_152576(); break;
case 149: objPacket = new DATA_PACKET_153600(); break;
case 150: objPacket = new DATA_PACKET_154624(); break;
case 151: objPacket = new DATA_PACKET_155648(); break;
case 152: objPacket = new DATA_PACKET_156672(); break;
case 153: objPacket = new DATA_PACKET_157696(); break;
case 154: objPacket = new DATA_PACKET_158720(); break;
case 155: objPacket = new DATA_PACKET_159744(); break;
case 156: objPacket = new DATA_PACKET_160768(); break;
case 157: objPacket = new DATA_PACKET_161792(); break;
case 158: objPacket = new DATA_PACKET_162816(); break;
case 159: objPacket = new DATA_PACKET_163840(); break;
case 160: objPacket = new DATA_PACKET_164864(); break;
case 161: objPacket = new DATA_PACKET_165888(); break;
case 162: objPacket = new DATA_PACKET_166912(); break;
case 163: objPacket = new DATA_PACKET_167936(); break;
case 164: objPacket = new DATA_PACKET_168960(); break;
case 165: objPacket = new DATA_PACKET_169984(); break;
case 166: objPacket = new DATA_PACKET_171008(); break;
case 167: objPacket = new DATA_PACKET_172032(); break;
case 168: objPacket = new DATA_PACKET_173056(); break;
case 169: objPacket = new DATA_PACKET_174080(); break;
case 170: objPacket = new DATA_PACKET_175104(); break;
case 171: objPacket = new DATA_PACKET_176128(); break;
case 172: objPacket = new DATA_PACKET_177152(); break;
case 173: objPacket = new DATA_PACKET_178176(); break;
case 174: objPacket = new DATA_PACKET_179200(); break;
case 175: objPacket = new DATA_PACKET_180224(); break;
case 176: objPacket = new DATA_PACKET_181248(); break;
case 177: objPacket = new DATA_PACKET_182272(); break;
case 178: objPacket = new DATA_PACKET_183296(); break;
case 179: objPacket = new DATA_PACKET_184320(); break;
case 180: objPacket = new DATA_PACKET_185344(); break;
case 181: objPacket = new DATA_PACKET_186368(); break;
case 182: objPacket = new DATA_PACKET_187392(); break;
case 183: objPacket = new DATA_PACKET_188416(); break;
case 184: objPacket = new DATA_PACKET_189440(); break;
case 185: objPacket = new DATA_PACKET_190464(); break;
case 186: objPacket = new DATA_PACKET_191488(); break;
case 187: objPacket = new DATA_PACKET_192512(); break;
case 188: objPacket = new DATA_PACKET_193536(); break;
case 189: objPacket = new DATA_PACKET_194560(); break;
case 190: objPacket = new DATA_PACKET_195584(); break;
case 191: objPacket = new DATA_PACKET_196608(); break;
case 192: objPacket = new DATA_PACKET_197632(); break;
case 193: objPacket = new DATA_PACKET_198656(); break;
case 194: objPacket = new DATA_PACKET_199680(); break;
case 195: objPacket = new DATA_PACKET_200704(); break;
case 196: objPacket = new DATA_PACKET_201728(); break;
case 197: objPacket = new DATA_PACKET_202752(); break;
case 198: objPacket = new DATA_PACKET_203776(); break;
case 199: objPacket = new DATA_PACKET_204800(); break;
case 200: objPacket = new DATA_PACKET_205824(); break;
case 201: objPacket = new DATA_PACKET_206848(); break;
case 202: objPacket = new DATA_PACKET_207872(); break;
case 203: objPacket = new DATA_PACKET_208896(); break;
case 204: objPacket = new DATA_PACKET_209920(); break;
case 205: objPacket = new DATA_PACKET_210944(); break;
case 206: objPacket = new DATA_PACKET_211968(); break;
case 207: objPacket = new DATA_PACKET_212992(); break;
case 208: objPacket = new DATA_PACKET_214016(); break;
case 209: objPacket = new DATA_PACKET_215040(); break;
case 210: objPacket = new DATA_PACKET_216064(); break;
case 211: objPacket = new DATA_PACKET_217088(); break;
case 212: objPacket = new DATA_PACKET_218112(); break;
case 213: objPacket = new DATA_PACKET_219136(); break;
case 214: objPacket = new DATA_PACKET_220160(); break;
case 215: objPacket = new DATA_PACKET_221184(); break;
case 216: objPacket = new DATA_PACKET_222208(); break;
case 217: objPacket = new DATA_PACKET_223232(); break;
case 218: objPacket = new DATA_PACKET_224256(); break;
case 219: objPacket = new DATA_PACKET_225280(); break;
case 220: objPacket = new DATA_PACKET_226304(); break;
case 221: objPacket = new DATA_PACKET_227328(); break;
case 222: objPacket = new DATA_PACKET_228352(); break;
case 223: objPacket = new DATA_PACKET_229376(); break;
case 224: objPacket = new DATA_PACKET_230400(); break;
case 225: objPacket = new DATA_PACKET_231424(); break;
case 226: objPacket = new DATA_PACKET_232448(); break;
case 227: objPacket = new DATA_PACKET_233472(); break;
case 228: objPacket = new DATA_PACKET_234496(); break;
case 229: objPacket = new DATA_PACKET_235520(); break;
case 230: objPacket = new DATA_PACKET_236544(); break;
case 231: objPacket = new DATA_PACKET_237568(); break;
case 232: objPacket = new DATA_PACKET_238592(); break;
case 233: objPacket = new DATA_PACKET_239616(); break;
case 234: objPacket = new DATA_PACKET_240640(); break;
case 235: objPacket = new DATA_PACKET_241664(); break;
case 236: objPacket = new DATA_PACKET_242688(); break;
case 237: objPacket = new DATA_PACKET_243712(); break;
case 238: objPacket = new DATA_PACKET_244736(); break;
case 239: objPacket = new DATA_PACKET_245760(); break;
case 240: objPacket = new DATA_PACKET_246784(); break;
case 241: objPacket = new DATA_PACKET_247808(); break;
case 242: objPacket = new DATA_PACKET_248832(); break;
case 243: objPacket = new DATA_PACKET_249856(); break;
case 244: objPacket = new DATA_PACKET_250880(); break;
case 245: objPacket = new DATA_PACKET_251904(); break;
case 246: objPacket = new DATA_PACKET_252928(); break;
case 247: objPacket = new DATA_PACKET_253952(); break;
case 248: objPacket = new DATA_PACKET_254976(); break;
case 249: objPacket = new DATA_PACKET_256000(); break;
case 250: objPacket = new DATA_PACKET_512000(); break;
/*
case 251: objPacket = new DATA_PACKET_1024000(); break;
case 252: objPacket = new DATA_PACKET_2048000(); break;
case 253: objPacket = new DATA_PACKET_3072000(); break;
case 254: objPacket = new DATA_PACKET_4096000(); break;
case 255: objPacket = new DATA_PACKET_5120000(); break;
case 256: objPacket = new DATA_PACKET_6144000(); break;
case 257: objPacket = new DATA_PACKET_7168000(); break;
case 258: objPacket = new DATA_PACKET_8192000(); break;
case 259: objPacket = new DATA_PACKET_9216000(); break;
case 260: objPacket = new DATA_PACKET_10240000(); break;
*/
default: objPacket = null; break;
}
return objPacket;
}
//------------------------------------------------------------------------------------------
public static byte[] RawSerialize(object ShmStruct, int irsStructSize)
{
IntPtr buffer = Marshal.AllocHGlobal(irsStructSize);
Marshal.StructureToPtr(ShmStruct, buffer, false);
byte[] RawData = new byte[irsStructSize];
Marshal.Copy(buffer, RawData, 0, irsStructSize);
Marshal.FreeHGlobal(buffer);
return RawData;
}
//------------------------------------------------------------------------------------------
public static object RawDeSerialize(byte[] RawData, Type typeData, int iOption = 0)
{
int RawSize = 0;
if (iOption == 0)
RawSize = Marshal.SizeOf(typeData);
else
RawSize = iOption;
//Size Over
if (RawSize > RawData.Length)
return null;
IntPtr buffer = Marshal.AllocHGlobal(RawSize);
Marshal.Copy(RawData, 0, buffer, RawSize);
object retobj = Marshal.PtrToStructure(buffer, typeData);
Marshal.FreeHGlobal(buffer);
return retobj;
}
//------------------------------------------------------------------------------------------
public static byte[] ObjectToByteArray(object obj)
{
if (obj == null) return null;
BinaryFormatter bf = new BinaryFormatter();
MemoryStream ms = new MemoryStream();
bf.Serialize(ms, obj);
return ms.ToArray();
}
//------------------------------------------------------------------------------------------
public static object ByteArrayToObject(byte[] byteArr)
{
if (byteArr == null) return null;
MemoryStream ms = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
ms.Write(byteArr, 0, byteArr.Length);
ms.Seek(0, SeekOrigin.Begin);
object obj = bf.Deserialize(ms);
return obj;
}
public static T ByteArrayToObject<T>(byte[] byteArr)
{
if (byteArr == null) return default(T);
MemoryStream ms = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
ms.Write(byteArr, 0, byteArr.Length);
ms.Seek(0, SeekOrigin.Begin);
return (T)Convert.ChangeType(bf.Deserialize(ms), typeof(T));
}
}
}

49
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/AppWinControl.cs Normal file
View File

@ -0,0 +1,49 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
namespace SystemX.Net.Platform.Common.Util
{
public static class AppWinControl
{
public enum eShowType
{
SW_HIDE = 0, //Hides the window and activates another window.
SW_MAXIMIZE = 3, //Maximizes the specified window.
SW_MINIMIZE = 6, //Minimizes the specified window and activates the next top-level window in the Z order.
SW_RESTORE = 9, //Activates and displays the window. If the window is minimized or maximized, the system restores it to its original size and position. An application should specify this flag when restoring a minimized window.
SW_SHOW = 5, //Activates the window and displays it in its current size and position.
SW_SHOWDEFAULT = 10, //Sets the show state based on the SW_ value specified in the STARTUPINFO structure passed to the CreateProcess function by the program that started the application.
SW_SHOWMAXIMIZED = 3, //Activates the window and displays it as a maximized window.
SW_SHOWMINIMIZED = 2, //Activates the window and displays it as a minimized window.
SW_SHOWMINNOACTIVE = 7, //Displays the window as a minimized window. This value is similar to SW_SHOWMINIMIZED, except the window is not activated.
SW_SHOWNA = 8, //Displays the window in its current size and position. This value is similar to SW_SHOW, except that the window is not activated.
SW_SHOWNOACTIVATE = 4, //Displays a window in its most recent size and position. This value is similar to SW_SHOWNORMAL, except that the window is not activated.
SW_SHOWNORMAL = 1
}
[DllImport("user32.dll")]
public static extern IntPtr ExtGetWindowRect(IntPtr hWnd, out Rect lpRect);
[DllImport("user32.dll")]
public static extern bool ExtPrintWindow(IntPtr hWnd, IntPtr hdcBlt, int nFlags);
[DllImport("user32.dll")]
private static extern int ExtSetForegroundWindow(IntPtr hWnd);
private const int SW_RESTORE = 9;
[DllImport("user32.dll")]
private static extern IntPtr ExtShowWindow(IntPtr hWnd, int nCmdShow);
public static IntPtr GetWindowRect(IntPtr hWnd, out Rect lpRect) { return ExtGetWindowRect(hWnd, out lpRect); }
public static bool PrintWindow(IntPtr hWnd, IntPtr hdcBlt, int nFlags) { return ExtPrintWindow(hWnd, hdcBlt, nFlags); }
public static int SetForegroundWindow(IntPtr hWnd) { return ExtSetForegroundWindow(hWnd); }
public static IntPtr ShowWindow(IntPtr hWnd, int nCmdShow) { return ExtShowWindow(hWnd, nCmdShow); }
}
}

338
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/ApplicationIdleTimer.cs Normal file
View File

@ -0,0 +1,338 @@
using System;
// http://www.codeproject.com/Articles/13756/Detecting-Application-Idleness
namespace SystemX.Net.Platform.Common.Util
{
/// <summary>
/// ApplicationIdleTimer provides a convenient way of
/// processing events only during application dormancy.
/// Why use this instead of the Application.Idle event?
/// That event gets fired EVERY TIME the message stack
/// is exhausted, which basically means it fires very
/// frequently. With this, you only get events when
/// the application is actually idle.
/// </summary>
public class ApplicationIdleTimer
{
#region Static Members and Events
// private singleton
private static ApplicationIdleTimer instance = null;
// Notes:
// Could have utilized the System.Timers.ElapsedEventArgs, but that
// only provides the time an event happend (even though it's called
// "Elapsed" not "Timed" EventArgs). I figgure most listeners care
// less *WHEN* the app went idle, but rather *HOW LONG* it has been
// idle.
/// <summary>
/// EventArgs for an ApplicationIdle event.
/// </summary>
public class ApplicationIdleEventArgs : EventArgs
{
// time of last idle
private DateTime _idleSince;
// duration of "idleness"
private TimeSpan _idleTime;
/// <summary>
/// Internal constructor
/// </summary>
/// <param name="idleSince">Time app was declared idle</param>
internal ApplicationIdleEventArgs(DateTime idleSince) : base()
{
_idleSince = idleSince;
_idleTime = new TimeSpan(DateTime.Now.Ticks - idleSince.Ticks);
}
/// <summary>
/// Timestamp of the last time the application was "active".
/// </summary>
public DateTime IdleSince
{
get { return _idleSince; }
}
/// <summary>
/// Duration of time the application has been idle.
/// </summary>
public TimeSpan IdleDuration
{
get { return _idleTime; }
}
}
/// <summary>
/// ApplicationIdle event handler.
/// </summary>
public delegate void ApplicationIdleEventHandler(ApplicationIdleEventArgs e);
/// <summary>
/// Hook into the ApplicationIdle event to monitor inactivity.
/// It will fire AT MOST once per second.
/// </summary>
public static event ApplicationIdleEventHandler ApplicationIdle;
#endregion
#region Private Members
// Timer used to guarentee perodic updates.
private System.Timers.Timer _timer;
// Tracks idle state
private bool isIdle;
// Last time application was declared "idle"
private System.DateTime lastAppIdleTime;
// Last time we checked for GUI activity
private long lastIdleCheckpoint;
// Running count of Application.Idle events recorded since a checkpoint.
// Expressed as a long (instead of int) for math.
private long idlesSinceCheckpoint;
// Number of ticks used by application process at last checkpoint
private long cpuTime;
// Last time we checked for cpu activity
private long lastCpuCheckpoint;
// These values can be adjusted through the static properties:
// Maximum "activity" (Application.Idle events per second) that will be considered "idle"
// Here it is expressed as minimum ticks between idles.
private long guiThreshold = TimeSpan.TicksPerMillisecond * 50L;
// Maximum CPU use (percentage) that is considered "idle"
private double cpuThreshold = 0.05;
#endregion
#region Constructors
/// <summary>
/// Private constructor. One instance is plenty.
/// </summary>
private ApplicationIdleTimer()
{
// Initialize counters
isIdle = false;
lastAppIdleTime = DateTime.Now;
lastIdleCheckpoint = lastCpuCheckpoint = DateTime.UtcNow.Ticks;
idlesSinceCheckpoint = cpuTime = 0;
// Set up the timer and the counters
_timer = new System.Timers.Timer(500); // every half-second.
_timer.Enabled = true;
_timer.Start();
// Hook into the events
_timer.Elapsed += new System.Timers.ElapsedEventHandler(Heartbeat);
System.Windows.Forms.Application.Idle += new EventHandler(Application_Idle);
}
/// <summary>
/// Static initialization. Called once per AppDomain.
/// </summary>
static ApplicationIdleTimer()
{
// Create the singleton.
if (instance == null)
{
instance = new ApplicationIdleTimer();
}
}
#endregion
#region Private Methods
private void Heartbeat(object sender, System.Timers.ElapsedEventArgs e)
{
// First we need to do here is compensate for the
// "heartbeat", since it will result in an 'extra'
// Idle firing .. just don't cause a divide by zero!
if (idlesSinceCheckpoint > 1)
idlesSinceCheckpoint--;
bool newIdle = isIdle;
long delta = DateTime.UtcNow.Ticks - lastIdleCheckpoint;
// Determine average idle events per second. Done manually here
// instead of using the ComputeGUIActivity() method to avoid the
// unnecessary numeric conversion and use of a TimeSpan object.
if (delta >= TimeSpan.TicksPerSecond)
{
// It's been over a second since last checkpoint,
// so determine how "busy" the app has been over that timeframe.
if (idlesSinceCheckpoint == 0 || delta / idlesSinceCheckpoint >= guiThreshold)
{
// Minimal gui activity. Check recent CPU activity.
if (cpuThreshold < 1.0)
newIdle = (ComputeCPUUsage(true) < cpuThreshold);
else
newIdle = true;
}
else
{
newIdle = false;
}
// Update counters if state changed.
if (newIdle != isIdle)
{
isIdle = newIdle;
if (newIdle)
lastAppIdleTime = DateTime.Now.AddTicks(-1L * delta);
}
// Reset checkpoint.
lastIdleCheckpoint = DateTime.UtcNow.Ticks;
idlesSinceCheckpoint = 0;
// Last but not least, if idle, raise the event.
if (newIdle)
OnApplicationIdle();
}
}
private void Application_Idle(object sender, EventArgs e)
{
// Increment idle counter.
idlesSinceCheckpoint++;
}
internal double ComputeCPUUsage(bool resetCounters)
{
long delta = DateTime.UtcNow.Ticks - lastCpuCheckpoint;
double pctUse = 0.0;
try
{
// Get total time this process has used the cpu.
long cpu = System.Diagnostics.Process.GetCurrentProcess().TotalProcessorTime.Ticks;
// Compute usage.
if (delta > 0)
pctUse = ((double)(cpu - cpuTime)) / (double)delta;
else
pctUse = ((cpu - cpuTime) == 0 ? 0.0 : 1.0);
// Update counter and checkpoint if told OR if delta is at least a quarter second.
// This is to prevent inaccurate readings due to frequent OR infrequent calls.
if (resetCounters || 4L * delta >= TimeSpan.TicksPerSecond)
{
lastCpuCheckpoint = DateTime.UtcNow.Ticks;
cpuTime = cpu;
// Update idle status if above threshold.
if (!resetCounters && isIdle && pctUse > cpuThreshold)
isIdle = false;
}
}
catch (Exception e)
{
// Probably a security thing. Just ignore.
pctUse = double.NaN;
}
return pctUse;
}
internal double ComputeGUIActivity()
{
if (idlesSinceCheckpoint <= 0) return 0.0;
TimeSpan delta = new TimeSpan(DateTime.UtcNow.Ticks - lastIdleCheckpoint);
if (delta.Ticks == 0)
{
// Clock hasn't updated yet. Return a "real" value
// based on counter (either 0 or twice the threshold).
return (idlesSinceCheckpoint == 0 ? 0.0 : ((double)TimeSpan.TicksPerSecond / (double)instance.guiThreshold) * 2.0);
}
// Expressed as activity (number of idles) per second.
return ((double)idlesSinceCheckpoint / delta.TotalSeconds);
// Note that this method, unlike his CPU brother, does not reset any counters.
// The gui activity counters are reset once a second by the Heartbeat.
}
private void OnApplicationIdle()
{
// Check to see if anyone cares.
if (ApplicationIdle == null) return;
// Build the message
ApplicationIdleEventArgs e = new ApplicationIdleEventArgs(this.lastAppIdleTime);
// Iterate over all listeners
foreach (MulticastDelegate multicast in ApplicationIdle.GetInvocationList())
{
// Raise the event
multicast.DynamicInvoke(new object[] { e });
}
}
#endregion
#region Static Properties
/// <summary>
/// Returns the percent CPU use for the current process (0.0-1.0).
/// Will return double.NaN if indeterminate.
/// </summary>
public static double CurrentCPUUsage
{
get { return instance.ComputeCPUUsage(false); }
}
/// <summary>
/// Returns an "indication" of the gui activity, expressed as
/// activity per second. 0 indicates no activity.
/// GUI activity includes user interactions (typing,
/// moving mouse) as well as events, paint operations, etc.
/// </summary>
public static double CurrentGUIActivity
{
get { return instance.ComputeGUIActivity(); }
}
/// <summary>
/// Returns the *last determined* idle state. Idle state is
/// recomputed once per second. Both the gui and the cpu must
/// be idle for this property to be true.
/// </summary>
public static bool IsIdle
{
get { return instance.isIdle; }
}
/// <summary>
/// The threshold (gui activity) for determining idleness.
/// GUI activity below this level is considered "idle".
/// </summary>
public static double GUIActivityThreshold
{
get
{
return ((double)TimeSpan.TicksPerSecond / (double)instance.guiThreshold);
}
set
{
// validate value
if (value <= 0.0)
throw new ArgumentOutOfRangeException("GUIActivityThreshold", value, "GUIActivityThreshold must be greater than zero.");
instance.guiThreshold = (long)((double)TimeSpan.TicksPerSecond / value);
}
}
/// <summary>
/// The threshold (cpu usage) for determining idleness.
/// CPU usage below this level is considered "idle".
/// A value >= 1.0 will disable CPU idle checking.
/// </summary>
public static double CPUUsageThreshold
{
get { return instance.cpuThreshold; }
set
{
if (value == instance.cpuThreshold)
return;
// validate value
if (value < 0.0)
throw new ArgumentOutOfRangeException("CPUUsageThreshold", value, "Negative values are not allowed.");
instance.cpuThreshold = value;
}
}
#endregion
}
}

301
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/CommonUtil.cs Normal file
View File

@ -0,0 +1,301 @@
using Microsoft.Win32.SafeHandles;
using System;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using static SystemX.Net.Platform.Common.Util.LogMessage;
namespace SystemX.Net.Platform.Common.Util
{
public static class ConsoleUtil
{
static bool ConsoleShowState = false;
const int SW_HIDE = 0;
const int SW_SHOW = 5;
// STD_INPUT_HANDLE (DWORD): -10 is the standard input device.
const int STD_INPUT_HANDLE = -10;
/// <summary>
/// SC_CLOSE
/// </summary>
private const uint SC_CLOSE = 0xf060;
/// <summary>
/// MF_ENABLED
/// </summary>
private const uint MF_ENABLED = 0x00000000;
/// <summary>
/// MF_GRAYED
/// </summary>
private const uint MF_GRAYED = 0x00000001;
[DllImport("kernel32.dll")]
static extern IntPtr GetConsoleWindow();
[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr GetStdHandle(int nStdHandle);
[DllImport("kernel32.dll")]
static extern bool GetConsoleMode(IntPtr hConsoleHandle, out uint lpMode);
[DllImport("kernel32.dll")]
static extern bool SetConsoleMode(IntPtr hConsoleHandle, uint dwMode);
[DllImport("user32.dll")]
static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
#region 시스템 메뉴 구하기 - GetSystemMenu(windowHandle, revert)
/// <summary>
/// 시스템 메뉴 구하기
/// </summary>
/// <param name="windowHandle">윈도우 핸들</param>
/// <param name="revert">메뉴 복사 핸들 여부</param>
/// <returns>시스템 메뉴 핸들</returns>
[DllImport("user32.dll")]
private static extern IntPtr GetSystemMenu(IntPtr windowHandle, bool revert);
#endregion
#region 메뉴 항목 이용 가능 여부 설정하기 - EnableMenuItem(menuHandle, menuItemID, enabled)
/// <summary>
/// 메뉴 항목 이용 가능 여부 설정하기
/// </summary>
/// <param name="menuHandle">메뉴 핸들</param>
/// <param name="menuItemID">메뉴 항목 ID</param>
/// <param name="enabled">이용 가능 여부</param>
/// <returns>처리 결과</returns>
[DllImport("user32.dll")]
private static extern bool EnableMenuItem(IntPtr menuHandle, uint menuItemID, uint enabled);
#endregion
public static void ConsoleVisibleControl()
{
var handle = GetConsoleWindow();
if (ConsoleShowState)
ConsoleHide(handle);
else
ConsoleShow(handle);
}
public static void ConsoleHide()
{
var handle = GetConsoleWindow();
var consoleHandle = GetStdHandle(STD_INPUT_HANDLE);
const uint ENABLE_QUICK_EDIT = 0x0040;
const uint ENABLE_MOUSE_INPUT = 0x0010;
uint consoleMode = 0x0;
// get current console mode
if (!GetConsoleMode(consoleHandle, out consoleMode))
{
// Error: Unable to get console mode.
return;
}
// Clear the quick edit bit in the mode flags
consoleMode &= ~ENABLE_QUICK_EDIT;
consoleMode &= ~ENABLE_MOUSE_INPUT;
// set the new mode
if (!SetConsoleMode(consoleHandle, consoleMode))
{
//ERROR: Unable to set console mode
return;
}
// Hide
ShowWindow(handle, SW_HIDE);
ConsoleShowState = false;
}
public static void ConsoleHide(IntPtr handle)
{
// Hide
ShowWindow(handle, SW_HIDE);
ConsoleShowState = false;
}
public static void ConsoleShow(IntPtr handle)
{
// Show
SetCloseButtonEnabled(handle, false);
ShowWindow(handle, SW_SHOW);
ConsoleShowState = true;
}
private static void SetCloseButtonEnabled(IntPtr windowHandle, bool enabled)
{
IntPtr systemMenuHandle = GetSystemMenu(windowHandle, false);
EnableMenuItem(systemMenuHandle, SC_CLOSE, (uint)(MF_ENABLED | (enabled ? MF_ENABLED : MF_GRAYED)));
}
}
public static class CommonUtil
{
public static string GetProfilePath(string programName = "", bool makeDirOnDemand = true)
{
var xProfilePath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
var dir = String.Format(@"{0}\TESTApp\{1}", xProfilePath, programName);
if (makeDirOnDemand && !Directory.Exists(dir))
Directory.CreateDirectory(dir);
return dir;
}
public static PropertyInfo GetProperty(object obj, string propName)
{
return obj.GetType().GetProperty(propName);
}
public static void ClonePropertyValues<T>(T original, T clone)
{
foreach (_PropertyInfo info in original.GetType().GetProperties())
SetPropertyValue(clone, info.Name, info.GetValue(original, null));
}
public static T GetPropertyValue<T>(object obj, string propName)
{
return (T)obj.GetType().GetProperty(propName).GetValue(obj, null);
}
public static void SetPropertyValue(object obj, string propName, object value)
{
obj.GetType().GetProperty(propName).SetValue(obj, value, null);
}
public static Type GetType(string strType)
{
try
{
Type typeResult = Type.GetType("System." + strType, true, true);
return typeResult;
}
catch (Exception ex)
{
MessageOutput.ConsoleWrite("Type Recognition Error: " + ex.Message, ConsoleColor.Red, LogMessageLevel.FATAL);
return null;
}
}
public static Type GetType(Assembly assy, string strNameSpace, string strType)
{
try
{
string strFullName = $"{strNameSpace}." + strType;
Type typeResult = Type.GetType(strFullName, true, true);
return typeResult;
}
catch (Exception ex)
{
MessageOutput.ConsoleWrite("Type Recognition Error: " + ex.Message, ConsoleColor.Red, LogMessageLevel.FATAL);
return null;
}
}
public static string GetStringFromASCII(int[] arrData, bool bReverseBit = false)
{
string sData = string.Empty;
foreach (short s in arrData)
{
byte[] intBytes = BitConverter.GetBytes(s);
byte ucRever;
if (bReverseBit)
{
ucRever = intBytes[0];
intBytes[0] = intBytes[1];
intBytes[1] = ucRever;
}
foreach (byte b in intBytes)
{
if (b == 0)
continue;
sData += ((Char)b).ToString(); // Ascii To Char
}
}
return sData;
}
public static short[] HexStringToBytes(string hexString)
{
if (hexString.Length % 2 != 0)
hexString += "\0";
char[] result = hexString.ToCharArray();
short[] arrShort = new short[hexString.Length / 2];
byte[] bytes = new byte[hexString.Length];
for (int i = 0; i < result.Length; i++)
bytes[i] = Convert.ToByte(result[i]);
for (int i = 0; i < bytes.Length; i += 2)
arrShort[i / 2] = BitConverter.ToInt16(bytes, i);
return arrShort;
}
}
public partial class NativeMethods
{
[DllImportAttribute("kernel32.dll", SetLastError = true, EntryPoint = "CreateFile")]
public static extern SafeFileHandle CreateFileW(
[InAttribute()][MarshalAsAttribute(UnmanagedType.LPWStr)] string lpFileName,
uint dwDesiredAccess,
uint dwShareMode,
[InAttribute()] System.IntPtr lpSecurityAttributes,
uint dwCreationDisposition,
uint dwFlagsAndAttributes,
[InAttribute()] System.IntPtr hTemplateFile
);
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern IntPtr CreateFile(
[MarshalAs(UnmanagedType.LPTStr)] string filename,
[MarshalAs(UnmanagedType.U4)] FileAccess access,
[MarshalAs(UnmanagedType.U4)] FileShare share,
IntPtr securityAttributes,
[MarshalAs(UnmanagedType.U4)] FileMode creationDisposition,
[MarshalAs(UnmanagedType.U4)] FileAttributes flagsAndAttributes,
IntPtr templateFile);
}
public partial class NativeConstants
{
/// GENERIC_WRITE -> (0x40000000L)
public const int GENERIC_WRITE = 1073741824;
public const uint GENERIC_READ = 2147483648;
/// FILE_SHARE_DELETE -> 0x00000004
public const int FILE_SHARE_DELETE = 4;
/// FILE_SHARE_WRITE -> 0x00000002
public const int FILE_SHARE_WRITE = 2;
/// FILE_SHARE_READ -> 0x00000001
public const int FILE_SHARE_READ = 1;
/// OPEN_ALWAYS -> 4
public const int OPEN_ALWAYS = 4;
public const int CREATE_NEW = 1;
}
}

34
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/CustomExceptions.cs Normal file
View File

@ -0,0 +1,34 @@
using System;
namespace SystemX.Net.Platform.Common.Util
{
/// <summary>
/// Subclass should have re-implemented the method by overriding, but it did not.
/// </summary>
public class NotReimplementedException : NotImplementedException
{
public NotReimplementedException() { }
public NotReimplementedException(string message) : base(message) { }
}
/// <summary>
/// Subclass will not re-implemented. So you should not call this subclass method.
/// </summary>
public class WillNotBeReimplementedException : NotImplementedException
{
public WillNotBeReimplementedException() { }
public WillNotBeReimplementedException(string message) : base(message) { }
}
public class UnexpectedCaseOccurredException : InvalidOperationException
{
public UnexpectedCaseOccurredException() { }
public UnexpectedCaseOccurredException(string message) : base(message) { }
}
public class SampleException : Exception
{
public SampleException() { }
public SampleException(string message) : base(message) { }
}
}

252
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/FileSystemUtil.cs Normal file
View File

@ -0,0 +1,252 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace SystemX.Net.Platform.Common.Util
{
public static class FileSystemUtil
{
public static void DeleteFile(string strSourcePath)
{
if (!File.Exists(strSourcePath))
return;
File.Delete(strSourcePath);
}
public static void CopyToDestination(string strSourcePath, string strDesitinationPath, bool bDeleteSrc, bool bOverwrite)
{
if (!Directory.Exists(Path.GetDirectoryName(strDesitinationPath)))
Directory.CreateDirectory(Path.GetDirectoryName(strDesitinationPath));
File.Copy(strSourcePath, strDesitinationPath, bOverwrite);
while(true)
{
FileInfo fileSrc = new FileInfo(strSourcePath);
FileInfo fileDest = new FileInfo(strDesitinationPath);
if (fileSrc.Length == fileDest.Length)
break;
Thread.Sleep(1);
}
if (bDeleteSrc)
DeleteFile(strSourcePath);
}
public static void Compress(DirectoryInfo directorySelected, string strFilePath)
{
using (var fileStream = new FileStream(strFilePath, FileMode.OpenOrCreate))
{
using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Create))
{
foreach (FileInfo file in directorySelected.GetFiles())
{
var entry = zip.CreateEntry(file.Name, CompressionLevel.Optimal);
using (Stream s = entry.Open())
{
FileStream file2Comp = new FileStream(file.FullName, FileMode.Open);
byte[] data = new byte[file2Comp.Length];
file2Comp.Read(data, 0, (int)file2Comp.Length);
s.Write(data, 0, data.Length);
file2Comp.Close();
s.Close();
}
}
}
fileStream.Close();
}
}
public static void AddFile2CompFile(List<string> vstrTargetFilePath, string strCompFilePath)
{
using (var fileStream = new FileStream(strCompFilePath, FileMode.OpenOrCreate))
{
using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Create))
{
foreach (string strFilePath in vstrTargetFilePath)
{
string strTargetFileName = Path.GetFileName(strFilePath);
var entry = zip.CreateEntry(strTargetFileName, CompressionLevel.Optimal);
using (Stream s = entry.Open())
{
FileStream file2Comp = new FileStream(strFilePath, FileMode.Open);
byte[] data = new byte[file2Comp.Length];
file2Comp.Read(data, 0, (int)file2Comp.Length);
s.Write(data, 0, data.Length);
file2Comp.Close();
s.Close();
}
}
}
fileStream.Close();
}
}
public static void CompressStream2CompFile(List<KeyValuePair<string, MemoryStream>> vPairTargetData, string strCompFilePath)
{
using (var fileStream = new FileStream(strCompFilePath, FileMode.OpenOrCreate))
{
using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Create))
{
foreach (KeyValuePair<string, MemoryStream> dataBinFile in vPairTargetData)
{
var entry = zip.CreateEntry(dataBinFile.Key, CompressionLevel.Optimal);
using (Stream s = entry.Open())
{
byte[] data = new byte[dataBinFile.Value.Length];
s.Write(dataBinFile.Value.ToArray(), 0, data.Length);
s.Close();
}
}
}
}
}
public static void Decompress(string strPathZip, string strPath)
{
if (!Directory.Exists(strPath))
Directory.CreateDirectory(strPath);
using (ZipArchive archive = ZipFile.OpenRead(strPathZip))
{
foreach (ZipArchiveEntry entry in archive.Entries)
{
entry.ExtractToFile(Path.Combine(strPath, entry.FullName), true);
}
}
}
public static List<string> GetFileList(string strPathZip)
{
List<string> vstrFileNames = new List<string>();
using (ZipArchive archive = ZipFile.OpenRead(strPathZip))
{
foreach (ZipArchiveEntry entry in archive.Entries)
vstrFileNames.Add(entry.FullName);
}
return vstrFileNames;
}
public static bool IsFileExist(string strPathZip, string strFile)
{
using (ZipArchive archive = ZipFile.OpenRead(strPathZip))
{
ZipArchiveEntry entry = archive.Entries.Where(compFile => compFile.FullName == strFile).DefaultIfEmpty()?.First();
if (entry != null)
return false;
}
return true;
}
public static MemoryStream OpenCompressWithoutUnzip(string strPathZip, string strFile)
{
Stream streamFile = null;
using (ZipArchive archive = ZipFile.OpenRead(strPathZip))
{
ZipArchiveEntry entry = archive.Entries.Where(compFile => compFile.FullName == strFile).DefaultIfEmpty()?.First();
if (entry != null)
{
streamFile = entry.Open();
return CopyToMemory(streamFile);
}
else
{
}
}
return null;
}
public static MemoryStream OpenCompressWithoutUnzip(Stream streamZip, string strFile)
{
Stream streamFile = null;
if (streamZip == null)
return null;
using (ZipArchive archive = new ZipArchive(streamZip))
{
ZipArchiveEntry entry = archive.Entries.Where(compFile => compFile.FullName == strFile).DefaultIfEmpty()?.First();
if (entry != null)
{
streamFile = entry.Open();
return CopyToMemory(streamFile);
}
}
return null;
}
public static MemoryStream CopyToMemory(Stream input)
{
// It won't matter if we throw an exception during this method;
// we don't *really* need to dispose of the MemoryStream, and the
// caller should dispose of the input stream
MemoryStream ret = new MemoryStream();
byte[] buffer = new byte[8192];
int bytesRead;
while ((bytesRead = input.Read(buffer, 0, buffer.Length)) > 0)
{
ret.Write(buffer, 0, bytesRead);
}
// Rewind ready for reading (typical scenario)
ret.Position = 0;
return ret;
}
static public void ClearDirectory(string strFolderPath)
{
if (Directory.Exists(strFolderPath))
Directory.Delete(strFolderPath, true);
}
static public void ClearFile(string strFilePath)
{
if (File.Exists(strFilePath))
File.Delete(strFilePath);
}
static public void MoveFile(string source, string destination)
{
if (!File.Exists(source))
return;
if (!Directory.Exists(Path.GetDirectoryName(destination)))
Directory.CreateDirectory(Path.GetDirectoryName(destination));
// 2017.04.13 add M.S Ko
if (File.Exists(destination))
{
File.Delete(destination);
LogMessage.MessageOutput.ConsoleWrite("File was deleted & moved name of " + destination, ConsoleColor.White);
}
File.Move(source, destination);
}
}
}

90
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/FilterableTextBox.cs Normal file
View File

@ -0,0 +1,90 @@
using System;
using System.Linq;
using System.Windows.Forms;
namespace SystemX.Net.Platform.Common.Util
{
/// <summary>
/// see http://www.thecoolestdolphin.be/?p=38
/// TextBox 에서 invalid 문자를 filtering 함
/// sister classes : Dsu.Common.Utilities.NumericTextBox
/// </summary>
public class FilterableTextBox : TextBox
{
/// <summary>
/// 허용 문자 set.
/// <para/> - empty 이면, ForbiddenCharacterSet 이외의 모든 문자 허용
/// <para/> - empty 가 아니면 ForbiddenCharacterSet 는 의미가 없음
/// </summary>
public string AllowedCharacterSet { get; set; }
/// <summary>
/// 금칙 문자 set. AllowedCharacterSet 가 empty 인 경우에만 의미를 가짐
/// </summary>
public string ForbiddenCharacterSet { get; set; }
public bool ShowBalloonTips { get { return _showBalloonTips; } set { _showBalloonTips = value; }}
private bool _showBalloonTips = true;
private ToolTip _balloonTips;
public FilterableTextBox()
{
// default 는 alpha numeric 만 받음. 필요시 override.
SetAlphaNumericFilter();
_balloonTips = new ToolTip()
{
ToolTipTitle = "Invalid character.",
ToolTipIcon = ToolTipIcon.Warning,
AutoPopDelay = 0,
ShowAlways = false,
};
}
protected override void OnKeyPress(KeyPressEventArgs e)
{
base.OnKeyPress(e);
_balloonTips.Hide(this);
if ( Char.IsControl(e.KeyChar) || e.KeyChar == 46 ) // 8==backspace, 13=enter, 46=DEL
return;
bool valid = true;
if (String.IsNullOrEmpty(AllowedCharacterSet)) // 허용 문자를 지정하지 않은 경우. 금칙 문자에 포함되지 않으면 OK
{
if (!String.IsNullOrEmpty(ForbiddenCharacterSet) && ForbiddenCharacterSet.Contains(e.KeyChar))
valid = false;
}
else // 허용 문자를 지정한 경우
valid = AllowedCharacterSet.Contains(e.KeyChar);
e.Handled = ! valid;
if ( ! valid && _showBalloonTips)
_balloonTips.Show(String.Format("The character \"{0}\" is invalid.", e.KeyChar), this);
}
/// <summary>
/// Alpha-numeric 문자열 + addition 이 아니면 filtering 한다.
/// </summary>
/// <param name="addition"></param>
public void SetAlphaNumericFilter(string addition="")
{
AllowedCharacterSet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" + addition;
ForbiddenCharacterSet = String.Empty;
}
public void SetFileNameFilter()
{
AllowedCharacterSet = String.Empty;
ForbiddenCharacterSet = @"\/:*?""<>|";
}
public void SetSymbolFilter(string addition="")
{
SetAlphaNumericFilter("@_?" + addition);
}
}
}

25
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/GenericEventArgs.cs Normal file
View File

@ -0,0 +1,25 @@
using System;
namespace SystemX.Net.Platform.Common.Util
{
/// <summary>
/// Generic event argument decorator class
/// </summary>
public class GenericEventArgs : EventArgs
{
private EventArgs _innerEventArgs;
public T Cast<T>() where T : EventArgs
{
if (_innerEventArgs is T)
return (T)_innerEventArgs;
return null;
}
public GenericEventArgs(EventArgs args)
{
_innerEventArgs = args;
}
}
}

61
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/Gzip.cs Normal file
View File

@ -0,0 +1,61 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.Common.Util
{
public static class Gzip
{
#region Functions
public static string Compress(string stringData)
{
var rowData = Encoding.UTF8.GetBytes(stringData);
byte[] compressedData = null;
using (var outStream = new MemoryStream())
{
using (var gStream = new GZipStream(outStream, CompressionMode.Compress))
{
gStream.Write(rowData, 0, rowData.Length);
}
compressedData = outStream.ToArray();
}
return Convert.ToBase64String(compressedData);
}
public static string Decompression(string compressedDataStr)
{
string output = null;
byte[] compressedData = Convert.FromBase64String(compressedDataStr);
using (var decompressStream = new MemoryStream(compressedData))
{
using (var gStream = new GZipStream(decompressStream, CompressionMode.Decompress))
{
using (var reader = new StreamReader(gStream))
{
output = reader.ReadToEnd();
}
}
}
return output;
}
#endregion
#region String Extension(확장메서드)
public static string GzipCompress(this string stringData)
{
return Compress(stringData);
}
public static string GzipDecompress(this string compressedDataStr)
{
return Decompression(compressedDataStr);
}
#endregion
}
}

124
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/Log4NetWrapper.cs Normal file
View File

@ -0,0 +1,124 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Windows.Forms;
using log4net;
using log4net.Appender;
using SystemX.Net.Platform.Common.ExtensionMethods;
namespace SystemX.Net.Platform.Common.Util
{
public static class Log4NetWrapper
{
private static readonly LogProxy _dummyLogger = LogProxy.CreateLoggerProxy(MethodBase.GetCurrentMethod().DeclaringType);
private static ILog _logger = null;
public static ILog Logger { get { return _logger ?? _dummyLogger.Logger; } set { _logger = value; } }
#region Extension methods
[Conditional("DEBUG")]
public static void DEBUG(this ILog logger, object message, Exception exception)
{
if (logger.IsDebugEnabled) logger.Debug(message, exception);
}
[Conditional("DEBUG")]
public static void DEBUG(this ILog logger, object message)
{
if (logger.IsDebugEnabled) logger.Debug(message);
}
[Conditional("DEBUG")]
public static void DEBUGFORMAT(this ILog logger, string format, params object[] args)
{
if (logger.IsDebugEnabled) logger.DebugFormat(format, args);
}
[Conditional("DEBUG")]
public static void DEBUGFORMAT(this ILog logger, string format, object arg0)
{
if (logger.IsDebugEnabled) logger.DebugFormat(format, arg0);
}
[Conditional("DEBUG")]
public static void DEBUGFORMAT(this ILog logger, string format, object arg0, object arg1)
{
if (logger.IsDebugEnabled) logger.DebugFormat(format, arg0, arg1);
}
[Conditional("DEBUG")]
public static void DEBUGFORMAT(this ILog logger, string format, object arg0, object arg1, object arg2)
{
if (logger.IsDebugEnabled) logger.DebugFormat(format, arg0, arg1, arg2);
}
[Conditional("DEBUG")]
public static void DEBUGFORMAT(this ILog logger, IFormatProvider provider, string format, params object[] args)
{
if (logger.IsDebugEnabled) logger.DebugFormat(provider, format, args);
}
#endregion
/// <summary>
///
/// </summary>
/// <param name="mainForm"></param>
/// <param name="configFile">xml log configuration file</param>
/// <param name="logFileName">real log file name to be generated.</param>
public static void Install(IAppender mainForm, string configFile, string logFileName)
{
// http://stackoverflow.com/questions/2815940/where-will-log4net-create-this-log-file
// see log4netXXXX.xml configuration file
var appName = Path.GetFileNameWithoutExtension(Assembly.GetEntryAssembly().Location);
log4net.GlobalContext.Properties["LogFileName"] = logFileName.IsNullOrEmpty() ? Path.Combine(CommonUtil.GetProfilePath(), appName) : logFileName;
if ( File.Exists(configFile) )
{
log4net.Config.XmlConfigurator.Configure(new System.IO.FileInfo(configFile));
((log4net.Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root.AddAppender(mainForm);
}
else
MessageBox.Show(String.Format("Failed to load configuration file {0}.\r\nLog message will not be available.", configFile), appName);
}
/// <summary>
/// 분석 대상 assembly 의 type 을 검사하여, "logger" 라는 이름의 static 멤버를 찾고,
/// 사전에 해당 객체를 생성해서 등록해 둔다.
/// </summary>
/// <param name="mainForm"></param>
/// <param name="configFile">e.g "log4net.xml"</param>
/// <param name="assemblies">Logger 를 포함하는 분석 대상 assemblies</param>
/// <param name="logFileName">logFileName</param>
/// <param name="staticLoggerMemberName">e.g "logger"</param>
public static void Install(IAppender mainForm, string configFile, IEnumerable<Assembly> assemblies, string logFileName=null, string staticLoggerMemberName = "logger")
{
Install(mainForm, configFile, logFileName);
List<Type> types = new List<Type>();
foreach (var assembly in assemblies)
{
foreach (Type t_ in assembly.GetTypes())
{
Type t = t_.DeclaringType ?? t_;
MemberInfo[] mis = t.GetMember(staticLoggerMemberName, BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
foreach (var mi in mis)
{
Type candidateType = mi.DeclaringType.DeclaringType ?? mi.DeclaringType;
if (!types.Contains(candidateType))
{
types.Add(candidateType);
}
}
}
}
foreach (var type in types)
LogProxy.CreateLoggerProxy(type);
}
}
}

73
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/LogEntryManager.cs Normal file
View File

@ -0,0 +1,73 @@
using System;
using System.Diagnostics;
using System.Diagnostics.Contracts;
using log4net.Core;
using SystemX.Net.Platform.Common.ExtensionMethods;
namespace SystemX.Net.Platform.Common.Util
{
public class LogEntryManager : IDisposable
{
private LoggingEvent[] _logEntries;
public LoggingEvent[] LogEntries { get { return _logEntries; } }
public int Capacity { get { return (int)_capacity; } set { _capacity = (ulong)value; } }
private ulong _cursor = 0;
private ulong _capacity = 0;
public int Count { get { return (int)Math.Min(_cursor, (ulong)Capacity); } }
public LogEntryManager(int capacity)
{
Contract.Requires(capacity >= 0);
Capacity = Math.Max(capacity, 1000);
_logEntries = new LoggingEvent[Capacity];
}
public void AddLogEntry(LoggingEvent logEntry)
{
_logEntries[_cursor++ % _capacity] = logEntry;
}
public void Clear()
{
_logEntries = new LoggingEvent[Capacity];
_cursor = 0;
}
/// <summary>
/// logical index 를 physical index 로 변환해서 반환.
/// e.g : capacity=1000, logical=1200 => physical=200
/// </summary>
/// <param name="n">logical index number</param>
/// <returns>physical index number : capacity 적용하여 rolling 한 결과 값</returns>
public int LogicalIndex2PhysicalIndex(int n)
{
Contract.Requires(n.InRange(0, Capacity - 1));
if (_cursor < _capacity)
return n;
return (int)((_cursor + (ulong)n) % _capacity);
}
public int PhysicalIndex2LogicalIndex(int n)
{
if (_cursor < _capacity)
return n;
Debug.Assert((ulong)n < _cursor);
return (int)((ulong)n + (_cursor / _capacity) * _capacity);
}
public LoggingEvent this[int n]
{
get { return _logEntries[LogicalIndex2PhysicalIndex(n)]; }
}
public void Dispose()
{
_logEntries = null;
_capacity = 0;
}
}
}

83
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/LogMessage.cs Normal file
View File

@ -0,0 +1,83 @@
using log4net;
using System;
namespace SystemX.Net.Platform.Common.Util
{
public class LogMessage
{
public enum LogMessageLevel
{
NONE = 0,
FATAL,
DEBUG,
INFO,
LAST
};
public delegate void MessageEventHandlerOutput(string strMessage, ConsoleColor csColor = ConsoleColor.White, LogMessageLevel logLevel = LogMessageLevel.DEBUG);
static public class MessageOutput
{
private static ILog logger => Log4NetWrapper.Logger;
static public LogMessageLevel PrintLogLevel { get; set; } = LogMessageLevel.DEBUG;
static public MessageEventHandlerOutput UEventOutput;
static public void ConsoleWrite(string strMessage, ConsoleColor csColor = ConsoleColor.White, LogMessageLevel logLevel = LogMessageLevel.DEBUG)
{
try
{
if (PrintLogLevel >= logLevel)
{
Console.ForegroundColor = csColor;
Console.WriteLine(strMessage);
Console.ResetColor();
UEventOutput?.Invoke(strMessage, csColor, logLevel);
switch (logLevel)
{
case LogMessageLevel.FATAL:
logger.Error(strMessage);
//WriteEventLogEntry(strMessage);
break;
case LogMessageLevel.DEBUG:
logger.Debug(strMessage);
break;
default:
logger.Info(strMessage);
break;
}
}
}
catch (System.Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
private static void WriteEventLogEntry(string message)
{
// Create an instance of EventLog
System.Diagnostics.EventLog eventLog = new System.Diagnostics.EventLog();
// Check if the event source exists. If not create it.
if (!System.Diagnostics.EventLog.SourceExists("CP-ServerX"))
{
System.Diagnostics.EventLog.CreateEventSource("CP-ServerX", "SystemX");
}
// Set the source name for writing log entries.
eventLog.Source = "CP-ServerX";
// Create an event ID to add to the event log
int eventID = 2051;
// Write an entry to the event log.
eventLog.WriteEntry(message,
System.Diagnostics.EventLogEntryType.Error,
eventID);
// Close the Event Log
eventLog.Close();
}
}
}

153
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/LogProxy.cs Normal file
View File

@ -0,0 +1,153 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using log4net;
namespace SystemX.Net.Platform.Common.Util
{
/// <summary>
/// ILog 가 runtime 에 debug log 를 enable/disable 하는 기능을 지원하지 않으므로,
/// proxy 를 통해서 enable/disable 한다.
/// https://social.msdn.microsoft.com/forums/vstudio/en-US/0624de68-fe7f-45c0-9cd8-468d9dac844b/how-to-disable-log4net-debug-logging-during-runtime
/// </summary>
public class LogProxy
{
public ILog Logger { get; set; }
public string Name { get { return Logger.Logger.Name; } }
public Type Type { get; set; }
/// <summary>
/// runtime 에 debug 로그에 대한 enable/disable 여부
/// </summary>
public bool IsEnableDebug
{
get { return _isEnableDebug && Logger.IsDebugEnabled; }
set
{
_isEnableDebug = value;
Trace.WriteLine($"{Name}: IsEnableDebug={IsEnableDebug}");
}
}
private bool _isEnableDebug = false;
public bool IsEnableInfo { get { return _isEnableInfo && Logger.IsInfoEnabled; } set { _isEnableInfo = value; } }
private bool _isEnableInfo = false;
public bool IsEnableWarn { get { return _isEnableWarn && Logger.IsWarnEnabled; } set { _isEnableWarn = value; } }
private bool _isEnableWarn = false;
/// <summary>
/// 현재 등록된 logger 들 : var loggers = log4net.LogManager.GetCurrentLoggers(); 와 동일
/// </summary>
public static IEnumerable<LogProxy> CurrentLoggers { get { return _currentLoggers; } }
private static List<LogProxy> _currentLoggers = new List<LogProxy>();
private LogProxy(Type type)
{
Type = type;
Logger = log4net.LogManager.GetLogger(type);
}
public static LogProxy GetLogProxy(Type t)
{
return CurrentLoggers.FirstOrDefault(l => l.Name == t.FullName);
}
/// <summary>
/// proxy 된 logger 를 생성한다.
/// </summary>
/// <param name="t"></param>
/// <param name="enableDebug"></param>
/// <returns></returns>
public static LogProxy CreateLoggerProxy(Type t, bool? enableDebug = null)
{
var proxy = GetLogProxy(t);
if (proxy == null)
{
proxy = new LogProxy(t);
_currentLoggers.Add(proxy);
}
if (enableDebug.HasValue)
proxy.IsEnableDebug = enableDebug.Value;
return proxy;
}
[Conditional("DEBUG")]
public void Debug(object message, Exception exception)
{
if (IsEnableDebug) Logger.Debug(message, exception);
}
[Conditional("DEBUG")]
public void Debug(object message)
{
if (IsEnableDebug) Logger.Debug(message);
}
[Conditional("DEBUG")]
public void DebugFormat(string format, params object[] args)
{
if (IsEnableDebug) Logger.DebugFormat(format, args);
}
[Conditional("DEBUG")]
public void DebugFormat(string format, object arg0)
{
if (IsEnableDebug) Logger.DebugFormat(format, arg0);
}
[Conditional("DEBUG")]
public void DebugFormat(string format, object arg0, object arg1)
{
if (IsEnableDebug) Logger.DebugFormat(format, arg0, arg1);
}
[Conditional("DEBUG")]
public void DebugFormat(string format, object arg0, object arg1, object arg2)
{
if (IsEnableDebug) Logger.DebugFormat(format, arg0, arg1, arg2);
}
[Conditional("DEBUG")]
public void DebugFormat(IFormatProvider provider, string format, params object[] args)
{
if (IsEnableDebug) Logger.DebugFormat(provider, format, args);
}
public void Error(object message) { Logger.Error(message); }
public void Error(object message, Exception exception) { Logger.Error(message, exception); }
public void ErrorFormat(string format, object arg0) { Logger.ErrorFormat(format, arg0); }
public void ErrorFormat(string format, params object[] args) { Logger.ErrorFormat(format, args); }
public void ErrorFormat(IFormatProvider provider, string format, params object[] args) { Logger.ErrorFormat(provider, format, args); }
public void ErrorFormat(string format, object arg0, object arg1) { Logger.ErrorFormat(format, arg0, arg1); }
public void ErrorFormat(string format, object arg0, object arg1, object arg2) { Logger.ErrorFormat(format, arg0, arg1, arg2); }
public void Fatal(object message) { Logger.Fatal(message); }
public void Fatal(object message, Exception exception) { Logger.Fatal(message, exception); }
public void FatalFormat(string format, object arg0) { Logger.FatalFormat(format, arg0); }
public void FatalFormat(string format, params object[] args) { Logger.FatalFormat(format, args); }
public void FatalFormat(IFormatProvider provider, string format, params object[] args) { Logger.FatalFormat(provider, format, args); }
public void FatalFormat(string format, object arg0, object arg1) { Logger.FatalFormat(format, arg0, arg1); }
public void FatalFormat(string format, object arg0, object arg1, object arg2) { Logger.FatalFormat(format, arg0, arg1, arg2); }
public void Info(object message) { if (IsEnableInfo) Logger.Info(message); }
public void Info(object message, Exception exception) { if (IsEnableInfo) Logger.Info(message, exception); }
public void InfoFormat(string format, object arg0) { if (IsEnableInfo) Logger.InfoFormat(format, arg0); }
public void InfoFormat(string format, params object[] args) { if (IsEnableInfo) Logger.InfoFormat(format, args); }
public void InfoFormat(IFormatProvider provider, string format, params object[] args) { if (IsEnableInfo) Logger.InfoFormat(provider, format, args); }
public void InfoFormat(string format, object arg0, object arg1) { if (IsEnableInfo) Logger.InfoFormat(format, arg0, arg1); }
public void InfoFormat(string format, object arg0, object arg1, object arg2) { if (IsEnableInfo) Logger.InfoFormat(format, arg0, arg1, arg2); }
public void Warn(object message) { if (IsEnableWarn) Logger.Warn(message); }
public void Warn(object message, Exception exception) { if (IsEnableWarn) Logger.Warn(message, exception); }
public void WarnFormat(string format, object arg0) { if (IsEnableWarn) Logger.WarnFormat(format, arg0); }
public void WarnFormat(string format, params object[] args) { if (IsEnableWarn) Logger.WarnFormat(format, args); }
public void WarnFormat(IFormatProvider provider, string format, params object[] args) { if (IsEnableWarn) Logger.WarnFormat(provider, format, args); }
public void WarnFormat(string format, object arg0, object arg1) { if (IsEnableWarn) Logger.WarnFormat(format, arg0, arg1); }
public void WarnFormat(string format, object arg0, object arg1, object arg2) { if (IsEnableWarn) Logger.WarnFormat(format, arg0, arg1, arg2); }
}
}

81
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/LogRecord.cs Normal file
View File

@ -0,0 +1,81 @@
using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;
using log4net;
using log4net.Core;
namespace SystemX.Net.Platform.Common.Util
{
public class LogRecord
{
[Browsable(false)]
public LoggingEvent LogEntry { get; private set; }
[DisplayName("Time")]
public string TimeStamp { get { return LogEntry.TimeStamp.ToString("HH:mm:ss.ff"); } }
public Level Level { get { return LogEntry.Level; } }
[DisplayName("Sender")]
public string LoggerName { get { return LogEntry.LoggerName; } }
[DisplayName("Message")]
public object MessageObject { get { return LogEntry.MessageObject; } }
[DisplayName("t-Id")]
public string ThreadName { get { return LogEntry.ThreadName; } }
public LogRecord(LoggingEvent log)
{
LogEntry = log;
}
public override string ToString()
{
var sb = new StringBuilder();
sb.Append(TimeStamp);
sb.Append("\t");
sb.Append(Level);
sb.Append("\t");
sb.Append(LoggerName);
sb.Append("\t");
sb.Append(MessageObject);
return sb.ToString();
}
}
[ComVisible(false)]
public class LogRecordFiledWriter<T> : IDisposable
{
private bool _globalContext;
private string _field;
private T _valueBackup;
public LogRecordFiledWriter(string field, T value, bool globalContext=false)
{
_field = field;
_globalContext = globalContext;
if (globalContext)
{
var backup = GlobalContext.Properties[field];
_valueBackup = backup == null ? default(T) : (T)backup;
GlobalContext.Properties[field] = value;
}
else
{
var backup = ThreadContext.Properties[field];
_valueBackup = backup == null ? default(T) : (T)backup;
ThreadContext.Properties[field] = value;
}
}
public void Dispose()
{
if (_globalContext)
GlobalContext.Properties[_field] = _valueBackup;
else
ThreadContext.Properties[_field] = _valueBackup;
}
}
}

432
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/NumericTextBox.cs Normal file
View File

@ -0,0 +1,432 @@
//
// http://www.mediafire.com/download/fidd3mm85dmq9tb/%281392.03.10%29+Numerical+TextBox+Sample.rar
// 이거도 참고로 볼 것... 비슷하지만, 현재 것이 나아보임 http://www.codeproject.com/Articles/30812/Simple-Numeric-TextBox
// http://www.thecoolestdolphin.be/?p=38 [Allow only specific characters in textBox in C#]
using System;
using System.ComponentModel;
using System.Text.RegularExpressions;
using System.Windows.Forms;
namespace SystemX.Net.Platform.Common.Util
{
/// <summary>
///
/// </summary>
public class NumericTextBox : TextBox
{
private bool _negative;
private bool _dot;
private bool _exponent;
private int _decimalNumber;
private int _cursorPositionPlus;
private char _discriminant;
private double _maxValue;
private double _minValue;
private bool _maxCheck;
private bool _minCheck;
private string _oldText;
public NumericTextBox()
{
_decimalNumber = 4;
_negative = true;
_dot = true;
_exponent = true;
_discriminant = ',';
_maxValue = 0;
_minValue = 0;
_maxCheck = false;
_minCheck = false;
_oldText = string.Empty;
_balloonTips = new ToolTip()
{
ToolTipTitle = "Invalid character.",
ToolTipIcon = ToolTipIcon.Warning,
AutoPopDelay = 0,
ShowAlways = false,
};
}
public NumericTextBox(int decimalNumber)
: this()
{
_decimalNumber = decimalNumber;
}
public NumericTextBox(char discriminant)
: this(4)
{
if (discriminant == '\'' || discriminant == '/' || discriminant == '`')
_discriminant = discriminant;
else
_discriminant = ',';
}
public NumericTextBox(int decimalNumber, char discriminant)
: this(discriminant)
{
_decimalNumber = decimalNumber;
}
[Description("1000 단위 comma 허용 여부")]
public int DecimalNumber
{
get { return _decimalNumber; }
set { _decimalNumber = value; OnTextChanged(new EventArgs()); }
}
[Description("음수 허용 여부")]
public bool Negative
{
get { return _negative; }
set { _negative = value; OnTextChanged(new EventArgs()); }
}
[Description("Period 허용 여부")]
public bool Dot
{
get { return _dot; }
set { _dot = value; OnTextChanged(new EventArgs()); }
}
[Description("Scientific notation 허용 여부")]
public bool Exponent
{
get { return _exponent; }
set { _exponent = value; OnTextChanged(new EventArgs()); }
}
public char Discriminant
{
get { return _discriminant; }
set
{
if (value == '\'' || value == '/' || value == '`')
_discriminant = value;
else
_discriminant = ',';
OnTextChanged(new EventArgs());
}
}
public double MaxValue
{
get { return _maxValue; }
set
{
_maxValue = (!MinCheck || value >= _minValue) ? value : _maxValue;
if (_maxCheck && new NumericalString(this.Text) > _maxValue)
this.Text = _maxValue.ToString();
}
}
public double MinValue
{
get { return _minValue; }
set
{
_minValue = (!MaxCheck || value <= _maxValue) ? value : _minValue;
if (_minCheck && new NumericalString(this.Text) < _minValue)
this.Text = _minValue.ToString();
}
}
public bool MaxCheck
{
get { return _maxCheck; }
set
{
_maxCheck = value;
if (_maxCheck && new NumericalString(this.Text) > _maxValue)
this.Text = _maxValue.ToString();
}
}
public bool MinCheck
{
get { return _minCheck; }
set
{
_minCheck = value;
if (_minCheck && new NumericalString(this.Text) < _minValue)
this.Text = _minValue.ToString();
}
}
public NumericalString NumericalText
{
get { return new NumericalString(this.Text); }
}
public double GetDoubleValue()
{
double value;
if (!Double.TryParse(NumericalText.Text, out value))
return 0;
return value;
}
public int GetIntValue()
{
int value;
if (!Int32.TryParse(NumericalText.Text, out value))
return 0;
return value;
}
#region Baloon Tips
[Description("오류 문자 입력시 풍선 도움말 표시 여부")]
public bool ShowBalloonTips { get { return _showBalloonTips; } set { _showBalloonTips = value; } }
private bool _showBalloonTips = true;
private ToolTip _balloonTips;
#endregion
protected override void OnTextChanged(EventArgs e)
{
_balloonTips.Hide(this);
_cursorPositionPlus = 0;
int SelectionStart = this.SelectionStart;
int TextLength = this.Text.Length;
int CursorPositionPlus;
string Text = NormalTextToNumericString();
CursorPositionPlus = _cursorPositionPlus;
if ((!_maxCheck || new NumericalString(this.Text) <= _maxValue) && (!_minCheck || new NumericalString(this.Text) >= _minValue))
{
this.Text = Text;
this.SelectionStart = SelectionStart + CursorPositionPlus;
_oldText = this.Text;
}
else
{
this.Text = _oldText;
this.SelectionStart = SelectionStart + _oldText.Length - TextLength;
}
base.OnTextChanged(e);
}
protected string NormalTextToNumericString()
{
string Text = this.Text;
string TextTemp1 = string.Empty, TextTemp2 = string.Empty;
#region Lowering Characters
for (int i = 0; i < Text.Length; i++)
TextTemp1 += char.ToLower(Text[i]);
#endregion
#region Remove Unknown Characters
int FloatNumber = 0;
for (int i = 0; i < TextTemp1.Length; i++)
if (_negative && TextTemp1[i] == '-' && i == 0)
TextTemp2 += TextTemp1[i];
else if (TextTemp1[i] == '-' && TextTemp2.IndexOf('e') >= 0 && TextTemp2.Length == TextTemp2.IndexOf('e') + 1)
TextTemp2 += TextTemp1[i];
else if (char.IsDigit(TextTemp1[i]))
{
TextTemp2 += TextTemp1[i];
if (TextTemp2.IndexOf('.') > -1 && TextTemp2.IndexOf('e') < 0 && i < this.SelectionStart)
{
FloatNumber++;
if (FloatNumber > _decimalNumber && i < this.SelectionStart)
_cursorPositionPlus--;
}
}
else if (_dot && _decimalNumber > 0 && TextTemp1[i] == '.' && TextTemp2.IndexOf('.') < 0 && (TextTemp2.IndexOf('e') < 0 || TextTemp2.Length < TextTemp2.IndexOf('e')))
TextTemp2 += TextTemp1[i];
else if (_exponent && TextTemp1[i] == 'e' && TextTemp2.IndexOf('e') < 0 && TextTemp2.Length >= TextTemp2.IndexOf('.') + 1)
TextTemp2 += TextTemp1[i];
else if (i < this.SelectionStart)
{
bool skip = _decimalNumber != 0 && TextTemp1[i] == ',';
if ( ! skip && ShowBalloonTips )
_balloonTips.Show(String.Format("The character \"{0}\" is invalid.", TextTemp1[i]), this);
_cursorPositionPlus--;
}
#endregion
#region Get Integer Number
string INTEGER = string.Empty;
int IntegerIndex = (TextTemp2.IndexOf('.') >= 0) ? TextTemp2.IndexOf('.') : (TextTemp2.IndexOf('e') >= 0) ? TextTemp2.IndexOf('e') : TextTemp2.Length;
for (int i = 0; i < IntegerIndex; i++)
if (char.IsDigit(TextTemp2[i]) || TextTemp2[i] == '-' && INTEGER.IndexOf('-') < 0)
INTEGER += TextTemp2[i];
#endregion
#region Get Float Number
string FLOAT = string.Empty;
if (TextTemp2.IndexOf('.') >= 0)
for (int i = TextTemp2.IndexOf('.') + 1; i < ((TextTemp2.IndexOf('e') >= 0) ? TextTemp2.IndexOf('e') : TextTemp2.Length); i++)
if (char.IsDigit(TextTemp2[i]))
FLOAT += TextTemp2[i];
#endregion
#region Put '/' Character in Integer Number
string T = string.Empty;
int n = 0;
for (int i = INTEGER.Length - 1; i >= 0; i--)
{
T += INTEGER[i];
n++;
if (n == 3 && i > 0 && INTEGER[i - 1] != '-')
{
if (i - _cursorPositionPlus < this.SelectionStart)
_cursorPositionPlus++;
T += _discriminant.ToString();
n = 0;
}
}
char[] charArray = T.ToCharArray();
Array.Reverse(charArray);
T = new string(charArray);
#endregion
#region Put '.' Character
if (TextTemp2.IndexOf('.') >= 0)
{
T += ('.').ToString();
for (int i = 0; i < DecimalNumber && i < FLOAT.Length; i++)
T += FLOAT[i];
}
#endregion
#region Put 'e' Character
if (TextTemp2.IndexOf('e') >= 0)
{
T += ('e').ToString();
for (int i = TextTemp2.IndexOf('e') + 1; i < TextTemp2.Length; i++)
T += TextTemp2[i];
}
#endregion
return T;
}
}
public class NumericalString
{
private string _text;
public string Text
{
get { return _text; }
set { _text = value; }
}
public NumericalString()
{
_text = string.Empty;
}
public NumericalString(string Text)
{
string Temp = string.Empty;
for (int i = 0; i < Text.Length; i++)
if (char.IsDigit(Text[i]) || Text[i] == '-' || Text[i] == '.' || Text[i] == 'e')
Temp += Text[i];
_text = Temp;
}
public override string ToString()
{
return (this.Text == string.Empty) ? "0" : this.Text;
}
public static implicit operator NumericalString(string Text)
{
return new NumericalString(Text);
}
public static explicit operator string(NumericalString Text)
{
return (Text.Text == "") ? "0" : Text.Text;
}
public static implicit operator double(NumericalString Text)
{
double value;
if (Text.Text == "")
return 0;
if (Text.Text == "-")
return 0;
if (Text.Text == "-.")
return 0;
if (Text.Text.StartsWith("-e"))
return 0;
if (Text.Text.StartsWith("e"))
return 0;
if (Text.Text.EndsWith("e") || Text.Text.EndsWith("e-"))
return Convert.ToDouble(Text.Text.Substring(0, Text.Text.IndexOf('e')));
if (!Double.TryParse(Text.Text, out value))
return Convert.ToDouble(Regex.Replace(Text.Text, @"\D", ""));
return Convert.ToDouble(Text.Text);
}
public static string operator +(NumericalString Text1, NumericalString Text2)
{
return Text1.Text + Text2.Text;
}
public static string operator +(NumericalString Text1, string Text2)
{
return Text1.Text + Text2;
}
public static string operator +(NumericalString Text1, char ch)
{
return Text1.Text + ch.ToString();
}
}
}
/*
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
numericalTextBox.DecimalNumber = (int)DecimalNumberNumericUpDown.Value;
numericalTextBox.Negative = NegativeSignCheckBox.Checked;
numericalTextBox.Dot = DotCheckBox.Checked;
numericalTextBox.Exponent = ExponentCheckBox.Checked;
numericalTextBox.MaxValue = System.Convert.ToDouble(MaximumTextBox.Text);
numericalTextBox.MinValue = System.Convert.ToDouble(MinimumTextBox.Text);
numericalTextBox.MaxCheck = MaximumCheckBox.Checked;
numericalTextBox.MinCheck = MinimumCheckBox.Checked;
numericalTextBox.Discriminant = ',';
}
private void DecimalNumberNumericUpDown_ValueChanged(object sender, EventArgs e)
{
numericalTextBox.DecimalNumber = (int)DecimalNumberNumericUpDown.Value;
}
private void NegativeSignCheckBox_CheckedChanged(object sender, EventArgs e)
{
numericalTextBox.Negative = NegativeSignCheckBox.Checked;
}
private void DotCheckBox_CheckedChanged(object sender, EventArgs e)
{
numericalTextBox.Dot = DotCheckBox.Checked;
}
private void ExponentCheckBox_CheckedChanged(object sender, EventArgs e)
{
numericalTextBox.Exponent = ExponentCheckBox.Checked;
}
private void MaximumTextBox_TextChanged(object sender, EventArgs e)
{
numericalTextBox.MaxValue = MaximumTextBox.NumericalText;
}
private void MinimumTextBox_TextChanged(object sender, EventArgs e)
{
numericalTextBox.MinValue = MinimumTextBox.NumericalText;
}
private void MaximumCheckBox_CheckedChanged(object sender, EventArgs e)
{
numericalTextBox.MaxCheck = MaximumCheckBox.Checked;
MaximumTextBox.Enabled = MaximumCheckBox.Checked;
}
private void MinimumCheckBox_CheckedChanged(object sender, EventArgs e)
{
numericalTextBox.MinCheck = MinimumCheckBox.Checked;
MinimumTextBox.Enabled = MinimumCheckBox.Checked;
}
private void GroupSeparatorCharacterTextBox_TextChanged(object sender, EventArgs e)
{
if (GroupSeparatorCharacterTextBox.Text != "" && GroupSeparatorCharacterTextBox.Text.Length == 1)
numericalTextBox.Discriminant = System.Convert.ToChar(GroupSeparatorCharacterTextBox.Text);
else
numericalTextBox.Discriminant = ',';
}
private void numericalTextBox_TextChanged(object sender, EventArgs e)
{
NumericalString NS = "Reza";
string s = numericalTextBox.NumericalText.ToString();
TextTextBox.Text = (string)numericalTextBox.NumericalText + " Reza";
DoubleTextBox.Text = (numericalTextBox.NumericalText + 3).ToString();
ConditionTextBox.Text = (numericalTextBox.NumericalText < 100) ? (string)numericalTextBox.NumericalText : "Over 100";
}
}
*/

16
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/ObservableEvent.cs Normal file
View File

@ -0,0 +1,16 @@
using System;
using System.Runtime.InteropServices;
namespace SystemX.Net.Platform.Common.Util
{
/// <summary>
/// Rx: System.Reactive.Subjects.Subject 에 대한 base interface
/// </summary>
[ComVisible(false)]
public interface IObservableEvent
{
}
public interface IObservableUIEvent : IObservableEvent { }
}

45
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/SupportedCultures.cs Normal file
View File

@ -0,0 +1,45 @@
using System.Globalization;
using System.Threading;
namespace SystemX.Net.Platform.Common.Util
{
public enum SupportedCultures
{
English,
Korean,
}
public static class CultrureConverter
{
public static string ConvertToString(this SupportedCultures culture)
{
switch (culture)
{
case SupportedCultures.English:
return "en-US";
case SupportedCultures.Korean:
return "ko-KR";
}
return null;
}
public static CultureInfo ConvertToCultureInfo(this SupportedCultures culture)
{
return new CultureInfo(culture.ConvertToString());
}
public static void Apply(this SupportedCultures culture)
{
var ci = culture.ConvertToCultureInfo();
ci.Apply();
}
public static void Apply(this CultureInfo ci)
{
Thread.CurrentThread.CurrentCulture = ci;
Thread.CurrentThread.CurrentUICulture = ci;
}
}
}

27
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/Utilities.cs Normal file
View File

@ -0,0 +1,27 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
namespace SystemX.Net.Platform.Common.Util
{
public class CwdChanger : IDisposable
{
protected string m_strBackupDirectory = null;
public CwdChanger() : this(null) { }
public CwdChanger(string strTargetDirectory/*=null*/)
{
m_strBackupDirectory = Directory.GetCurrentDirectory();
if (!String.IsNullOrEmpty(strTargetDirectory))
Directory.SetCurrentDirectory(strTargetDirectory);
}
public void Dispose()
{
Directory.SetCurrentDirectory(m_strBackupDirectory);
}
}
}

55
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Common/Util/XMLControl.cs Normal file
View File

@ -0,0 +1,55 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
namespace SystemX.Net.Platform.Common.Util
{
public static class XMLControl
{
public static XDocument OpenXMLDocument(string strXmlPath)
{
XDocument xDoc = XDocument.Load(strXmlPath);
return xDoc;
}
public static XElement OpenXMLDocument(string strXmlPath, string strRootElemName)
{
XDocument xDoc = XDocument.Load(strXmlPath);
var xElement = xDoc.Element(strRootElemName);
if (xElement == null) return null;
return xElement;
}
public static XElement OpenXMLElement(XElement xRootElem, string strChildName)
{
var xElement = xRootElem.Element(strChildName);
if (xElement == null) return null;
return xElement;
}
public static void LoadXMLAttributes(object objOwner, Type typAttributes, XElement xelem)
{
foreach (string strAttrb in Enum.GetNames(typAttributes))
{
string strData = xelem.Attribute(strAttrb).Value;
PropertyInfo propInfo = CommonUtil.GetProperty(objOwner, strAttrb);
if (propInfo.PropertyType == typeof(int))
CommonUtil.SetPropertyValue(objOwner, strAttrb, Convert.ToInt32(strData));
else if (propInfo.PropertyType == typeof(string))
CommonUtil.SetPropertyValue(objOwner, strAttrb, strData);
}
}
}
}

173
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.CP.Platform.csproj Normal file
View File

@ -0,0 +1,173 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{9E024203-A0D4-4A08-8041-9D31248B6F7B}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>SystemX.Net.Platform</RootNamespace>
<AssemblyName>SystemX.Net.Platform</AssemblyName>
<TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<Deterministic>true</Deterministic>
<TargetFrameworkProfile />
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>..\..\Output.SystemX\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>..\..\Output.SystemX\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
<DebugSymbols>true</DebugSymbols>
<OutputPath>bin\x64\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<DebugType>full</DebugType>
<PlatformTarget>x64</PlatformTarget>
<LangVersion>7.3</LangVersion>
<ErrorReport>prompt</ErrorReport>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
<OutputPath>..\..\Output.SystemX\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<Optimize>true</Optimize>
<DebugType>pdbonly</DebugType>
<PlatformTarget>x64</PlatformTarget>
<LangVersion>7.3</LangVersion>
<ErrorReport>prompt</ErrorReport>
</PropertyGroup>
<ItemGroup>
<Reference Include="log4net">
<HintPath>..\..\References\log4net.dll</HintPath>
</Reference>
<Reference Include="Remotion.Linq, Version=2.1.0.0, Culture=neutral, PublicKeyToken=fee00910d6e5f53b, processorArchitecture=MSIL">
<HintPath>..\packages\Remotion.Linq.2.1.1\lib\net45\Remotion.Linq.dll</HintPath>
</Reference>
<Reference Include="System" />
<Reference Include="System.Collections.Immutable, Version=1.2.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<HintPath>..\packages\System.Collections.Immutable.1.3.0\lib\portable-net45+win8+wp8+wpa81\System.Collections.Immutable.dll</HintPath>
</Reference>
<Reference Include="System.ComponentModel.Composition" />
<Reference Include="System.ComponentModel.DataAnnotations" />
<Reference Include="System.Core" />
<Reference Include="System.Diagnostics.DiagnosticSource, Version=4.0.1.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
<HintPath>..\packages\System.Diagnostics.DiagnosticSource.4.3.1\lib\portable-net45+win8+wpa81\System.Diagnostics.DiagnosticSource.dll</HintPath>
</Reference>
<Reference Include="System.Drawing" />
<Reference Include="System.Interactive.Async, Version=3.0.0.0, Culture=neutral, PublicKeyToken=94bc3704cddfc263, processorArchitecture=MSIL">
<HintPath>..\packages\System.Interactive.Async.3.0.0\lib\net45\System.Interactive.Async.dll</HintPath>
</Reference>
<Reference Include="System.IO.Compression" />
<Reference Include="System.IO.Compression.FileSystem" />
<Reference Include="System.Numerics" />
<Reference Include="System.Reactive.Core">
<HintPath>..\..\References\System.Reactive.Core.dll</HintPath>
</Reference>
<Reference Include="System.Reactive.Interfaces">
<HintPath>..\..\References\System.Reactive.Interfaces.dll</HintPath>
</Reference>
<Reference Include="System.Reactive.Linq">
<HintPath>..\..\References\System.Reactive.Linq.dll</HintPath>
</Reference>
<Reference Include="System.Runtime.CompilerServices.Unsafe, Version=4.0.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<HintPath>..\packages\System.Runtime.CompilerServices.Unsafe.4.3.0\lib\netstandard1.0\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
</Reference>
<Reference Include="System.Runtime.InteropServices.RuntimeInformation, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<HintPath>..\packages\System.Runtime.InteropServices.RuntimeInformation.4.3.0\lib\net45\System.Runtime.InteropServices.RuntimeInformation.dll</HintPath>
</Reference>
<Reference Include="System.Transactions" />
<Reference Include="System.Windows" />
<Reference Include="System.Windows.Forms" />
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Data" />
<Reference Include="System.Net.Http" />
<Reference Include="System.Xml" />
<Reference Include="WindowsBase" />
</ItemGroup>
<ItemGroup>
<Compile Include="SystemX.Common.Protocol\CommonCustomMakeProtocol.cs" />
<Compile Include="SystemX.Common.Protocol\LSU Trimming 4th\CustomMakeProtocol_LSU.cs" />
<Compile Include="SystemX.Common.Protocol\Smart Inhibitor 1th\CustomMakeProtocol_SIA.cs" />
<Compile Include="SystemX.Common\DataTableQuery.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="SystemX.Common.Protocol\AsyncEventProcess.cs" />
<Compile Include="SystemX.Common\Archive.cs" />
<Compile Include="SystemX.Common\MemoryMappedFileControl.cs" />
<Compile Include="SystemX.Common\PacketControl\Common.cs" />
<Compile Include="SystemX.Common\Event\EventBase.cs" />
<Compile Include="SystemX.Common\Event\FuncEventHandler.cs" />
<Compile Include="SystemX.Common\Event\PauseToken.cs" />
<Compile Include="SystemX.Common\Extension\EmAsync.cs" />
<Compile Include="SystemX.Common\Extension\EmBitmap.cs" />
<Compile Include="SystemX.Common\Extension\EmComparable.cs" />
<Compile Include="SystemX.Common\Extension\EmControl.cs" />
<Compile Include="SystemX.Common\Extension\EmEventHandler.cs" />
<Compile Include="SystemX.Common\Extension\EmGeneral.cs" />
<Compile Include="SystemX.Common\Extension\EmLinq.cs" />
<Compile Include="SystemX.Common\PacketControl\PacketMakeFrom.cs" />
<Compile Include="SystemX.Common\PacketControl\PacketMakeTo.cs" />
<Compile Include="SystemX.Common\Serialization.cs" />
<Compile Include="SystemX.Common\Util\ApplicationIdleTimer.cs" />
<Compile Include="SystemX.Common\Util\AppWinControl.cs" />
<Compile Include="SystemX.Common\Util\CommonUtil.cs" />
<Compile Include="SystemX.Common\Util\CustomExceptions.cs" />
<Compile Include="SystemX.Common\Util\FileSystemUtil.cs" />
<Compile Include="SystemX.Common\Util\FilterableTextBox.cs">
<SubType>Component</SubType>
</Compile>
<Compile Include="SystemX.Common\Util\GenericEventArgs.cs" />
<Compile Include="SystemX.Common\Util\Gzip.cs" />
<Compile Include="SystemX.Common\Util\Log4NetWrapper.cs" />
<Compile Include="SystemX.Common\Util\LogEntryManager.cs" />
<Compile Include="SystemX.Common\Util\LogMessage.cs" />
<Compile Include="SystemX.Common\Util\LogProxy.cs" />
<Compile Include="SystemX.Common\Util\LogRecord.cs" />
<Compile Include="SystemX.Common\Util\NumericTextBox.cs">
<SubType>Component</SubType>
</Compile>
<Compile Include="SystemX.Common\Util\ObservableEvent.cs" />
<Compile Include="SystemX.Common\Util\SupportedCultures.cs" />
<Compile Include="SystemX.Common\Util\Utilities.cs" />
<Compile Include="SystemX.Common\Util\XMLControl.cs" />
<Compile Include="SystemX.Net.Comm\AsyncComClientSocket.cs" />
<Compile Include="SystemX.Net.Comm\AsyncClientSocket.cs" />
<Compile Include="SystemX.Net.Comm\AsyncServerSocket.cs" />
<Compile Include="SystemX.Net.Comm\Comm.cs" />
<Compile Include="SystemX.Net.Comm\IIS FTP\CommonsFTP.cs" />
<Compile Include="SystemX.Net.Comm\IIS FTP\ManagerFTP.cs" />
<Compile Include="SystemX.Net.Comm\IIS FTP\CtrlFTP.cs" />
<Compile Include="SystemX.Net.DB\ConnInfo.cs" />
<Compile Include="SystemX.Net.DB\ConnManager.cs" />
<Compile Include="SystemX.Net.DB\DBType\DBTMSSQL - Query.cs" />
<Compile Include="SystemX.Net.DB\DBType\DBTMSSQL.cs" />
<Compile Include="SystemX.Net.DB\DBType\IDBControl.cs" />
<Compile Include="SystemX.Net.DB\DBType\MariaDB.cs" />
<Compile Include="SystemX.Net.Schedule\PacketFlowControl.cs" />
<Compile Include="SystemX.Net.Schedule\Schedule.cs" />
<Compile Include="SystemX.Net\BaseContainer.cs" />
<Compile Include="SystemX.Net\Base.cs" />
<Compile Include="SystemX.Net\Protocol\BasePacket.cs" />
<Compile Include="SystemX.Net\Protocol\BaseProtocol.cs" />
<Compile Include="SystemX.Net\Info.cs" />
</ItemGroup>
<ItemGroup />
<ItemGroup>
<None Include="packages.config" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

940
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.Comm/AsyncClientSocket.cs Normal file
View File

@ -0,0 +1,940 @@
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using SystemX.Common;
using SystemX.Common.Serialization;
using SystemX.Net.Comm;
using static SystemX.Net.Platform.Common.Util.LogMessage;
namespace SystemX.Net.Comm
{
public class AsyncClientSocket : SystemXSocket, IDisposable
{
private Socket ClientSock; /* client Socket */
private Socket cbClientSock; /* client Async Callback Socket */
private byte[] recvBuffer;
//private String recvText;
private byte[] recvStoreBuffer;
private int iStoreCnt;
private int iCheckRetryCnt;
private const int MAX_CHECK_COUNT = 100; /* 256000 / 4096 <- 65526 / 4096 */
private const int USER_MAX_SIZE = 819200; /* 256000 <- 1000000 65536 */
private const int MAXSIZE = 8192; /* 8192 <- 4096 */
private const int MAX_PACKET_COUNT = 1024;
private string m_strGetIp;
private int m_iGetPort;
private bool m_bConnected;
private string m_strGetText;
private bool m_bGetRecv;
private bool bDisposed;
private bool bReadySocket;
public override event SocketCallEvent Comm_Connect_Event;
public override event SocketCallEvent Socket_Error_Event;
public override event SendRecvCallEvent Comm_Send_Event;
public override event SendRecvCallEvent Comm_Recv_Event;
public override event EventHandler<ScheduleEvent> AwaitSendEvent;
public override event EventHandler<ScheduleEvent> AwaitRecvEvent;
private Queue<CPacketDataInfo> QPacketAllData;
private Queue<CPacketDataInfo> QPacketRemainData;
private bool bQueuePacketClearOn;
public override void SetRefSocketPacketClear()
{
bQueuePacketClearOn = true;
}
/*
private Task taskPacketCaclQueue;
private bool m_bThreadPCQBlock;
//
private CancellationTokenSource CTS;
private CancellationToken CT;
//
private async void WatchPacketCaclQueue()
{
await Task.Delay(250).ConfigureAwait(false);
while (!m_bThreadPCQBlock)
{
try
{
CT.ThrowIfCancellationRequested();
}
catch (OperationCanceledException CancelEx)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @" Work Canceled. [SystemX.Net.Comm : AsyncClientSocket.WatchPacketCaclQueue]\r\n" + CancelEx.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
break;
}
//
try
{
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"General Queue Schedule failed. [SystemX.Net.Comm : AsyncClientSocket.WatchPacketCaclQueue]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
await Task.Delay(1).ConfigureAwait(false);
}
}
*/
public bool CONNECT
{
get { return this.m_bConnected; }
}
public string MSG
{
set { this.m_strGetText = value; }
get { return this.m_strGetText; }
}
public bool RECV_STATE
{
set { this.m_bGetRecv = value; }
get { return this.m_bGetRecv; }
}
public bool READY_STATE
{
set { this.bReadySocket = value; }
get { return this.bReadySocket; }
}
public string strGetLocalAddress { set; get; }
public string strGetLocalPort { set; get; }
public AsyncClientSocket(SOCKET_TYPE SOCK_TYPE, IPEndPoint SetRemote) : base(SOCKET_RULE.CLIENT, SOCK_TYPE)
{
nSocketNumber = 100;
bDisposed = false;
QPacketAllData = new Queue<CPacketDataInfo>();
QPacketRemainData = new Queue<CPacketDataInfo>();
bQueuePacketClearOn = false;
bReadySocket = false;
m_strGetIp = SetRemote.Address.ToString();
m_iGetPort = SetRemote.Port;
ClientSock = null;
cbClientSock = null;
//recvText = string.Empty;
recvStoreBuffer = new byte[USER_MAX_SIZE];
iStoreCnt = 0;
iCheckRetryCnt = 0;
recvBuffer = new byte[MAXSIZE];
//
m_bGetRecv = false;
m_bConnected = false;
AwaitSendEvent += SendCompleteEvent;
/*
taskSendQueue = null;
m_bThreadSendBlock = false;
taskSendQueue = new Task(new Action(WatchSendQueue));
taskSendQueue.Start();
*/
bReadySocket = DoReady();
/*
//
CTS = new CancellationTokenSource();
CT = CTS.Token;
//
m_bThreadPCQBlock = false;
taskPacketCaclQueue = new Task(new Action(WatchPacketCaclQueue), CT);
taskPacketCaclQueue.Start();
//
*/
}
private async void WatchSendQueue()
{
/*
while (!m_bThreadSendBlock)
{
try
{
if(qSendData.Count > 0)
{
byte[] ucGetData;
if(qSendData.TryDequeue(out ucGetData))
{
cbClientSock.BeginSend(ucGetData, 0, ucGetData.Length, SocketFlags.None, new AsyncCallback(SendCallBack), ucGetData);
stopWaitHandle.WaitOne();
}
}
}
catch (Exception e)
{
ErrorEventProcess(new CommonSocketException("Send error.[SystemX.Net.Comm : AsyncClientSocket|WatchSendQueue]"));
}
await Task.Delay(1);
}
*/
await Task.Delay(1);
}
public void ClearEventConnectCall()
{
if (Comm_Connect_Event != null)
{
foreach (Delegate d in Comm_Connect_Event.GetInvocationList())
Comm_Connect_Event -= (SocketCallEvent)d;
}
}
public void ClearEventErrorCall()
{
if (Socket_Error_Event != null)
{
foreach (Delegate d in Socket_Error_Event.GetInvocationList())
Socket_Error_Event -= (SocketCallEvent)d;
}
}
public void ClearEventSendCall()
{
if (Comm_Send_Event != null)
{
foreach (Delegate d in Comm_Send_Event.GetInvocationList())
Comm_Send_Event -= (SendRecvCallEvent)d;
}
}
public void ClearEventRecvCall()
{
if (Comm_Recv_Event != null)
{
foreach (Delegate d in Comm_Recv_Event.GetInvocationList())
Comm_Recv_Event -= (SendRecvCallEvent)d;
}
}
public void ClearEventAsyncSendCall()
{
if (AwaitSendEvent != null)
{
foreach (Delegate d in AwaitSendEvent.GetInvocationList())
AwaitSendEvent -= (EventHandler<ScheduleEvent>)d;
}
}
public void ClearEventAsyncRecvCall()
{
if (AwaitRecvEvent != null)
{
foreach (Delegate d in AwaitRecvEvent.GetInvocationList())
AwaitRecvEvent -= (EventHandler<ScheduleEvent>)d;
}
}
protected override void Dispose(bool disposing)
{
if (!bDisposed)
{
try
{
/*
if (taskSendQueue != null)
{
m_bThreadSendBlock = true;
taskSendQueue.Wait();
}
*/
// dispose managed resource (종결자를 가진 객체의 자원 해제)
/*
if (cbClientSock != null)
{
if (cbClientSock.Connected)
{
cbClientSock.Disconnect(false);
cbClientSock.Shutdown(SocketShutdown.Both);
cbClientSock.Close();
cbClientSock = null;
}
cbClientSock = null;
}
*/
if (ClientSock != null)
{
if (ClientSock.Connected)
{
ClientSock.Disconnect(false);
ClientSock.Shutdown(SocketShutdown.Both);
}
ClientSock.Close();
ClientSock = null;
}
/*if(cbClientSock != null)
cbClientSock.Close();*/
cbClientSock = null;
m_bConnected = false;
}
catch
{
cbClientSock = null;
ClientSock = null;
m_bConnected = false;
ErrorEventProcess(new Exception("Dispose failed. [SystemX.Net.Comm : AsyncClientSocket.Dispose]"));
}
finally
{
ClearEventAsyncSendCall();
ClearEventAsyncRecvCall();
ClearEventSendCall();
ClearEventRecvCall();
/*
ClearEventConnectCall();
ClearEventErrorCall();
*/
}
if (disposing)
{
//Manage
}
//Unmanage
recvStoreBuffer = null;
recvBuffer = null;
bDisposed = true;
}
//Base Dispose
base.Dispose(disposing);
}
private void ErrorEventProcess(Exception e, bool ConnectStateOff = false)
{
//if (e.SocketErrorCode == SocketError.NotConnected)
m_bConnected = ConnectStateOff;
Socket_Error_Event?.Invoke(e, new ScheduleEvent(nSocketNumber, false, "Error", 0));
}
private bool DoReady()
{
bool bDoState = true;
try
{
if (base.SOCK_TYPE == SOCKET_TYPE.TCP)
ClientSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
else if (base.SOCK_TYPE == SOCKET_TYPE.UDP)
ClientSock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
if (base.SOCK_TYPE == SOCKET_TYPE.TCP)
{
LingerOption SetLinger = new LingerOption(true, 1);
ClientSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, SetLinger);
//ClientSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
var option = new TcpKeepAlive
{
OnOff = 1,
KeepAliveTime = 90000,
KeepAliveInterval = 3000
};
int iState = ClientSock.IOControl(IOControlCode.KeepAliveValues, option.GetBytes(), null);
}
}
catch (Exception e)
{
bDoState = false;
/* 접속 실패 */
ErrorEventProcess(e);
}
finally
{
;//
}
return bDoState;
}
public void Connect()
{
if (bReadySocket)
BeginConnect();
}
private void BeginConnect()
{
try
{
/* 접속 대기중 */
ClientSock.BeginConnect(m_strGetIp, m_iGetPort, new AsyncCallback(ConnectCallBack), ClientSock);
}
catch (Exception e)
{
/* 접속 실패 */
ErrorEventProcess(e);
}
}
private void ConnectCallBack(IAsyncResult IAR)
{
try
{
//보류중인 연결을 완성
Socket tempSock = (Socket)IAR.AsyncState;
IPEndPoint svrEP = (IPEndPoint)tempSock.RemoteEndPoint;
IPEndPoint connEP = (IPEndPoint)tempSock.LocalEndPoint;
string strLocalAddress = connEP.Address.ToString();
string strLocalPort = connEP.Port.ToString();
strGetLocalAddress = strLocalAddress;
strGetLocalPort = strLocalPort;
tempSock.EndConnect(IAR);
//AsyncSocketObject objScoket = new AsyncSocketObject(MAXSIZE);
//objScoket.WorkSocket = tempSock;
cbClientSock = tempSock;// objScoket.WorkSocket;
/*
LingerOption SetLinger = new LingerOption(true, 1);
cbClientSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, SetLinger);
cbClientSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
var option = new TcpKeepAlive
{
OnOff = 1,
KeepAliveTime = 53000,
KeepAliveInterval = 2000
};
int iState = cbClientSock.IOControl(IOControlCode.KeepAliveValues, option.GetBytes(), null);
*/
//데이터 받을 이벤트 함수 등록
cbClientSock.BeginReceive(recvBuffer, 0, MAXSIZE, SocketFlags.None, new AsyncCallback(OnReceiveCallBack), ClientSock);
m_bConnected = true;
Comm_Connect_Event?.BeginInvoke(ClientSock, new ScheduleEvent(nSocketNumber, true, "Connect", 0), InvokeCallback, null);
}
catch (Exception e)
{
/* 접속 실패 */
ErrorEventProcess(e);
}
}
private void InvokeCallback(object obj)
{
}
public override bool BeginSend(byte[] ucDatas)
{
bool bState = true;
if (cbClientSock == null)
return false;
//qSendData.Enqueue(ucDatas);
try
{
//연결 성공시
if (cbClientSock.Connected || base.SOCK_TYPE == SOCKET_TYPE.UDP)
{
cbClientSock.BeginSend(ucDatas, 0, ucDatas.Length, SocketFlags.None, new AsyncCallback(SendCallBack), ucDatas);
}
}
catch (Exception e)
{
bState = false;
//전송 에러
ErrorEventProcess(e);
}
return bState;
}
public override bool BeginSend(Socket SetSock, byte[] ucDatas)
{
bool bState = true;
if (cbClientSock == null)
return false;
try
{
//연결 성공시
if (SetSock.Connected || base.SOCK_TYPE == SOCKET_TYPE.UDP)
{
SetSock.BeginSend(ucDatas, 0, ucDatas.Length, SocketFlags.None, new AsyncCallback(SendCallBack), ucDatas);
}
}
catch (Exception e)
{
bState = false;
//전송 에러
ErrorEventProcess(e);
}
return bState;
}
public override bool BeginSend(string strMessage)
{
bool bState = true;
if (cbClientSock == null)
return false;
try
{
//연결 성공시
if (cbClientSock.Connected || base.SOCK_TYPE == SOCKET_TYPE.UDP)
{
byte[] buffer = new UnicodeEncoding().GetBytes(strMessage);
cbClientSock.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(SendCallBack), strMessage);
}
}
catch (Exception e)
{
bState = false;
//전송 에러
ErrorEventProcess(e);
}
return bState;
}
private void SendCallBack(IAsyncResult IAR)
{
//전송 완료
byte[] getData = null;
ScheduleEvent se = new ScheduleEvent(nSocketNumber, false, "Send Fail", 0);
if (cbClientSock == null)
return;
bool bResult = true;
try
{
getData = (byte[])IAR.AsyncState;
if (getData != null)
se = new ScheduleEvent(nSocketNumber, true, "Send Success", 0);
else
se = new ScheduleEvent(nSocketNumber, false, "Send Fail", 0);
}
catch (Exception e)
{
bResult = false;
//Callback Error
ErrorEventProcess(e);
}
finally
{
if (bResult)
{
Comm_Send_Event?.BeginInvoke(getData, se, null, null);
AwaitSendEvent?.BeginInvoke(getData, se, null, null);
//Comm_Send_Event?.Invoke(getData, se);
//AwaitSendEvent?.Invoke(getData, se);
}
}
//
try
{
int iSendCnt = cbClientSock.EndSend(IAR);
}
catch (Exception e)
{
bResult = false;
//Callback Error
ErrorEventProcess(e);
}
}
private void SendCompleteEvent(object senderData, ScheduleEvent e)
{
}
private void Receive()
{
if (cbClientSock == null)
return;
//받기
try
{
if (cbClientSock.Connected || base.SOCK_TYPE == SOCKET_TYPE.UDP)
cbClientSock.BeginReceive(recvBuffer, 0, MAXSIZE, SocketFlags.None, new AsyncCallback(OnReceiveCallBack), cbClientSock);
}
catch (Exception e)
{
ErrorEventProcess(e);
}
}
private void OnReceiveCallBack(IAsyncResult IAR)
{
bool bReceiveState = true;
int nReadSize = 0;
Socket ClientSideSock = null;
//AsyncSocketObject objScoket = null;
try
{
//수신
ClientSideSock = (Socket)IAR.AsyncState;
//objScoket = (AsyncSocketObject)IAR.AsyncState;
}
catch (Exception e)
{
this.Dispose(true);
//수신 실패
ErrorEventProcess(new CommonSocketException("Middleware server side connection lost.[SystemX.Net.Comm : AsyncClientSocket|OnReceiveCallBack]"));
return;
}
try
{
if (ClientSideSock.Connected)
nReadSize = ClientSideSock.EndReceive(IAR);
else
{
if (base.SOCK_TYPE == SOCKET_TYPE.UDP)
nReadSize = ClientSideSock.EndReceive(IAR);
else
bReceiveState = false;
}
}
catch (Exception e)
{
bReceiveState = false;
}
//
if (bReceiveState)
{
if (nReadSize != 0)
{
byte[] ucFindData = new byte[1];
//byte[] ucSetClearArray;
int iFindDataCnt = 0;
//bool bSegmentFind = false;
bool bDataFind = false;
byte ucGetLabel = 0;
try
{
/*
Array.Copy(recvBuffer, 0, recvStoreBuffer, iStoreCnt, nReadSize);
iStoreCnt += nReadSize;
*/
if (bQueuePacketClearOn)
{
bQueuePacketClearOn = false;
QPacketAllData.Clear();
}
//
QPacketAllData.Enqueue(new CPacketDataInfo(DateTime.Now, recvBuffer, nReadSize));
foreach (var n in QPacketAllData.ToList())
{
TimeSpan dsInterval = DateTime.Now - n.dtPacket;
//오랜된 패킷 소거
if (dsInterval.TotalSeconds >= 20.0)
QPacketAllData.Dequeue();
else
QPacketRemainData.Enqueue(new CPacketDataInfo(n.ID, n.dtPacket, n.ucData, n.nDataSize));
}
//
iStoreCnt = 0;
Array.Clear(recvStoreBuffer, 0, USER_MAX_SIZE);
Guid[] guidUsePacketID = new Guid[QPacketRemainData.Count];
int nPacketPos = 0;
//남은 패킷중 연산 시도
foreach (var n in QPacketRemainData.ToList())
{
Array.Copy(n.ucData, 0, recvStoreBuffer, iStoreCnt, n.nDataSize);
iStoreCnt += n.nDataSize;
guidUsePacketID[nPacketPos++] = n.ID;
for (int j = 0; j < iStoreCnt; j++)
{
if (recvStoreBuffer[j] == 0x0D &&
recvStoreBuffer[j + 1] == 0x02 &&
recvStoreBuffer[j + 6] == 0x08 &&
recvStoreBuffer[j + 7] == 0x0A)
{
ucGetLabel = recvStoreBuffer[j - 1];
uint uiGetPacketSize = 0x0;
uiGetPacketSize |= (uint)(recvStoreBuffer[j + 2] << 24);
uiGetPacketSize |= (uint)(recvStoreBuffer[j + 3] << 16);
uiGetPacketSize |= (uint)(recvStoreBuffer[j + 4] << 8);
uiGetPacketSize |= (uint)(recvStoreBuffer[j + 5] << 0);
int iGetSize = (int)uiGetPacketSize;
iGetSize += XCommons.PAD_SIZE;
if (recvStoreBuffer[j + iGetSize - 4] == 0x0D &&
recvStoreBuffer[j + iGetSize - 3] == 0x02 &&
recvStoreBuffer[j + iGetSize - 2] == 0x08 &&
recvStoreBuffer[j + iGetSize - 1] == 0x0A)
{
iFindDataCnt = iGetSize;
ucFindData = new byte[iFindDataCnt];
Array.Copy(recvStoreBuffer, j, ucFindData, 0, iFindDataCnt);
bDataFind = true;
break;
}
else
{
bDataFind = false;
break;
}
}
}
//
if(bDataFind)
{
//성공한 패킷이 있을경우 해당 패킷 제거
foreach (var m in QPacketAllData.ToList())
{
for (int i = 0; i < guidUsePacketID.Count(); i++)
{
if (m.ID == guidUsePacketID[i])
{
QPacketAllData.Dequeue();
break;
}
}
}
break;
}
}
QPacketRemainData.Clear();
//recvText += Encoding.Unicode.GetString(recvBuffer, 0, nReadSize);
/*
for (int i = 0; i < iStoreCnt; i++)
{
if (recvStoreBuffer[i] == 0x0D &&
recvStoreBuffer[i + 1] == 0x02 &&
recvStoreBuffer[i + 6] == 0x08 &&
recvStoreBuffer[i + 7] == 0x0A)
{
ucGetLabel = recvStoreBuffer[i - 1];
uint uiGetPacketSize = 0x0;
uiGetPacketSize |= (uint)(recvStoreBuffer[i + 2] << 24);
uiGetPacketSize |= (uint)(recvStoreBuffer[i + 3] << 16);
uiGetPacketSize |= (uint)(recvStoreBuffer[i + 4] << 8);
uiGetPacketSize |= (uint)(recvStoreBuffer[i + 5] << 0);
int iGetSize = (int)uiGetPacketSize;
iGetSize += XCommons.PAD_SIZE;
if (recvStoreBuffer[i + iGetSize - 4] == 0x0D &&
recvStoreBuffer[i + iGetSize - 3] == 0x02 &&
recvStoreBuffer[i + iGetSize - 2] == 0x08 &&
recvStoreBuffer[i + iGetSize - 1] == 0x0A)
{
iFindDataCnt = iGetSize;
bSegmentFind = true;
}
if (bSegmentFind)
{
iCheckRetryCnt = 0;
ucFindData = new byte[iFindDataCnt];
ucSetClearArray = new byte[(iFindDataCnt + 1)];
Array.Clear(ucSetClearArray, 0, (iFindDataCnt + 1));
Array.Copy(recvStoreBuffer, i, ucFindData, 0, iFindDataCnt);
iStoreCnt -= (iFindDataCnt + 1);
Buffer.BlockCopy(ucSetClearArray, 0, recvStoreBuffer, 0, (iFindDataCnt + 1));
Buffer.BlockCopy(recvStoreBuffer, iStoreCnt, recvStoreBuffer, 0, USER_MAX_SIZE - iStoreCnt);
bDataFind = true;
break;
}
else
{
iCheckRetryCnt++;
if (iCheckRetryCnt > MAX_CHECK_COUNT)
{
iCheckRetryCnt = 0;
ucSetClearArray = new byte[iFindDataCnt];
Array.Clear(ucSetClearArray, 0, iFindDataCnt);
iStoreCnt -= iFindDataCnt;
Buffer.BlockCopy(ucSetClearArray, 0, recvStoreBuffer, 0, iFindDataCnt);
Buffer.BlockCopy(recvStoreBuffer, iStoreCnt, recvStoreBuffer, 0, USER_MAX_SIZE - iStoreCnt);
}
break;
}
}
}
*/
}
catch (Exception e)
{
bDataFind = false;
/*
iStoreCnt = 0;
if(recvStoreBuffer != null) Array.Clear(recvStoreBuffer, 0, recvStoreBuffer.Count());
*/
}
if (bDataFind)
{
bool bDataControl = true;
byte[] ucGetInfp = null;
try
{
ucGetInfp = new byte[iFindDataCnt];
Array.Copy(ucFindData, ucGetInfp, iFindDataCnt);
}
catch (Exception e)
{
bDataControl = false;
}
ScheduleEvent se = null;
m_bGetRecv = true;
//recvText = string.Empty;
if (bDataControl)
{
se = new ScheduleEvent(nSocketNumber, true, "Recv Success", ucGetLabel);
}
else
{
se = new ScheduleEvent(nSocketNumber, false, "Recv Fail", ucGetLabel);
}
Comm_Recv_Event?.BeginInvoke(ucGetInfp, se, null, null);
AwaitRecvEvent?.BeginInvoke(ucGetInfp, se, null, null);
//Comm_Recv_Event?.Invoke(ucGetInfp, se);
//AwaitRecvEvent?.Invoke(ucGetInfp, se);
}
this.Receive();
//objScoket.WorkSocket.BeginReceive(objScoket.recvBuffer, 0, MAXSIZE, SocketFlags.None, new AsyncCallback(OnReceiveCallBack), objScoket);
}
else
{
this.Dispose(true);
ErrorEventProcess(new CommonSocketException("Middleware server side connection lost.[SystemX.Net.Comm : AsyncClientSocket|OnReceiveCallBack]"));
}
}
else
{
this.Dispose(true);
ErrorEventProcess(new CommonSocketException("Middleware server side connection lost.[SystemX.Net.Comm : AsyncClientSocket|OnReceiveCallBack]"));
}
}
}
}

871
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.Comm/AsyncComClientSocket.cs Normal file
View File

@ -0,0 +1,871 @@
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using SystemX.Common;
using SystemX.Common.Serialization;
using SystemX.Net.Comm;
namespace SystemX.Net.Comm
{
public class AsyncComClientSocket : SystemXSocket, IDisposable
{
private Socket ClientSock; /* client Socket */
private Socket cbClientSock; /* client Async Callback Socket */
private byte[] recvBuffer;
//private String recvText;
private byte[] recvStoreBuffer;
private int iStoreCnt;
private int iCheckRetryCnt;
private const int MAX_CHECK_COUNT = 100; /* 256000 / 4096 <- 65526 / 4096 */
private const int USER_MAX_SIZE = 819200; /* 256000 <- 1000000 65536 */
private const int MAXSIZE = 8192; /* 8192 <- 4096 */
private string m_strGetIp;
private int m_iGetPort;
private bool m_bConnected;
private string m_strGetText;
private bool m_bGetRecv;
private bool bDisposed;
public override event SocketCallEvent Comm_Connect_Event;
public override event SocketCallEvent Socket_Error_Event;
public override event SendRecvCallEvent Comm_Send_Event;
public override event SendRecvCallEvent Comm_Recv_Event;
public override event EventHandler<ScheduleEvent> AwaitSendEvent;
public override event EventHandler<ScheduleEvent> AwaitRecvEvent;
private Queue<CPacketDataInfo> QPacketAllData;
private Queue<CPacketDataInfo> QPacketRemainData;
private bool bQueuePacketClearOn;
public override void SetRefSocketPacketClear()
{
bQueuePacketClearOn = true;
}
/*
private Task taskSendQueue;
private bool m_bThreadSendBlock;
private ConcurrentQueue<byte[]> qSendData = new ConcurrentQueue<byte[]>();
AutoResetEvent stopWaitHandle = new AutoResetEvent(false);
*/
public bool CONNECT
{
get { return this.m_bConnected; }
}
public string MSG
{
set { this.m_strGetText = value; }
get { return this.m_strGetText; }
}
public bool RECV_STATE
{
set { this.m_bGetRecv = value; }
get { return this.m_bGetRecv; }
}
public string strGetLocalAddress { set; get; }
public string strGetLocalPort { set; get; }
public AsyncComClientSocket(SOCKET_TYPE SOCK_TYPE, IPEndPoint SetRemote) : base(SOCKET_RULE.CLIENT, SOCK_TYPE)
{
nSocketNumber = 100;
bDisposed = false;
QPacketAllData = new Queue<CPacketDataInfo>();
QPacketRemainData = new Queue<CPacketDataInfo>();
bQueuePacketClearOn = false;
m_strGetIp = SetRemote.Address.ToString();
m_iGetPort = SetRemote.Port;
ClientSock = null;
cbClientSock = null;
//recvText = string.Empty;
recvStoreBuffer = new byte[USER_MAX_SIZE];
iStoreCnt = 0;
iCheckRetryCnt = 0;
recvBuffer = new byte[MAXSIZE];
//
m_bGetRecv = false;
m_bConnected = false;
AwaitSendEvent += SendCompleteEvent;
/*
taskSendQueue = null;
m_bThreadSendBlock = false;
taskSendQueue = new Task(new Action(WatchSendQueue));
taskSendQueue.Start();
*/
this.DoInit();
}
private async void WatchSendQueue()
{
/*
while (!m_bThreadSendBlock)
{
try
{
if(qSendData.Count > 0)
{
byte[] ucGetData;
if(qSendData.TryDequeue(out ucGetData))
{
cbClientSock.BeginSend(ucGetData, 0, ucGetData.Length, SocketFlags.None, new AsyncCallback(SendCallBack), ucGetData);
stopWaitHandle.WaitOne();
}
}
}
catch (Exception e)
{
ErrorEventProcess(new CommonSocketException("Send error.[SystemX.Net.Comm : AsyncClientSocket|WatchSendQueue]"));
}
await Task.Delay(1);
}
*/
await Task.Delay(1);
}
public void ClearEventConnectCall()
{
if (Comm_Connect_Event != null)
{
foreach (Delegate d in Comm_Connect_Event.GetInvocationList())
Comm_Connect_Event -= (SocketCallEvent)d;
}
}
public void ClearEventErrorCall()
{
if (Socket_Error_Event != null)
{
foreach (Delegate d in Socket_Error_Event.GetInvocationList())
Socket_Error_Event -= (SocketCallEvent)d;
}
}
public void ClearEventSendCall()
{
if (Comm_Send_Event != null)
{
foreach (Delegate d in Comm_Send_Event.GetInvocationList())
Comm_Send_Event -= (SendRecvCallEvent)d;
}
}
public void ClearEventRecvCall()
{
if (Comm_Recv_Event != null)
{
foreach (Delegate d in Comm_Recv_Event.GetInvocationList())
Comm_Recv_Event -= (SendRecvCallEvent)d;
}
}
public void ClearEventAsyncSendCall()
{
if (AwaitSendEvent != null)
{
foreach (Delegate d in AwaitSendEvent.GetInvocationList())
AwaitSendEvent -= (EventHandler<ScheduleEvent>)d;
}
}
public void ClearEventAsyncRecvCall()
{
if (AwaitRecvEvent != null)
{
foreach (Delegate d in AwaitRecvEvent.GetInvocationList())
AwaitRecvEvent -= (EventHandler<ScheduleEvent>)d;
}
}
protected override void Dispose(bool disposing)
{
if (!bDisposed)
{
AwaitSendEvent -= SendCompleteEvent;
try
{
/*
if (taskSendQueue != null)
{
m_bThreadSendBlock = true;
taskSendQueue.Wait();
}
*/
// dispose managed resource (종결자를 가진 객체의 자원 해제)
/*
if (cbClientSock != null)
{
if (cbClientSock.Connected)
{
cbClientSock.Disconnect(false);
cbClientSock.Shutdown(SocketShutdown.Both);
cbClientSock.Close();
cbClientSock = null;
}
cbClientSock = null;
}
*/
if (ClientSock != null)
{
if (ClientSock.Connected)
{
ClientSock.Disconnect(false);
ClientSock.Shutdown(SocketShutdown.Both);
ClientSock.Close();
ClientSock = null;
}
ClientSock = null;
}
/*if(cbClientSock != null)
cbClientSock.Close();*/
cbClientSock = null;
m_bConnected = false;
}
catch
{
cbClientSock = null;
ClientSock = null;
m_bConnected = false;
ErrorEventProcess(new Exception("Dispose failed. [SystemX.Net.Comm : AsyncComClientSocket.Dispose]"));
}
finally
{
ClearEventAsyncSendCall();
ClearEventAsyncRecvCall();
ClearEventSendCall();
ClearEventRecvCall();
/*
ClearEventConnectCall();
ClearEventErrorCall();
*/
}
if (disposing)
{
//Manage
}
//Unmanage
recvStoreBuffer = null;
recvBuffer = null;
bDisposed = true;
}
//Base Dispose
base.Dispose(disposing);
}
private void ErrorEventProcess(Exception e, bool ConnectStateOff = false)
{
//if (e.SocketErrorCode == SocketError.NotConnected)
m_bConnected = ConnectStateOff;
Socket_Error_Event?.Invoke(e, new ScheduleEvent(nSocketNumber, false, "Error", 0));
}
private void DoInit()
{
bool bDoState = true;
try
{
if (base.SOCK_TYPE == SOCKET_TYPE.TCP)
ClientSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
else if (base.SOCK_TYPE == SOCKET_TYPE.UDP)
ClientSock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
if (base.SOCK_TYPE == SOCKET_TYPE.TCP)
{
LingerOption SetLinger = new LingerOption(true, 1);
ClientSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, SetLinger);
//ClientSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
var option = new TcpKeepAlive
{
OnOff = 1,
KeepAliveTime = 90000,
KeepAliveInterval = 3000
};
int iState = ClientSock.IOControl(IOControlCode.KeepAliveValues, option.GetBytes(), null);
}
}
catch (Exception e)
{
bDoState = false;
/* 접속 실패 */
ErrorEventProcess(e);
}
finally
{
if (bDoState)
this.BeginConnect();
}
}
private void BeginConnect()
{
try
{
/* 접속 대기중 */
ClientSock.BeginConnect(m_strGetIp, m_iGetPort, new AsyncCallback(ConnectCallBack), ClientSock);
}
catch (Exception e)
{
/* 접속 실패 */
ErrorEventProcess(e);
}
}
private void ConnectCallBack(IAsyncResult IAR)
{
try
{
//보류중인 연결을 완성
Socket tempSock = (Socket)IAR.AsyncState;
IPEndPoint svrEP = (IPEndPoint)tempSock.RemoteEndPoint;
IPEndPoint connEP = (IPEndPoint)tempSock.LocalEndPoint;
string strLocalAddress = connEP.Address.ToString();
string strLocalPort = connEP.Port.ToString();
strGetLocalAddress = strLocalAddress;
strGetLocalPort = strLocalPort;
tempSock.EndConnect(IAR);
//AsyncSocketObject objScoket = new AsyncSocketObject(MAXSIZE);
//objScoket.WorkSocket = tempSock;
cbClientSock = tempSock;
/*
LingerOption SetLinger = new LingerOption(true, 1);
cbClientSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, SetLinger);
cbClientSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
var option = new TcpKeepAlive
{
OnOff = 1,
KeepAliveTime = 53000,
KeepAliveInterval = 2000
};
int iState = cbClientSock.IOControl(IOControlCode.KeepAliveValues, option.GetBytes(), null);
*/
//데이터 받을 이벤트 함수 등록
cbClientSock.BeginReceive(recvBuffer, 0, MAXSIZE, SocketFlags.None, new AsyncCallback(OnReceiveCallBack), ClientSock);
m_bConnected = true;
Comm_Connect_Event?.BeginInvoke(ClientSock, new ScheduleEvent(nSocketNumber, true, "Connect", 0), InvokeCallback, null);
}
catch (Exception e)
{
/* 접속 실패 */
ErrorEventProcess(e);
}
}
private void InvokeCallback(object obj)
{
}
public override bool BeginSend(byte[] ucDatas)
{
bool bState = true;
if (cbClientSock == null)
return false;
//qSendData.Enqueue(ucDatas);
try
{
//연결 성공시
if (cbClientSock.Connected || base.SOCK_TYPE == SOCKET_TYPE.UDP)
{
cbClientSock.BeginSend(ucDatas, 0, ucDatas.Length, SocketFlags.None, new AsyncCallback(SendCallBack), ucDatas);
}
}
catch (Exception e)
{
bState = false;
//전송 에러
ErrorEventProcess(e);
}
return bState;
}
public override bool BeginSend(Socket SetSock, byte[] ucDatas)
{
bool bState = true;
if (cbClientSock == null)
return false;
try
{
//연결 성공시
if (SetSock.Connected || base.SOCK_TYPE == SOCKET_TYPE.UDP)
{
SetSock.BeginSend(ucDatas, 0, ucDatas.Length, SocketFlags.None, new AsyncCallback(SendCallBack), ucDatas);
}
}
catch (Exception e)
{
bState = false;
//전송 에러
ErrorEventProcess(e);
}
return bState;
}
public override bool BeginSend(string strMessage)
{
bool bState = true;
if (cbClientSock == null)
return false;
try
{
//연결 성공시
if (cbClientSock.Connected || base.SOCK_TYPE == SOCKET_TYPE.UDP)
{
byte[] buffer = new UnicodeEncoding().GetBytes(strMessage);
cbClientSock.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(SendCallBack), strMessage);
}
}
catch (Exception e)
{
bState = false;
//전송 에러
ErrorEventProcess(e);
}
return bState;
}
private void SendCallBack(IAsyncResult IAR)
{
//전송 완료
byte[] getData = null;
ScheduleEvent se = new ScheduleEvent(nSocketNumber, false, "Send Fail", 0);
if (cbClientSock == null)
return;
bool bResult = true;
try
{
getData = (byte[])IAR.AsyncState;
if (getData != null)
se = new ScheduleEvent(nSocketNumber, true, "Send Success", 0);
else
se = new ScheduleEvent(nSocketNumber, false, "Send Fail", 0);
}
catch (Exception e)
{
bResult = false;
//Callback Error
ErrorEventProcess(e);
}
finally
{
if (bResult)
{
Comm_Send_Event?.BeginInvoke(getData, se, null, null);
AwaitSendEvent?.BeginInvoke(getData, se, null, null);
//Comm_Send_Event?.Invoke(getData, se);
//AwaitSendEvent?.Invoke(getData, se);
}
}
try
{
int iSendCnt = cbClientSock.EndSend(IAR);
}
catch (Exception e)
{
bResult = false;
//Callback Error
ErrorEventProcess(e);
}
}
private void SendCompleteEvent(object senderData, ScheduleEvent e)
{
}
private void Receive()
{
if (cbClientSock == null)
return;
//받기
try
{
if (cbClientSock.Connected || base.SOCK_TYPE == SOCKET_TYPE.UDP)
cbClientSock.BeginReceive(recvBuffer, 0, MAXSIZE, SocketFlags.None, new AsyncCallback(OnReceiveCallBack), ClientSock);
}
catch (Exception e)
{
ErrorEventProcess(e);
}
}
private void OnReceiveCallBack(IAsyncResult IAR)
{
bool bReceiveState = true;
int nReadSize = 0;
Socket ClientSideSock = null;
//AsyncSocketObject objScoket = null;
try
{
//수신
ClientSideSock = (Socket)IAR.AsyncState;
//objScoket = (AsyncSocketObject)IAR.AsyncState;
}
catch (Exception e)
{
this.Dispose(true);
//수신 실패
ErrorEventProcess(new CommonSocketException("Middleware server side connection lost.[SystemX.Net.Comm : AsyncClientSocket|OnReceiveCallBack]"));
return;
}
try
{
if (ClientSideSock.Connected)
nReadSize = ClientSideSock.EndReceive(IAR);
else
{
if (base.SOCK_TYPE == SOCKET_TYPE.UDP)
nReadSize = ClientSideSock.EndReceive(IAR);
else
bReceiveState = false;
}
}
catch (Exception e)
{
bReceiveState = false;
}
//
if (bReceiveState)
{
if (nReadSize != 0)
{
byte[] ucFindData = new byte[1];
//byte[] ucSetClearArray;
int iFindDataCnt = 0;
//bool bSegmentFind = false;
bool bDataFind = false;
byte ucGetLabel = 0;
try
{
/*
Array.Copy(recvBuffer, 0, recvStoreBuffer, iStoreCnt, nReadSize);
iStoreCnt += nReadSize;
*/
if (bQueuePacketClearOn)
{
bQueuePacketClearOn = false;
QPacketAllData.Clear();
}
QPacketAllData.Enqueue(new CPacketDataInfo(DateTime.Now, recvBuffer, nReadSize));
foreach (var n in QPacketAllData.ToList())
{
TimeSpan dsInterval = DateTime.Now - n.dtPacket;
//오랜된 패킷 소거
if (dsInterval.TotalSeconds >= 20.0)
QPacketAllData.Dequeue();
else
QPacketRemainData.Enqueue(new CPacketDataInfo(n.ID, n.dtPacket, n.ucData, n.nDataSize));
}
//
iStoreCnt = 0;
Array.Clear(recvStoreBuffer, 0, USER_MAX_SIZE);
Guid[] guidUsePacketID = new Guid[QPacketRemainData.Count];
int nPacketPos = 0;
//남은 패킷중 연산 시도
foreach (var n in QPacketRemainData.ToList())
{
Array.Copy(n.ucData, 0, recvStoreBuffer, iStoreCnt, n.nDataSize);
iStoreCnt += n.nDataSize;
guidUsePacketID[nPacketPos++] = n.ID;
for (int j = 0; j < iStoreCnt; j++)
{
if (recvStoreBuffer[j] == 0x0D &&
recvStoreBuffer[j + 1] == 0x02 &&
recvStoreBuffer[j + 6] == 0x08 &&
recvStoreBuffer[j + 7] == 0x0A)
{
ucGetLabel = recvStoreBuffer[j - 1];
uint uiGetPacketSize = 0x0;
uiGetPacketSize |= (uint)(recvStoreBuffer[j + 2] << 24);
uiGetPacketSize |= (uint)(recvStoreBuffer[j + 3] << 16);
uiGetPacketSize |= (uint)(recvStoreBuffer[j + 4] << 8);
uiGetPacketSize |= (uint)(recvStoreBuffer[j + 5] << 0);
int iGetSize = (int)uiGetPacketSize;
iGetSize += XCommons.PAD_SIZE;
if (recvStoreBuffer[j + iGetSize - 4] == 0x0D &&
recvStoreBuffer[j + iGetSize - 3] == 0x02 &&
recvStoreBuffer[j + iGetSize - 2] == 0x08 &&
recvStoreBuffer[j + iGetSize - 1] == 0x0A)
{
iFindDataCnt = iGetSize;
ucFindData = new byte[iFindDataCnt];
Array.Copy(recvStoreBuffer, j, ucFindData, 0, iFindDataCnt);
bDataFind = true;
break;
}
else
{
bDataFind = false;
break;
}
}
}
//
if (bDataFind)
{
//성공한 패킷이 있을경우 해당 패킷 제거
foreach (var m in QPacketAllData.ToList())
{
for (int i = 0; i < guidUsePacketID.Count(); i++)
{
if (m.ID == guidUsePacketID[i])
{
QPacketAllData.Dequeue();
break;
}
}
}
break;
}
}
QPacketRemainData.Clear();
//recvText += Encoding.Unicode.GetString(recvBuffer, 0, nReadSize);
/*
for (int i = 0; i < iStoreCnt; i++)
{
if (recvStoreBuffer[i] == 0x0D &&
recvStoreBuffer[i + 1] == 0x02 &&
recvStoreBuffer[i + 6] == 0x08 &&
recvStoreBuffer[i + 7] == 0x0A)
{
ucGetLabel = recvStoreBuffer[i - 1];
uint uiGetPacketSize = 0x0;
uiGetPacketSize |= (uint)(recvStoreBuffer[i + 2] << 24);
uiGetPacketSize |= (uint)(recvStoreBuffer[i + 3] << 16);
uiGetPacketSize |= (uint)(recvStoreBuffer[i + 4] << 8);
uiGetPacketSize |= (uint)(recvStoreBuffer[i + 5] << 0);
int iGetSize = (int)uiGetPacketSize;
iGetSize += XCommons.PAD_SIZE;
if (recvStoreBuffer[i + iGetSize - 4] == 0x0D &&
recvStoreBuffer[i + iGetSize - 3] == 0x02 &&
recvStoreBuffer[i + iGetSize - 2] == 0x08 &&
recvStoreBuffer[i + iGetSize - 1] == 0x0A)
{
iFindDataCnt = iGetSize;
bSegmentFind = true;
}
if (bSegmentFind)
{
iCheckRetryCnt = 0;
ucFindData = new byte[iFindDataCnt];
ucSetClearArray = new byte[(iFindDataCnt + 1)];
Array.Clear(ucSetClearArray, 0, (iFindDataCnt + 1));
Array.Copy(recvStoreBuffer, i, ucFindData, 0, iFindDataCnt);
iStoreCnt -= (iFindDataCnt + 1);
Buffer.BlockCopy(ucSetClearArray, 0, recvStoreBuffer, 0, (iFindDataCnt + 1));
Buffer.BlockCopy(recvStoreBuffer, iStoreCnt, recvStoreBuffer, 0, USER_MAX_SIZE - iStoreCnt);
bDataFind = true;
break;
}
else
{
iCheckRetryCnt++;
if (iCheckRetryCnt > MAX_CHECK_COUNT)
{
iCheckRetryCnt = 0;
ucSetClearArray = new byte[iFindDataCnt];
Array.Clear(ucSetClearArray, 0, iFindDataCnt);
iStoreCnt -= iFindDataCnt;
Buffer.BlockCopy(ucSetClearArray, 0, recvStoreBuffer, 0, iFindDataCnt);
Buffer.BlockCopy(recvStoreBuffer, iStoreCnt, recvStoreBuffer, 0, USER_MAX_SIZE - iStoreCnt);
}
break;
}
}
}
*/
}
catch (Exception e)
{
bDataFind = false;
/*
iStoreCnt = 0;
if (recvStoreBuffer != null) Array.Clear(recvStoreBuffer, 0, recvStoreBuffer.Count());
*/
}
if (bDataFind)
{
bool bDataControl = true;
byte[] ucGetInfp = null;
try
{
ucGetInfp = new byte[iFindDataCnt];
Array.Copy(ucFindData, ucGetInfp, iFindDataCnt);
}
catch (Exception e)
{
bDataControl = false;
}
ScheduleEvent se = null;
m_bGetRecv = true;
//recvText = string.Empty;
if (bDataControl)
{
se = new ScheduleEvent(nSocketNumber, true, "Recv Success", ucGetLabel);
}
else
{
se = new ScheduleEvent(nSocketNumber, false, "Recv Fail", ucGetLabel);
}
Comm_Recv_Event?.BeginInvoke(ucGetInfp, se, null, null);
AwaitRecvEvent?.BeginInvoke(ucGetInfp, se, null, null);
//Comm_Recv_Event?.Invoke(ucGetInfp, se);
//AwaitRecvEvent?.Invoke(ucGetInfp, se);
}
this.Receive();
//objScoket.WorkSocket.BeginReceive(objScoket.recvBuffer, 0, MAXSIZE, SocketFlags.None, new AsyncCallback(OnReceiveCallBack), objScoket);
}
else
{
this.Dispose(true);
ErrorEventProcess(new CommonSocketException("Middleware server side connection lost.[SystemX.Net.Comm : AsyncClientSocket|OnReceiveCallBack]"));
}
}
else
{
this.Dispose(true);
ErrorEventProcess(new CommonSocketException("Middleware server side connection lost.[SystemX.Net.Comm : AsyncClientSocket|OnReceiveCallBack]"));
}
}
}
}

977
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.Comm/AsyncServerSocket.cs Normal file
View File

@ -0,0 +1,977 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using SystemX.Common;
using SystemX.Common.Serialization;
using SystemX.Net.Comm;
//using static SystemX.Net.Platform.Common.Util.LogMessage;
namespace SystemX.Net.Comm
{
public class AsyncServerSocket : SystemXSocket, IDisposable
{
private Socket ServerSock;
private IPAddress SetAddress;
//Unused
private Socket ClientSock; /* client Socket */
//private Socket cbClientSock; /* client Async Callback Socket */
private byte[] recvBuffer;
//private String recvText;
private byte[] recvStoreBuffer;
private int iStoreCnt;
private int iCheckRetryCnt;
private const int MAX_CHECK_COUNT = 100; /* 256000 / 4096 <- 65526 / 4096 */
private const int USER_MAX_SIZE = 819200; /* 256000 <- 1000000 65536 */
private const int MAXSIZE = 8192; /* 8192 <- 4096 */
private string m_strGetIp;
private int m_iGetPort;
private bool m_bOpen;
private bool m_bConnected;
private string m_strGetText;
private bool m_bGetRecv;
public override event SocketCallEvent Comm_Connect_Event;
public override event SocketCallEvent Socket_Error_Event;
public override event SendRecvCallEvent Comm_Send_Event;
public override event SendRecvCallEvent Comm_Recv_Event;
private Queue<CPacketDataInfo> QPacketAllData;
private Queue<CPacketDataInfo> QPacketRemainData;
private bool bQueuePacketClearOn;
public override void SetRefSocketPacketClear()
{
bQueuePacketClearOn = true;
}
private bool bDisposed;
//
//private bool bHaveHostinfo;
//private DataTable dtHostInfo;
public bool STATE
{
get { return this.m_bOpen; }
}
public bool CLIENT_CONNECT
{
get { return this.m_bConnected; }
}
public string MSG
{
set { this.m_strGetText = value; }
get { return this.m_strGetText; }
}
public bool RECV_STATE
{
set { this.m_bGetRecv = value; }
get { return this.m_bGetRecv; }
}
public string strSetRemoteAddress { set; get; }
public string strSetRemotePort { set; get; }
/*
public bool HAVE_HOST_INFO
{
set { this.bHaveHostinfo = value; }
get { return this.bHaveHostinfo; }
}
*/
public AsyncServerSocket(SOCKET_TYPE SOCK_TYPE, int iCreatePosition, IPEndPoint SetRemote) : base(SOCKET_RULE.SERVER, SOCK_TYPE)
{
bDisposed = false;
QPacketAllData = new Queue<CPacketDataInfo>();
QPacketRemainData = new Queue<CPacketDataInfo>();
bQueuePacketClearOn = false;
strSetRemoteAddress = string.Empty;
strSetRemotePort = string.Empty;
SetAddress = SetRemote.Address;
nSocketNumber = iCreatePosition;
m_strGetIp = SetRemote.Address.ToString();
m_iGetPort = SetRemote.Port;
ServerSock = null;
ClientSock = null;
//cbClientSock = null;
//recvText = string.Empty;
recvStoreBuffer = new byte[USER_MAX_SIZE];
iStoreCnt = 0;
iCheckRetryCnt = 0;
recvBuffer = new byte[MAXSIZE];
//
m_bGetRecv = false;
m_bOpen = false;
m_bConnected = false;
SetSocketListen();
}
public AsyncServerSocket(SOCKET_TYPE SOCK_TYPE, int iCreatePosition, IPEndPoint SetRemote, DataTable dtHostInfomation) : base(SOCKET_RULE.SERVER, SOCK_TYPE)
{
bDisposed = false;
strSetRemoteAddress = string.Empty;
strSetRemotePort = string.Empty;
SetAddress = SetRemote.Address;
nSocketNumber = iCreatePosition;
m_strGetIp = SetRemote.Address.ToString();
m_iGetPort = SetRemote.Port;
ServerSock = null;
ClientSock = null;
//cbClientSock = null;
//recvText = string.Empty;
recvStoreBuffer = new byte[USER_MAX_SIZE];
iStoreCnt = 0;
iCheckRetryCnt = 0;
recvBuffer = new byte[MAXSIZE];
//
m_bGetRecv = false;
m_bOpen = false;
m_bConnected = false;
SetSocketListen();
}
protected override void Dispose(bool disposing)
{
if (!bDisposed)
{
ConnectTokken.SetTokenState((ConnectTokken.Connect_Token)nSocketNumber, false);
try
{
if (ServerSock != null)
{
if (ServerSock.Connected)
ServerSock.Shutdown(SocketShutdown.Both);
ServerSock.Close();
//ServerSock.Dispose();
ServerSock = null;
}
m_bOpen = false;
ClientSock = null;
m_bConnected = false;
}
catch (Exception e)
{
ClientSock = null;
ServerSock = null;
m_bOpen = false;
m_bConnected = false;
ErrorEventProcess(new Exception("Dispose failed. [SystemX.Net.Comm : AsyncServerSocket.Dispose]"));
}
finally
{
/*
ClearEventConnectCall();
ClearEventErrorCall();
*/
ClearEventSendCall();
ClearEventRecvCall();
}
if (disposing)
{
//Manage
}
//Unmanage
recvStoreBuffer = null;
recvBuffer = null;
bDisposed = true;
}
//Base Dispose
base.Dispose(disposing);
}
public void ClearEventConnectCall()
{
if (Comm_Connect_Event != null)
{
foreach (Delegate d in Comm_Connect_Event.GetInvocationList())
Comm_Connect_Event -= (SocketCallEvent)d;
}
}
public void ClearEventErrorCall()
{
if (Socket_Error_Event != null)
{
foreach (Delegate d in Socket_Error_Event.GetInvocationList())
Socket_Error_Event -= (SocketCallEvent)d;
}
}
public void ClearEventSendCall()
{
if (Comm_Send_Event != null)
{
foreach (Delegate d in Comm_Send_Event.GetInvocationList())
Comm_Send_Event -= (SendRecvCallEvent)d;
}
}
public void ClearEventRecvCall()
{
if (Comm_Recv_Event != null)
{
foreach (Delegate d in Comm_Recv_Event.GetInvocationList())
Comm_Recv_Event -= (SendRecvCallEvent)d;
}
}
public void ServerSocketAllClearToken()
{
ConnectTokken.AllClearToken((ConnectTokken.Connect_Token)nSocketNumber);
}
public bool ServerTokenPosCheck(int iGet)
{
return ConnectTokken.GetTokenPosState((ConnectTokken.Connect_Token)nSocketNumber, iGet);
}
public void ServerSocketUnknownError(bool bCallEvent = true)
{
ConnectTokken.SetTokenState((ConnectTokken.Connect_Token)nSocketNumber, false);
try
{
if (ClientSock != null)
{
if (ClientSock.Connected)
{
ClientSock.Disconnect(false);
ClientSock.Shutdown(SocketShutdown.Both);
ClientSock.Close();
ClientSock = null;
}
ClientSock = null;
}
//m_bOpen = false;
}
catch (Exception ex)
{
ClientSock = null;
//MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"Client socket release error.[SystemX.Net.Net.Comm.AsyncServerSocket] " + ex.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
m_bConnected = false;
if (bCallEvent)
Socket_Error_Event?.Invoke(null, new ScheduleEvent(nSocketNumber, false, "Error", 0));
}
private void ErrorEventProcess(Exception e, bool ConnectStateOff = false, bool bServerSock = false)
{
//if (e.SocketErrorCode == SocketError.NotConnected)
ConnectTokken.SetTokenState((ConnectTokken.Connect_Token)nSocketNumber, false);
if (bServerSock == false)
m_bConnected = ConnectStateOff;
else
m_bOpen = ConnectStateOff;
Socket_Error_Event?.Invoke(e, new ScheduleEvent(nSocketNumber, false, "Error", 0));
}
private void AcceptCallback(IAsyncResult ar)
{
try
{
if (m_bOpen)
{
Socket SockListen = null;
try
{
SockListen = (Socket)ar?.AsyncState;
int nGetAvailable = SockListen.Available;
}
catch (ObjectDisposedException dispose)
{
SockListen = null;
throw new Exception();
}
if (SockListen != null)
{
IPEndPoint GetIPInfo = (IPEndPoint)SockListen.LocalEndPoint;
if (ConnectTokken.GetTokenState((ConnectTokken.Connect_Token)nSocketNumber) == false)
{
ConnectTokken.SetTokenState((ConnectTokken.Connect_Token)nSocketNumber, true);
//AsyncSocketObject objScoket = new AsyncSocketObject(MAXSIZE);
Socket sockClient = SockListen.EndAccept(ar);
//objScoket.WorkSocket = sockClient;
ClientSock = sockClient; // objScoket.WorkSocket;
m_bConnected = true;
sockClient.BeginReceive(recvBuffer, 0, MAXSIZE, SocketFlags.None, new AsyncCallback(OnReceiveCallBack), ClientSock);
Comm_Connect_Event?.BeginInvoke(ClientSock, new ScheduleEvent(nSocketNumber, true, "Connect", 0), InvokeCallback, null);
}
//클라이언트의 연결 요청 대기
SockListen.BeginAccept(AcceptCallback, SockListen);
}
}
}
catch (Exception e)
{
//종료 또는 Accept 실패.
ErrorEventProcess(new CommonSocketException("Middleware server side connection lost.[SystemX.Net.Comm : AsyncServerSocket|AcceptCallback]"));
}
}
private void InvokeCallback(object obj)
{
}
private void SetSocketListen()
{
try
{
if (base.SOCK_TYPE == SOCKET_TYPE.TCP)
{
ServerSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
LingerOption SetLinger = new LingerOption(true, 0);
ServerSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, SetLinger);
//ServerSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
var option = new TcpKeepAlive
{
OnOff = 1,
KeepAliveTime = 90000,
KeepAliveInterval = 3000
};
int iState = ServerSock.IOControl(IOControlCode.KeepAliveValues, option.GetBytes(), null);
// 서버에서 클라이언트의 연결 요청을 대기하기 위해 소켓을 열어둔다.
IPEndPoint mkServerEP;
mkServerEP = new IPEndPoint(SetAddress, m_iGetPort);
ServerSock.Bind(mkServerEP);
ServerSock.Listen(1024);
SetSocketBeginReady();
}
else if (base.SOCK_TYPE == SOCKET_TYPE.UDP)
{
ServerSock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
// 서버에서 클라이언트의 연결 요청을 대기하기 위해 소켓을 열어둔다.
IPEndPoint mkServerEP;
mkServerEP = new IPEndPoint(SetAddress, m_iGetPort);
EndPoint ServerEP;
ServerEP = new IPEndPoint(SetAddress, m_iGetPort);
ServerSock.Bind(mkServerEP);
//ServerSock.BeginReceiveFrom(recvBuffer, 0, MAXSIZE, SocketFlags.None, ref ServerEP, new AsyncCallback(OnReceiveCallBack), ServerSock);
ServerSock.BeginReceive(recvBuffer, 0, MAXSIZE, SocketFlags.None, new AsyncCallback(OnReceiveCallBack), ServerSock);
}
m_bOpen = true;
}
catch (Exception e)
{
//종료 또는 Accept 실패.
ErrorEventProcess(new CommonSocketException("Server socket open-ready fail.[SystemX.Net.Comm : AsyncServerSocket|DoInit]"), false, true);
}
}
private void SetSocketBeginReady()
{
try
{
if (ServerSock != null)
// 비동기적으로 클라이언트의 연결 요청을 받는다.
ServerSock.BeginAccept(AcceptCallback, ServerSock);
}
catch (Exception e)
{
//종료 또는 Accept 실패.
ErrorEventProcess(new CommonSocketException("Server socket BeginAccept() fail. [SystemX.Net.Comm : AsyncServerSocket|SetSocketListen]"), false, true);
}
}
public override bool BeginSend(byte[] ucDatas)
{
bool bState = true;
if (ClientSock == null)
{
if (base.SOCK_TYPE != SOCKET_TYPE.UDP)
return false;
else
{
if (ServerSock == null)
return false;
}
}
try
{
if (base.SOCK_TYPE == SOCKET_TYPE.TCP)
{
/* 연결 성공시 */
if (ClientSock.Connected) ClientSock.BeginSend(ucDatas, 0, ucDatas.Length, SocketFlags.None, new AsyncCallback(SendCallBack), ucDatas);
}
else if (base.SOCK_TYPE == SOCKET_TYPE.UDP)
{
if (strSetRemoteAddress.Length > 0 && strSetRemotePort.Length > 0)
{
EndPoint setRemote = new IPEndPoint(IPAddress.Parse(strSetRemoteAddress), int.Parse(strSetRemotePort));
ServerSock.BeginSendTo(ucDatas, 0, ucDatas.Length, SocketFlags.None, setRemote, new AsyncCallback(SendCallBack), ucDatas);
}
}
}
catch (Exception e)
{
bState = false;
//전송 에러
ErrorEventProcess(e);
}
return bState;
}
public override bool BeginSend(Socket SetSock, byte[] ucDatas)
{
bool bState = true;
if (SetSock == null)
{
if (base.SOCK_TYPE != SOCKET_TYPE.UDP)
return false;
else
{
if (ServerSock == null)
return false;
}
}
try
{
/* 연결 성공시 */
if (base.SOCK_TYPE == SOCKET_TYPE.TCP)
{
if (SetSock.Connected) SetSock.BeginSend(ucDatas, 0, ucDatas.Length, SocketFlags.None, new AsyncCallback(SendCallBack), ucDatas);
}
else if (base.SOCK_TYPE == SOCKET_TYPE.UDP)
{
if (strSetRemoteAddress.Length > 0 && strSetRemotePort.Length > 0)
{
EndPoint setRemote = new IPEndPoint(IPAddress.Parse(strSetRemoteAddress), int.Parse(strSetRemotePort));
ServerSock.BeginSendTo(ucDatas, 0, ucDatas.Length, SocketFlags.None, setRemote, new AsyncCallback(SendCallBack), ucDatas);
}
}
}
catch (Exception e)
{
bState = false;
//전송 에러
ErrorEventProcess(e);
}
return bState;
}
public override bool BeginSend(string strMessage)
{
bool bState = true;
if (ClientSock == null)
{
if (base.SOCK_TYPE != SOCKET_TYPE.UDP)
return false;
else
{
if (ServerSock == null)
return false;
}
}
try
{
byte[] buffer = new UnicodeEncoding().GetBytes(strMessage);
/* 연결 성공시 */
if (base.SOCK_TYPE == SOCKET_TYPE.TCP)
{
if (ClientSock.Connected) ClientSock.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(SendCallBack), strMessage);
}
else if (base.SOCK_TYPE == SOCKET_TYPE.UDP)
{
if (strSetRemoteAddress.Length > 0 && strSetRemotePort.Length > 0)
{
EndPoint setRemote = new IPEndPoint(IPAddress.Parse(strSetRemoteAddress), int.Parse(strSetRemotePort));
ServerSock.BeginSendTo(buffer, 0, buffer.Length, SocketFlags.None, setRemote, new AsyncCallback(SendCallBack), strMessage);
}
}
}
catch (Exception e)
{
bState = false;
//전송 에러
ErrorEventProcess(e);
}
return bState;
}
private void SendCallBack(IAsyncResult IAR)
{
//전송 완료
byte[] getData = null;
ScheduleEvent se = new ScheduleEvent(nSocketNumber, false, "Send Fail", 0);
if (ClientSock == null)
{
if (base.SOCK_TYPE != SOCKET_TYPE.UDP)
return;
else
{
if (ServerSock == null)
return;
}
}
bool bResult = true;
try
{
getData = (byte[])IAR.AsyncState;
if (getData != null)
se = new ScheduleEvent(nSocketNumber, true, "Send Success", 0);
else
se = new ScheduleEvent(nSocketNumber, false, "Send Fail", 0);
}
catch (Exception e)
{
bResult = false;
//Callback Error
ErrorEventProcess(e);
}
finally
{
if (bResult)
{
Comm_Send_Event?.BeginInvoke(getData, se, null, null);
}
}
//
try
{
int iSendCnt = 0;
if (base.SOCK_TYPE != SOCKET_TYPE.UDP)
iSendCnt = ClientSock.EndSend(IAR);
else
iSendCnt = ServerSock.EndSend(IAR);
}
catch (Exception e)
{
bResult = false;
//Callback Error
ErrorEventProcess(e);
}
}
private void Receive()
{
if (ClientSock == null)
{
if (base.SOCK_TYPE != SOCKET_TYPE.UDP)
return;
else
{
if (ServerSock == null)
return;
}
}
//받기
try
{
if (base.SOCK_TYPE == SOCKET_TYPE.UDP)
ServerSock.BeginReceive(recvBuffer, 0, MAXSIZE, SocketFlags.None, new AsyncCallback(OnReceiveCallBack), ServerSock);
else
{
if (ClientSock.Connected)
ClientSock.BeginReceive(recvBuffer, 0, MAXSIZE, SocketFlags.None, new AsyncCallback(OnReceiveCallBack), ClientSock);
}
}
catch (Exception e)
{
ErrorEventProcess(e);
}
}
private void OnReceiveCallBack(IAsyncResult IAR)
{
bool bReceiveState = true;
int nReadSize = 0;
Socket ClientSideSock;
//AsyncSocketObject objScoket = null;
try
{
//수신
ClientSideSock = (Socket)IAR.AsyncState;
//objScoket = (AsyncSocketObject)IAR.AsyncState;
}
catch (Exception e)
{
this.Dispose();
//수신 실패
ErrorEventProcess(new CommonSocketException("Middleware server side connection lost.[SystemX.Net.Comm : AsyncServerSocket|OnReceiveCallBack]"));
return;
}
try
{
if (ClientSideSock.Connected)
nReadSize = ClientSideSock.EndReceive(IAR);
else
{
if (base.SOCK_TYPE == SOCKET_TYPE.UDP)
nReadSize = ClientSideSock.EndReceive(IAR);
else
bReceiveState = false;
}
}
catch (Exception e)
{
bReceiveState = false;
}
//
if (bReceiveState)
{
if (nReadSize != 0)
{
byte[] ucFindData = new byte[1];
byte[] ucSetClearArray;
int iFindDataCnt = 0;
bool bSegmentFind = false;
bool bDataFind = false;
byte ucGetLabel = 0;
try
{
/*
Array.Copy(recvBuffer, 0, recvStoreBuffer, iStoreCnt, nReadSize);
iStoreCnt += nReadSize;
*/
if(bQueuePacketClearOn)
{
bQueuePacketClearOn = false;
QPacketAllData.Clear();
}
QPacketAllData.Enqueue(new CPacketDataInfo(DateTime.Now, recvBuffer, nReadSize));
foreach (var n in QPacketAllData.ToList())
{
TimeSpan dsInterval = DateTime.Now - n.dtPacket;
//오랜된 패킷 소거
if (dsInterval.TotalSeconds >= 20.0)
QPacketAllData.Dequeue();
else
QPacketRemainData.Enqueue(new CPacketDataInfo(n.ID, n.dtPacket, n.ucData, n.nDataSize));
}
//
iStoreCnt = 0;
Array.Clear(recvStoreBuffer, 0, USER_MAX_SIZE);
Guid[] guidUsePacketID = new Guid[QPacketRemainData.Count];
int nPacketPos = 0;
//남은 패킷중 연산 시도
foreach (var n in QPacketRemainData.ToList())
{
Array.Copy(n.ucData, 0, recvStoreBuffer, iStoreCnt, n.nDataSize);
iStoreCnt += n.nDataSize;
guidUsePacketID[nPacketPos++] = n.ID;
for (int j = 0; j < iStoreCnt; j++)
{
if (recvStoreBuffer[j] == 0x0D &&
recvStoreBuffer[j + 1] == 0x02 &&
recvStoreBuffer[j + 6] == 0x08 &&
recvStoreBuffer[j + 7] == 0x0A)
{
ucGetLabel = recvStoreBuffer[j - 1];
uint uiGetPacketSize = 0x0;
uiGetPacketSize |= (uint)(recvStoreBuffer[j + 2] << 24);
uiGetPacketSize |= (uint)(recvStoreBuffer[j + 3] << 16);
uiGetPacketSize |= (uint)(recvStoreBuffer[j + 4] << 8);
uiGetPacketSize |= (uint)(recvStoreBuffer[j + 5] << 0);
int iGetSize = (int)uiGetPacketSize;
iGetSize += XCommons.PAD_SIZE;
if (recvStoreBuffer[j + iGetSize - 4] == 0x0D &&
recvStoreBuffer[j + iGetSize - 3] == 0x02 &&
recvStoreBuffer[j + iGetSize - 2] == 0x08 &&
recvStoreBuffer[j + iGetSize - 1] == 0x0A)
{
iFindDataCnt = iGetSize;
ucFindData = new byte[iFindDataCnt];
Array.Copy(recvStoreBuffer, j, ucFindData, 0, iFindDataCnt);
bDataFind = true;
break;
}
else
{
bDataFind = false;
break;
}
}
}
//
if (bDataFind)
{
//성공한 패킷이 있을경우 해당 패킷 제거
foreach (var m in QPacketAllData.ToList())
{
for (int i = 0; i < guidUsePacketID.Count(); i++)
{
if (m.ID == guidUsePacketID[i])
{
QPacketAllData.Dequeue();
break;
}
}
}
break;
}
}
QPacketRemainData.Clear();
//recvText += Encoding.Unicode.GetString(recvBuffer, 0, nReadSize);
/*
for (int i = 0; i < iStoreCnt; i++)
{
if (recvStoreBuffer[i] == 0x0D &&
recvStoreBuffer[i + 1] == 0x02 &&
recvStoreBuffer[i + 6] == 0x08 &&
recvStoreBuffer[i + 7] == 0x0A)
{
ucGetLabel = recvStoreBuffer[i - 1];
uint uiGetPacketSize = 0x0;
uiGetPacketSize |= (uint)(recvStoreBuffer[i + 2] << 24);
uiGetPacketSize |= (uint)(recvStoreBuffer[i + 3] << 16);
uiGetPacketSize |= (uint)(recvStoreBuffer[i + 4] << 8);
uiGetPacketSize |= (uint)(recvStoreBuffer[i + 5] << 0);
int iGetSize = (int)uiGetPacketSize;
iGetSize += XCommons.PAD_SIZE;
if (recvStoreBuffer[i + iGetSize - 4] == 0x0D &&
recvStoreBuffer[i + iGetSize - 3] == 0x02 &&
recvStoreBuffer[i + iGetSize - 2] == 0x08 &&
recvStoreBuffer[i + iGetSize - 1] == 0x0A)
{
iFindDataCnt = iGetSize;
bSegmentFind = true;
}
if (bSegmentFind)
{
iCheckRetryCnt = 0;
ucFindData = new byte[iFindDataCnt];
ucSetClearArray = new byte[(iFindDataCnt + 1)];
Array.Clear(ucSetClearArray, 0, (iFindDataCnt + 1));
Array.Copy(recvStoreBuffer, i, ucFindData, 0, iFindDataCnt);
iStoreCnt -= (iFindDataCnt + 1);
Buffer.BlockCopy(ucSetClearArray, 0, recvStoreBuffer, 0, (iFindDataCnt + 1));
Buffer.BlockCopy(recvStoreBuffer, iStoreCnt, recvStoreBuffer, 0, USER_MAX_SIZE - iStoreCnt);
bDataFind = true;
break;
}
else
{
iCheckRetryCnt++;
if (iCheckRetryCnt > MAX_CHECK_COUNT)
{
iCheckRetryCnt = 0;
ucSetClearArray = new byte[iFindDataCnt];
Array.Clear(ucSetClearArray, 0, iFindDataCnt);
iStoreCnt -= iFindDataCnt;
Buffer.BlockCopy(ucSetClearArray, 0, recvStoreBuffer, 0, iFindDataCnt);
Buffer.BlockCopy(recvStoreBuffer, iStoreCnt, recvStoreBuffer, 0, USER_MAX_SIZE - iStoreCnt);
}
break;
}
}
}
*/
}
catch (Exception e)
{
bDataFind = false;
/*
iStoreCnt = 0;
if (recvStoreBuffer != null) Array.Clear(recvStoreBuffer, 0, recvStoreBuffer.Count());
*/
}
//
if (bDataFind)
{
bool bDataControl = true;
byte[] ucGetInfp = null;
try
{
ucGetInfp = new byte[iFindDataCnt];
Array.Copy(ucFindData, ucGetInfp, iFindDataCnt);
}
catch (Exception e)
{
bDataControl = false;
}
ScheduleEvent se = null;
m_bGetRecv = true;
//recvText = string.Empty;
if (bDataControl)
{
se = new ScheduleEvent(nSocketNumber, true, "Recv Success", ucGetLabel);
}
else
{
se = new ScheduleEvent(nSocketNumber, false, "Recv Fail", ucGetLabel);
}
Comm_Recv_Event?.BeginInvoke(ucGetInfp, se, null, null);
}
this.Receive();
//objScoket.WorkSocket.BeginReceive(objScoket.recvBuffer, 0, MAXSIZE, SocketFlags.None, new AsyncCallback(OnReceiveCallBack), objScoket);
}
else
{
this.Dispose();
ErrorEventProcess(new Exception("Middleware server side connection lost.[SystemX.Net.Comm : AsyncServerSocket.OnReceiveCallBack]"));
}
}
else
{
this.Dispose();
ErrorEventProcess(new Exception("Middleware server side connection lost.[SystemX.Net.Comm : AsyncServerSocket.OnReceiveCallBack]"));
}
}
}
}

383
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.Comm/Comm.cs Normal file
View File

@ -0,0 +1,383 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using SystemX.Common;
using SystemX.Common.Serialization;
namespace SystemX.Net.Comm
{
//
// 요약:
// Socket error information
public class CommonSocketException : Exception
{
public CommonSocketException()
{
}
public CommonSocketException(string message)
: base(message)
{
}
public CommonSocketException(string message, Exception inner)
: base(message, inner)
{
}
}
public enum SOCKET_RULE
{
NONE = -1,
SERVER = 0,
CLIENT = 1
}
public enum SOCKET_TYPE
{
NONE = -1,
TCP = 0,
UDP = 1
}
public class SystemXSocket : IDisposable
{
public virtual event SocketCallEvent Comm_Connect_Event;
public virtual event SocketCallEvent Socket_Error_Event;
public virtual event SendRecvCallEvent Comm_Send_Event;
public virtual event SendRecvCallEvent Comm_Recv_Event;
public virtual event EventHandler<ScheduleEvent> AwaitSendEvent;
public virtual event EventHandler<ScheduleEvent> AwaitRecvEvent;
public int nSocketNumber;
private bool bDisposed;
public SOCKET_RULE SOCK_RULE { set; get; }
public SOCKET_TYPE SOCK_TYPE { set; get; }
public SystemXSocket(SOCKET_RULE GET_SOCK_RULE, SOCKET_TYPE GET_SOCK_TYPE) {
SOCK_RULE = GET_SOCK_RULE;
SOCK_TYPE = GET_SOCK_TYPE;
bDisposed = false;
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool bDisposing)
{
if(bDisposed == false)
{
if(bDisposing)
{
//Manage
}
//Unmanage
bDisposed = true;
}
}
~SystemXSocket()
{
Dispose(false);
}
public virtual bool BeginSend(byte[] ucDatas) { return true; }
public virtual bool BeginSend(Socket SetSock, byte[] ucDatas) { return true; }
public virtual bool BeginSend(string strMessage) { return true; }
public virtual void SetRefSocketPacketClear() { return; }
}
public class CPacketDataInfo
{
public Guid ID;
public DateTime dtPacket;
public byte[] ucData;
public int nDataSize;
public CPacketDataInfo(DateTime dateTime, byte[] ucGetData, int nGetSize)
{
if (ID == default(Guid))
ID = Guid.NewGuid();
dtPacket = dateTime;
nDataSize = nGetSize;
ucData = new byte[nGetSize];
Buffer.BlockCopy(ucGetData, 0, ucData, 0, nGetSize);
}
public CPacketDataInfo(Guid SetID, DateTime dateTime, byte[] ucGetData, int nGetSize)
{
ID = SetID;
dtPacket = dateTime;
nDataSize = nGetSize;
ucData = new byte[nGetSize];
Buffer.BlockCopy(ucGetData, 0, ucData, 0, nGetSize);
}
}
public class AsyncSocketObject
{
public byte[] recvBuffer;
public Socket WorkSocket;
public readonly int iBufferSize;
public AsyncSocketObject(int ibufferSize)
{
iBufferSize = ibufferSize;
recvBuffer = new byte[iBufferSize];
}
public void ClearBuffer()
{
Array.Clear(recvBuffer, 0, iBufferSize);
}
}
public class TcpKeepAlive
{
public uint OnOff { get; set; }
public uint KeepAliveTime { get; set; }
public uint KeepAliveInterval { get; set; }
public byte[] GetBytes()
{
return BitConverter.GetBytes(OnOff).Concat(BitConverter.GetBytes(KeepAliveTime)).Concat(BitConverter.GetBytes(KeepAliveInterval)).ToArray();
}
}
public static class ConnectTokken
{
public enum Connect_Token
{
T010 = 0,
T020 = 1,
T030 = 2,
T040 = 3,
T050 = 4,
T060 = 5,
T070 = 6,
T080 = 7,
T090 = 8,
T100 = 9,
T110 = 10,
T120 = 11,
T130 = 12,
T140 = 13,
T150 = 14,
T160 = 15,
T170 = 16,
T180 = 17,
T190 = 18,
T200 = 19,
T210 = 20,
T220 = 21,
T230 = 22,
T240 = 23,
T250 = 24,
T260 = 25,
T270 = 26,
T280 = 27,
T290 = 28,
T300 = 29,
T310 = 30,
T320 = 31,
T330 = 32,
T340 = 33,
T350 = 34,
T360 = 35,
T370 = 36,
T380 = 37,
T390 = 38,
T400 = 39,
T410 = 40,
T420 = 41,
T430 = 42,
T440 = 43,
T450 = 44,
T460 = 45,
T470 = 46,
T480 = 47,
T490 = 48,
T500 = 49,
T510 = 50,
T520 = 51,
T530 = 52,
T540 = 53,
T550 = 54,
T560 = 55,
T570 = 56,
T580 = 57,
T590 = 58,
T600 = 59,
T610 = 60,
T620 = 61,
T630 = 62,
T640 = 63,
T650 = 64,
T660 = 65,
T670 = 66,
T680 = 67,
T690 = 68,
T700 = 69,
T710 = 70,
T720 = 71,
T730 = 72,
T740 = 73,
T750 = 74,
T760 = 75,
T770 = 76,
T780 = 77,
T790 = 78,
T800 = 79,
T810 = 80,
T820 = 81,
T830 = 82,
T840 = 83,
T850 = 84,
T860 = 85,
T870 = 86,
T880 = 87,
T890 = 88,
T900 = 89,
T910 = 90,
T920 = 91,
T930 = 92,
T940 = 93,
T950 = 94,
T960 = 95,
T970 = 96,
T980 = 97,
T990 = 98,
T1000 = 99,
T1010 = 100,
T1020 = 101,
T1030 = 102,
T1040 = 103,
T1050 = 104,
T1060 = 105,
T1070 = 106,
T1080 = 107,
T1090 = 108,
T1100 = 109,
T1110 = 110,
T1120 = 111,
T1130 = 112,
T1140 = 113,
T1150 = 114,
T1160 = 115,
T1170 = 116,
T1180 = 117,
T1190 = 118,
T1200 = 119,
T1210 = 120,
T1220 = 121,
T1230 = 122,
T1240 = 123,
T1250 = 124,
T1260 = 125,
T1270 = 126,
T1280 = 127
}
public const int MAX_PROCESS_NUM = 128;
public const int MAX_TOKEN_NUM = 128;
public static bool[,] m_bTokenUseState = new bool[MAX_PROCESS_NUM, MAX_TOKEN_NUM];
private static object objWait = new object();
public static int GET_MAX_PROCESS
{
get { return MAX_PROCESS_NUM; }
}
public static void AllClearToken(Connect_Token thisToken)
{
lock (objWait)
{
for (int i = 0; i < MAX_TOKEN_NUM; i++)
m_bTokenUseState[(int)thisToken, i] = false;
}
}
public static bool GetTokenPosState(Connect_Token thisToken, int iPos)
{
bool bValue = false;
if (iPos >= 0 && iPos < MAX_TOKEN_NUM)
bValue = m_bTokenUseState[(int)thisToken, iPos];
return bValue;
}
public static void SetTokenState(Connect_Token thisToken, bool bValue)
{
lock (objWait)
{
for (int i = 0; i < MAX_TOKEN_NUM; i++)
{
if (m_bTokenUseState[(int)thisToken, i] == !bValue)
{
m_bTokenUseState[(int)thisToken, i] = bValue;
break;
}
}
}
}
//사용 불가능 true 가능 false
public static bool GetTokenState(Connect_Token thisToken)
{
bool bUnused = true;
for (int i = 0; i < MAX_TOKEN_NUM; i++)
{
if (m_bTokenUseState[(int)thisToken, i] == false)
{
//사용 가능
bUnused = false;
return bUnused;
}
}
//사용 불가능
bUnused = true;
return bUnused;
}
}
}

20
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.Comm/IIS FTP/CommonsFTP.cs Normal file
View File

@ -0,0 +1,20 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.Net.Comm.IIS_FTP
{
public enum eFTPServiceStatus
{
None = 0,
Unused,
Connected,
Disconnected
}
}

578
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.Comm/IIS FTP/CtrlFTP.cs Normal file
View File

@ -0,0 +1,578 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.Net.Comm.IIS_FTP
{
public class CtrlFTP : ManagerInfoFTP
{
public CtrlFTP(bool bUseService, IPAddress SetIpAddress, int nSetPort, string strSetUserName, string strSetUserPassword)
: base (bUseService, SetIpAddress, nSetPort, strSetUserName, strSetUserPassword)
{
/*
"14.33.116.123", "2121"
"ALISFTP", "Kefico!@34"
*/
if (Connect())
FTPConnState = true;
else
FTPConnState = false;
string strGetLastCommandState = LastestCommandDebugInformation();
}
public override string GetLastestCommandStatusDescriptionText()
{
return LastestCommandStatusDescription;
}
public override FtpStatusCode GetLastestCommandStatusCodeText()
{
return LastestCommandStatusCode;
}
public override string GetLastestExceptionText()
{
return LastestCommandException.Message;
}
public override Exception GetLastestException()
{
return LastestCommandException;
}
public bool Connect()
{
LastestCommandException = null;
bool bCommandResult = true;
string url = string.Format(@"FTP://{0}:{1}/", UseInfo.InfoIPAddress.ToString(), UseInfo.InfoPort.ToString());
FtpWebRequest fwr = (FtpWebRequest)WebRequest.Create(url);
fwr.KeepAlive = false;
//fwr.UseBinary = true;
fwr.UsePassive = true;
fwr.Method = WebRequestMethods.Ftp.ListDirectory;
fwr.Credentials = new NetworkCredential(UseInfo.InfoUseUserAccount, UseInfo.InfoUseUserPassword);
StringBuilder sb = new StringBuilder();
FtpWebResponse wr = null;
try
{
using (wr = (FtpWebResponse)fwr.GetResponse())
{
LastestCommandStatusDescription = wr.StatusDescription;
LastestCommandStatusCode = wr.StatusCode;
}
}
catch(Exception FtpException)
{
bCommandResult = false;
LastestCommandException = FtpException;
}
finally
{
if(wr != null)
{
wr.Close();
wr = null;
}
}
return bCommandResult;
}
private List<string> CheckList(StringBuilder sb, bool bFolderCheck = false, string strFolderPath = "")
{
List<string> lstInfo = new List<string>();
string[] directorys = sb.ToString().Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
foreach (string strList in directorys)
{
string[] strGetItems = new string[4];
int[] nSplitPos = new int[3];
string strCopyText = strList;
for (int n = 0; n < 3; n++)
{
int nPos = strCopyText.IndexOf(' ');
int nOriginPosition = nPos;
int nCnt = 0;
while (strCopyText[nPos] == ' ')
{
nPos++;
nCnt++;
}
string strTempText = strCopyText.Substring(0, nOriginPosition);
strCopyText = strCopyText.Remove(0, nOriginPosition + nCnt);
strGetItems[n] = strTempText;
}
strGetItems[3] = strCopyText;
//string[] strGetItems = strList.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
if (strGetItems.Length != 4)
continue;
if (bFolderCheck)
{
if (strGetItems[2] != "<DIR>")
continue;
if (strFolderPath.Length == 0)
lstInfo.Add(strGetItems[3]);
else
{
if (strFolderPath.CompareTo(strGetItems[3]) == 0)
{
lstInfo.Add(strGetItems[3]);
break;
}
}
}
else
{
if (strGetItems[2] == "<DIR>")
continue;
DateTime dt = new DateTime();
if (DateTime.TryParse(strGetItems[0] + " " + strGetItems[1], CultureInfo.GetCultureInfo("en-US"), DateTimeStyles.None, out dt))
{
TimeSpan ts = DateTime.Now - dt;
if (ts.TotalSeconds >= ManagerInfoFTP.dDiffScanCheckFileTime)
lstInfo.Add(strGetItems[3]);
// TODO : FTP Download file list chekc limit 2048
if (lstInfo.Count >= 2048)
break;
}
else //Parsing failed!
continue;
}
}
return lstInfo;
}
public List<string> PositionRootCheckList(bool bFolderCheck = false, string strFolderPath = "")
{
LastestCommandException = null;
bool bCommandResult = true;
List<string> lstInfo = new List<string>();
string url = string.Format(@"FTP://{0}:{1}/", UseInfo.InfoIPAddress.ToString(), UseInfo.InfoPort.ToString());
FtpWebRequest fwr = (FtpWebRequest)WebRequest.Create(url);
fwr.KeepAlive = false;
//fwr.UseBinary = true;
fwr.UsePassive = true;
fwr.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
fwr.Credentials = new NetworkCredential(UseInfo.InfoUseUserAccount, UseInfo.InfoUseUserPassword);
StringBuilder sb = new StringBuilder();
FtpWebResponse wr = null;
try
{
using (wr = (FtpWebResponse)fwr.GetResponse())
{
LastestCommandStatusDescription = wr.StatusDescription;
LastestCommandStatusCode = wr.StatusCode;
StreamReader streamReader = new StreamReader(wr.GetResponseStream(), Encoding.Default);
sb.Append(streamReader.ReadToEnd());
}
}
catch (Exception FtpException)
{
LastestCommandException = FtpException;
bCommandResult = false;
}
finally
{
if (wr != null)
{
wr.Close();
wr = null;
}
}
if (bCommandResult)
lstInfo = CheckList(sb, bFolderCheck, strFolderPath);
return lstInfo;
}
public List<string> PositionSubCheckList(string strSubPath, bool bFolderCheck = false, string strFolderPath = "")
{
LastestCommandException = null;
bool bCommandResult = true;
List<string> lstInfo = new List<string>();
string url = string.Format(@"FTP://{0}:{1}/" + strSubPath + @"/", UseInfo.InfoIPAddress.ToString(), UseInfo.InfoPort.ToString());
FtpWebRequest fwr = (FtpWebRequest)WebRequest.Create(url);
fwr.KeepAlive = false;
//fwr.UseBinary = true;
fwr.UsePassive = true;
fwr.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
fwr.Credentials = new NetworkCredential(UseInfo.InfoUseUserAccount, UseInfo.InfoUseUserPassword);
StringBuilder sb = new StringBuilder();
FtpWebResponse wr = null;
try
{
using (wr = (FtpWebResponse)fwr.GetResponse())
{
LastestCommandStatusDescription = wr.StatusDescription;
LastestCommandStatusCode = wr.StatusCode;
StreamReader streamReader = new StreamReader(wr.GetResponseStream(), Encoding.Default);
sb.Append(streamReader.ReadToEnd());
}
}
catch (Exception FtpException)
{
LastestCommandException = FtpException;
bCommandResult = false;
}
finally
{
if (wr != null)
{
wr.Close();
wr = null;
}
}
if (bCommandResult)
lstInfo = CheckList(sb, bFolderCheck, strFolderPath);
return lstInfo;
}
public bool MakeDirectory(string strDirectoryPath)
{
LastestCommandException = null;
bool bCommandResult = true;
string url = string.Format(@"FTP://{0}:{1}/" + strDirectoryPath + @"/", UseInfo.InfoIPAddress.ToString(), UseInfo.InfoPort.ToString());
FtpWebRequest fwr = null;
FtpWebResponse wr = null;
try
{
fwr = (FtpWebRequest)WebRequest.Create(url);
fwr.KeepAlive = false;
//fwr.UseBinary = true;
fwr.UsePassive = true;
fwr.Method = WebRequestMethods.Ftp.MakeDirectory;
fwr.Credentials = new NetworkCredential("ALISFTP", "Kefico!@34");
StringBuilder sb = new StringBuilder();
using (wr = (FtpWebResponse)fwr.GetResponse())
{
// FTP 결과 스트림
LastestCommandStatusDescription = wr.StatusDescription;
LastestCommandStatusCode = wr.StatusCode;
if (LastestCommandStatusCode != System.Net.FtpStatusCode.PathnameCreated)
bCommandResult = false;
}
}
catch (Exception FtpException)
{
LastestCommandException = FtpException;
bCommandResult = false;
}
finally
{
if (wr != null)
{
wr.Close();
wr = null;
}
}
return bCommandResult;
}
public bool FileExist(string strFileName)
{
LastestCommandException = null;
bool bCommandResult = true;
string url = string.Format(@"FTP://{0}:{1}/" + strFileName, UseInfo.InfoIPAddress.ToString(), UseInfo.InfoPort.ToString());
FtpWebRequest fwr = null;
FtpWebResponse wr = null;
try
{
fwr = (FtpWebRequest)WebRequest.Create(url);
fwr.KeepAlive = false;
//fwr.UseBinary = true;
fwr.UsePassive = true;
fwr.Method = WebRequestMethods.Ftp.GetFileSize;
fwr.Credentials = new NetworkCredential(UseInfo.InfoUseUserAccount, UseInfo.InfoUseUserPassword);
StringBuilder sb = new StringBuilder();
using (wr = (FtpWebResponse)fwr.GetResponse())
{
LastestCommandStatusDescription = wr.StatusDescription;
LastestCommandStatusCode = wr.StatusCode;
if (LastestCommandStatusCode == System.Net.FtpStatusCode.ActionNotTakenFileUnavailable)
bCommandResult = false;
}
}
catch (Exception FtpException)
{
LastestCommandException = FtpException;
bCommandResult = false;
}
finally
{
if (wr != null)
{
wr.Close();
wr = null;
}
}
return bCommandResult;
}
public bool DeleteFile(string strFileName)
{
LastestCommandException = null;
bool bCommandResult = true;
string url = string.Format(@"FTP://{0}:{1}/" + strFileName, UseInfo.InfoIPAddress.ToString(), UseInfo.InfoPort.ToString());
FtpWebRequest fwr = null;
FtpWebResponse wr = null;
try
{
fwr = (FtpWebRequest)WebRequest.Create(url);
fwr.KeepAlive = false;
//fwr.UseBinary = true;
fwr.UsePassive = true;
fwr.Method = WebRequestMethods.Ftp.DeleteFile;
fwr.Credentials = new NetworkCredential(UseInfo.InfoUseUserAccount, UseInfo.InfoUseUserPassword);
StringBuilder sb = new StringBuilder();
using (wr = (FtpWebResponse)fwr.GetResponse())
{
LastestCommandStatusDescription = wr.StatusDescription;
LastestCommandStatusCode = wr.StatusCode;
if (LastestCommandStatusCode != System.Net.FtpStatusCode.FileActionOK)
bCommandResult = false;
else
{
if (LastestCommandStatusDescription.IndexOf("DELE command successful") < 0)
bCommandResult = false;
}
}
}
catch (Exception FtpException)
{
LastestCommandException = FtpException;
bCommandResult = false;
}
finally
{
if (wr != null)
{
wr.Close();
wr = null;
}
}
return bCommandResult;
}
public bool FileUpload(string strFilePos)
{
string strFileName = Path.GetFileName(strFilePos);
string url = string.Format(@"FTP://{0}:{1}/" + strFileName, UseInfo.InfoIPAddress.ToString(), UseInfo.InfoPort.ToString());
LastestCommandException = null;
bool bCommandResult = true;
FtpWebRequest fwr = null;
FtpWebResponse wr = null;
try
{
fwr = (FtpWebRequest)WebRequest.Create(url);
fwr.KeepAlive = false;
fwr.UseBinary = true;
fwr.UsePassive = true;
fwr.Method = WebRequestMethods.Ftp.UploadFile;
fwr.Credentials = new NetworkCredential(UseInfo.InfoUseUserAccount, UseInfo.InfoUseUserPassword);
// 입력파일을 바이트 배열로 읽음
byte[] ucReadData;
using (FileStream reader = new FileStream(strFilePos, FileMode.Open, FileAccess.Read))
{
ucReadData = new byte[reader.Length];
reader.Read(ucReadData, 0, (int)reader.Length);
}
// RequestStream에 데이타를 쓴다
fwr.ContentLength = ucReadData.Length;
using (Stream reqStream = fwr.GetRequestStream())
{
reqStream.Write(ucReadData, 0, ucReadData.Length);
}
// FTP Upload 실행
using (wr = (FtpWebResponse)fwr.GetResponse())
{
// FTP 결과 상태 출력
//Console.WriteLine("Upload: {0}", wr.StatusDescription);
LastestCommandStatusDescription = wr.StatusDescription;
LastestCommandStatusCode = wr.StatusCode;
if (LastestCommandStatusDescription.IndexOf("Transfer complete") >= 0)
bCommandResult = true;
}
}
catch (Exception FtpException)
{
LastestCommandException = FtpException;
bCommandResult = false;
}
finally
{
if (wr != null)
{
wr.Close();
wr = null;
}
}
return bCommandResult;
}
public async Task<string> FileDownload(string strDownloadFileName, string strCreateFilePath)
{
string url = string.Format(@"FTP://{0}:{1}/" + strDownloadFileName, UseInfo.InfoIPAddress.ToString(), UseInfo.InfoPort.ToString());
LastestCommandException = null;
bool bCommandResult = true;
FtpWebRequest fwr = null;
FtpWebResponse wr = null;
try
{
fwr = (FtpWebRequest)WebRequest.Create(url);
fwr.KeepAlive = false;
fwr.UseBinary = true;
fwr.UsePassive = true;
fwr.Method = WebRequestMethods.Ftp.DownloadFile;
fwr.Credentials = new NetworkCredential(UseInfo.InfoUseUserAccount, UseInfo.InfoUseUserPassword);
// FTP Request 결과를 가져온다.
using (wr = (FtpWebResponse)fwr.GetResponseAsync().ConfigureAwait(false).GetAwaiter().GetResult())
{
// FTP 결과 스트림
LastestCommandStatusDescription = wr.StatusDescription;
LastestCommandStatusCode = wr.StatusCode;
Stopwatch stWaitTime = new Stopwatch();
stWaitTime.Start();
while (true)
{
LastestCommandStatusDescription = wr.StatusDescription;
LastestCommandStatusCode = wr.StatusCode;
if (stWaitTime.ElapsedMilliseconds >= 10000)
throw new Exception("Can't FtpStatusCode.DataAlreadyOpen|FtpStatusCode.ClosingData");
if (LastestCommandStatusCode == System.Net.FtpStatusCode.DataAlreadyOpen ||
LastestCommandStatusCode == System.Net.FtpStatusCode.ClosingData)
break;
await Task.Delay(0);
}
Stream stream = wr.GetResponseStream();
FileStream fileStream = new FileStream(strCreateFilePath + strDownloadFileName, FileMode.Create);
byte[] ucBuffer = new byte[4096];
int nBytesRead;
while (true)
{
nBytesRead = stream.Read(ucBuffer, 0, ucBuffer.Length);
if (nBytesRead == 0)
break;
fileStream.Write(ucBuffer, 0, nBytesRead);
}
fileStream.Close();
}
}
catch (Exception FtpException)
{
LastestCommandException = FtpException;
bCommandResult = false;
}
finally
{
if (wr != null)
{
wr.Close();
wr = null;
}
}
if (bCommandResult)
return strCreateFilePath + strDownloadFileName;
else
return string.Empty;
}
}
}

77
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.Comm/IIS FTP/ManagerFTP.cs Normal file
View File

@ -0,0 +1,77 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.Net.Comm.IIS_FTP
{
public class ManagerInfoFTP
{
protected static double dDiffScanCheckFileTime = 60.0;
public sealed class ConnectFTPInformation
{
public bool UseFTPService { set; get; }
public IPAddress InfoIPAddress { set; get; }
public int InfoPort { set; get; }
public string InfoUseUserAccount { set; get; }
public string InfoUseUserPassword { set; get; }
}
protected ConnectFTPInformation UseInfo { set; get; }
protected string LastestCommandStatusDescription { set; get; }
protected FtpStatusCode LastestCommandStatusCode { set; get; }
protected Exception LastestCommandException { set; get; }
public virtual string GetLastestCommandStatusDescriptionText()
{
return string.Empty;
}
public virtual FtpStatusCode GetLastestCommandStatusCodeText()
{
return FtpStatusCode.Undefined;
}
public virtual string GetLastestExceptionText()
{
return string.Empty;
}
public virtual Exception GetLastestException()
{
return null;
}
public string LastestCommandDebugInformation()
{
string strMakeMessage = string.Format("{0}@{1}", LastestCommandStatusDescription, LastestCommandStatusCode.ToString());
if (LastestCommandException != null)
strMakeMessage += "@" + LastestCommandException.Message;
return strMakeMessage;
}
public ManagerInfoFTP(bool bUseService, IPAddress SetIpAddress, int nSetPort, string strSetUserName, string strSetUserPassword)
{
UseInfo = new ConnectFTPInformation();
UseInfo.UseFTPService = bUseService;
UseInfo.InfoIPAddress = SetIpAddress;
UseInfo.InfoPort = nSetPort;
UseInfo.InfoUseUserAccount = strSetUserName;
UseInfo.InfoUseUserPassword = strSetUserPassword;
}
public bool FTPConnState { set; get; }
}
}

271
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.DB/ConnInfo.cs Normal file
View File

@ -0,0 +1,271 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using SystemX.Common;
using SystemX.Common.Serialization;
using static SystemX.Net.DB.XDBConnManager;
namespace SystemX.Net.DB
{
public class CMainConnInfo
{
public string Type { get; set; }
public string IP { get; set; }
public string Port { get; set; }
public string ID { get; set; }
public string PW { get; set; }
public string SCHEMA { get; set; }
public string MAC_ADDR { get; set; }
public string SSPI { get; set; }
public CMainConnInfo()
{
Type = string.Empty;
IP = string.Empty;
Port = string.Empty;
ID = string.Empty;
PW = string.Empty;
SCHEMA = string.Empty;
MAC_ADDR = string.Empty;
SSPI = string.Empty;
}
}
public class CShortTermConnInfo
{
public string Type { get; set; }
public string IP { get; set; }
public string Port { get; set; }
public string ID { get; set; }
public string PW { get; set; }
public string SCHEMA { get; set; }
public string MAC_ADDR { get; set; }
public string SSPI { get; set; }
public CShortTermConnInfo()
{
Type = string.Empty;
IP = string.Empty;
Port = string.Empty;
ID = string.Empty;
PW = string.Empty;
SCHEMA = string.Empty;
MAC_ADDR = string.Empty;
SSPI = string.Empty;
}
}
public class CLongTermConnInfo
{
public string Type { get; set; }
public string IP { get; set; }
public string Port { get; set; }
public string ID { get; set; }
public string PW { get; set; }
public string SCHEMA { get; set; }
public string MAC_ADDR { get; set; }
public string SSPI { get; set; }
public CLongTermConnInfo()
{
Type = string.Empty;
IP = string.Empty;
Port = string.Empty;
ID = string.Empty;
PW = string.Empty;
SCHEMA = string.Empty;
MAC_ADDR = string.Empty;
SSPI = string.Empty;
}
}
public class XDBConnInfo
{
public enum INFO_STRUCTURE
{
DBConnInfo,
IP,
Port,
ID,
PW,
DB_CONN,
MAC_ADDR,
SSPI
}
public CMainConnInfo ConnMain;
public CShortTermConnInfo ConnShortTerm;
public CLongTermConnInfo ConnLongTerm;
public XDBConnInfo()
{
ConnMain = new CMainConnInfo();
ConnShortTerm = new CShortTermConnInfo();
ConnLongTerm = new CLongTermConnInfo();
}
public bool ReadConfig(string strPath)
{
try
{
FileStream fs = new FileStream(strPath, FileMode.Open, FileAccess.Read);
XmlDocument xmldoc = new XmlDocument();
XmlNodeList nodeList;
Type InfoType = typeof(XDBConnInfo);
xmldoc.Load(fs);
nodeList = xmldoc.GetElementsByTagName(INFO_STRUCTURE.DBConnInfo.ToString());
XmlNode topNode = nodeList.Item(0);
foreach (XmlNode node in topNode.ChildNodes)
{
string strNodeName = node.Name;
if (strNodeName.CompareTo("MainConnInfo") == 0)
{
if (node.HasChildNodes == false)
throw new Exception("[MainConnInfo] Has no entries.");
if (node.ChildNodes.Count != 8)
throw new Exception("[MainConnInfo] Entries do not match.");
ConnMain.Type = node.ChildNodes[0].InnerText;
ConnMain.IP = node.ChildNodes[1].InnerText;
ConnMain.Port = node.ChildNodes[2].InnerText;
ConnMain.ID = node.ChildNodes[3].InnerText;
ConnMain.PW = node.ChildNodes[4].InnerText;
ConnMain.SCHEMA = node.ChildNodes[5].InnerText;
ConnMain.MAC_ADDR = node.ChildNodes[6].InnerText;
ConnMain.SSPI = node.ChildNodes[7].InnerText;
}
else if (strNodeName.CompareTo("ShortTermInfo") == 0)
{
if (node.HasChildNodes == false)
throw new Exception("[ShortTermInfo] Has no entries.");
if (node.ChildNodes.Count != 8)
throw new Exception("[ShortTermInfo] Entries do not match.");
ConnShortTerm.Type = node.ChildNodes[0].InnerText;
ConnShortTerm.IP = node.ChildNodes[1].InnerText;
ConnShortTerm.Port = node.ChildNodes[2].InnerText;
ConnShortTerm.ID = node.ChildNodes[3].InnerText;
ConnShortTerm.PW = node.ChildNodes[4].InnerText;
ConnShortTerm.SCHEMA = node.ChildNodes[5].InnerText;
ConnShortTerm.MAC_ADDR = node.ChildNodes[6].InnerText;
ConnShortTerm.SSPI = node.ChildNodes[7].InnerText;
}
else if(strNodeName.CompareTo("LongTermInfo") == 0)
{
if (node.HasChildNodes == false)
throw new Exception("[LongTermInfo] Has no entries.");
if (node.ChildNodes.Count != 8)
throw new Exception("[LongTermInfo] Entries do not match.");
ConnLongTerm.Type = node.ChildNodes[0].InnerText;
ConnLongTerm.IP = node.ChildNodes[1].InnerText;
ConnLongTerm.Port = node.ChildNodes[2].InnerText;
ConnLongTerm.ID = node.ChildNodes[3].InnerText;
ConnLongTerm.PW = node.ChildNodes[4].InnerText;
ConnLongTerm.SCHEMA = node.ChildNodes[5].InnerText;
ConnLongTerm.MAC_ADDR = node.ChildNodes[6].InnerText;
ConnLongTerm.SSPI = node.ChildNodes[7].InnerText;
}
/*
else
{
PropertyInfo propFound = InfoType.GetProperty(strNodeName);
if (propFound != null)
propFound.SetValue(this, node.InnerText);
}
*/
}
fs.Close();
}
catch (Exception ex)
{
Console.WriteLine($"DB Connection Info. Reading Error : {ex.Message}");
return false;
}
return true;
}
public string GetConnectionStatement(eDbType eType, eConnCategory eConn)
{
string strStatement = string.Empty;
bool bSSPI = true;
string IP_ADDRESS = string.Empty;
string PORT_NUMBER = string.Empty;
string CONN_SCHEMA = string.Empty;
string IDENTIFIER = string.Empty;
string PASSWORD = string.Empty;
switch (eConn)
{
case eConnCategory.Main:
{
if (ConnMain.SSPI.IndexOf("False") >= 0) bSSPI = false;
IP_ADDRESS = ConnMain.IP;
PORT_NUMBER = ConnMain.Port;
CONN_SCHEMA = ConnMain.SCHEMA;
IDENTIFIER = ConnMain.ID;
PASSWORD = ConnMain.PW;
}
break;
case eConnCategory.ShortTerm:
{
if (ConnShortTerm.SSPI.IndexOf("False") >= 0) bSSPI = false;
IP_ADDRESS = ConnShortTerm.IP;
PORT_NUMBER = ConnShortTerm.Port;
CONN_SCHEMA = ConnShortTerm.SCHEMA;
IDENTIFIER = ConnShortTerm.ID;
PASSWORD = ConnShortTerm.PW;
}
break;
case eConnCategory.LongTerm:
{
if (ConnLongTerm.SSPI.IndexOf("False") >= 0) bSSPI = false;
IP_ADDRESS = ConnLongTerm.IP;
PORT_NUMBER = ConnLongTerm.Port;
CONN_SCHEMA = ConnLongTerm.SCHEMA;
IDENTIFIER = ConnLongTerm.ID;
PASSWORD = ConnLongTerm.PW;
}
break;
}
switch (eType)
{
case eDbType.MS_SQL:
if (bSSPI == false)
strStatement = $"Data Source = {IP_ADDRESS},{PORT_NUMBER}; Initial Catalog = {CONN_SCHEMA}; User ID = {IDENTIFIER}; Password = {PASSWORD}; MultipleActiveResultSets=True;";
else
strStatement = $"Data Source = localhost; Initial Catalog = {CONN_SCHEMA}; Integrated Security = SSPI; MultipleActiveResultSets=True;";
break;
default:
break;
}
return strStatement;
}
}
}

420
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.DB/ConnManager.cs Normal file
View File

@ -0,0 +1,420 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SystemX.Net.DB.DBType;
using SystemX.Common;
using SystemX.Common.Serialization;
using System.Data;
using System.Data.SqlClient;
using static SystemX.Net.Platform.Common.Util.LogMessage;
using System.Diagnostics;
using log4net.Config;
namespace SystemX.Net.DB
{
public class XDBConnManager
{
public enum eDbType
{
Unknown,
MS_SQL
}
public enum eConnCategory
{
Main,
ShortTerm,
LongTerm
}
private Stopwatch stMainDBAccessTime;
private Stopwatch stShortTermDBAccessTime;
private Stopwatch stLongTermDBAccessTime;
private bool MAIN_CONNECT_STATE { set; get; }
private bool SHORTTERM_CONNECT_STATE { set; get; }
private bool LONGTERM_CONNECT_STATE { set; get; }
public bool CONNECT_STATE
{
get { return MAIN_CONNECT_STATE && SHORTTERM_CONNECT_STATE && LONGTERM_CONNECT_STATE; }
}
protected void SET_CONNECT_STATE(eConnCategory eConn, bool bValue)
{
switch (eConn)
{
case eConnCategory.Main:
MAIN_CONNECT_STATE = bValue;
break;
case eConnCategory.ShortTerm:
SHORTTERM_CONNECT_STATE = bValue;
break;
case eConnCategory.LongTerm:
LONGTERM_CONNECT_STATE = bValue;
break;
}
}
protected bool GET_CONNECT_STATE(eConnCategory eConn)
{
switch (eConn)
{
case eConnCategory.Main:
return MAIN_CONNECT_STATE;
case eConnCategory.ShortTerm:
return SHORTTERM_CONNECT_STATE;
case eConnCategory.LongTerm:
return LONGTERM_CONNECT_STATE;
}
return false;
}
public string ConfigPath { get; set; }
public XDBConnInfo InfoConnection { get; set; } = new XDBConnInfo();
private IDBControl MgrMainConnection { set; get; }
private IDBControl MgrShortTermConnection { set; get; }
private IDBControl MgrLongTermConnection { set; get; }
public XDBConnManager()
{
stMainDBAccessTime = new Stopwatch();
stMainDBAccessTime.Start();
stShortTermDBAccessTime = new Stopwatch();
stShortTermDBAccessTime.Start();
stLongTermDBAccessTime = new Stopwatch();
stLongTermDBAccessTime.Start();
MAIN_CONNECT_STATE = false;
SHORTTERM_CONNECT_STATE = false;
LONGTERM_CONNECT_STATE = false;
}
public long GetMainDBAccessTime()
{
if (stMainDBAccessTime != null)
return stMainDBAccessTime.ElapsedMilliseconds;
else
return long.MinValue;
}
public void SetMainDBAccessTime()
{
if (stMainDBAccessTime != null)
stMainDBAccessTime.Restart();
}
public long GetShortTermDBAccessTime()
{
if (stShortTermDBAccessTime != null)
return stShortTermDBAccessTime.ElapsedMilliseconds;
else
return long.MinValue;
}
public void SetShortTermDBAccessTime()
{
if (stShortTermDBAccessTime != null)
stShortTermDBAccessTime.Restart();
}
public long GetLongTermDBAccessTime()
{
if (stLongTermDBAccessTime != null)
return stLongTermDBAccessTime.ElapsedMilliseconds;
else
return long.MinValue;
}
public void SetLongTermDBAccessTime()
{
if (stLongTermDBAccessTime != null)
stLongTermDBAccessTime.Restart();
}
public IDBControl CurrentConnection(eConnCategory eConn)
{
if (GET_CONNECT_STATE(eConn))
{
switch (eConn)
{
case eConnCategory.Main:
{
if (stMainDBAccessTime != null)
stMainDBAccessTime.Restart();
}
return MgrMainConnection;
case eConnCategory.ShortTerm:
{
if (stShortTermDBAccessTime != null)
stShortTermDBAccessTime.Restart();
}
return MgrShortTermConnection;
case eConnCategory.LongTerm:
{
if (stLongTermDBAccessTime != null)
stLongTermDBAccessTime.Restart();
}
return MgrLongTermConnection;
}
return null;
}
else
return null;
}
private bool ReadyForConnection(eConnCategory eConn)
{
bool bResult = true;
try
{
string strSetType = string.Empty;
eDbType eType = eDbType.Unknown;
switch (eConn)
{
case eConnCategory.Main:
strSetType = InfoConnection.ConnMain.Type;
break;
case eConnCategory.ShortTerm:
strSetType = InfoConnection.ConnShortTerm.Type;
break;
case eConnCategory.LongTerm:
strSetType = InfoConnection.ConnLongTerm.Type;
break;
}
if (!Enum.TryParse(strSetType, out eType))
throw new Exception("Failed Database type check.");
switch (eConn)
{
case eConnCategory.Main:
MgrMainConnection = CreateDBConnMgr(eType);
MgrMainConnection.ConnectionText = InfoConnection.GetConnectionStatement(eType, eConn);
break;
case eConnCategory.ShortTerm:
MgrShortTermConnection = CreateDBConnMgr(eType);
MgrShortTermConnection.ConnectionText = InfoConnection.GetConnectionStatement(eType, eConn);
break;
case eConnCategory.LongTerm:
MgrLongTermConnection = CreateDBConnMgr(eType);
MgrLongTermConnection.ConnectionText = InfoConnection.GetConnectionStatement(eType, eConn);
break;
}
}
catch (Exception e)
{
bResult = false;
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"Failed make connection.[SystemX.Net.DB : XDBConnManager.MakeConnection]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
return bResult;
}
private bool MakeConnection(eConnCategory eConn)
{
bool bResult = true;
try
{
bResult = ReadyForConnection(eConn);
if(bResult)
{
switch (eConn)
{
case eConnCategory.Main:
if (!MgrMainConnection.OpenConnection())
throw new Exception("Failed [Main] IDBControl.OpenConnection()");
break;
case eConnCategory.ShortTerm:
if (!MgrShortTermConnection.OpenConnection())
throw new Exception("Failed [ShortTerm] IDBControl.OpenConnection()");
break;
case eConnCategory.LongTerm:
if (!MgrLongTermConnection.OpenConnection())
throw new Exception("Failed [LongTerm] IDBControl.OpenConnection()");
break;
}
}
}
catch (Exception e)
{
bResult = false;
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"Failed make connection.[SystemX.Net.DB : XDBConnManager.MakeConnection]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
return bResult;
}
private bool MakeConnection(eConnCategory eConn, bool bUseHostInfo, string strHostTableName, string strUserTableName)
{
bool bResult = true;
try
{
bResult = ReadyForConnection(eConn);
if (bResult)
{
switch (eConn)
{
case eConnCategory.Main:
if (!MgrMainConnection.OpenConnection(bUseHostInfo, strHostTableName, strUserTableName))
throw new Exception("Failed [Main] IDBControl.OpenConnection()");
break;
case eConnCategory.ShortTerm:
if (!MgrShortTermConnection.OpenConnection(bUseHostInfo, strHostTableName, strUserTableName))
throw new Exception("Failed [ShortTerm] IDBControl.OpenConnection()");
break;
case eConnCategory.LongTerm:
if (!MgrLongTermConnection.OpenConnection(bUseHostInfo, strHostTableName, strUserTableName))
throw new Exception("Failed [LongTerm] IDBControl.OpenConnection()");
break;
}
}
}
catch (Exception e)
{
bResult = false;
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"Failed make connection.[SystemX.Net.DB : XDBConnManager.MakeConnection]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
return bResult;
}
public bool OpenConnection(bool bReadCfgFile = true)
{
return CONNECT_STATE;
}
public bool OpenConnection(bool bUseHostInfo, string strHostTableName, string strUserTableName, bool bReadCfgFile = true)
{
SET_CONNECT_STATE(eConnCategory.Main, true);
SET_CONNECT_STATE(eConnCategory.ShortTerm, true);
SET_CONNECT_STATE(eConnCategory.LongTerm, true);
try
{
if (bReadCfgFile)
{
if (InfoConnection.ReadConfig(ConfigPath) == false)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"Fail read DB info file.[SystemX.Net.DB : XDBConnManager.OpenConnection]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
throw new Exception("Failed ReadConfig()");
}
}
SET_CONNECT_STATE(eConnCategory.Main, MakeConnection(eConnCategory.Main, bUseHostInfo, strHostTableName, strUserTableName));
SET_CONNECT_STATE(eConnCategory.ShortTerm, MakeConnection(eConnCategory.ShortTerm));
SET_CONNECT_STATE(eConnCategory.LongTerm, MakeConnection(eConnCategory.LongTerm));
if (GET_CONNECT_STATE(eConnCategory.Main) == false ||
GET_CONNECT_STATE(eConnCategory.ShortTerm) == false ||
GET_CONNECT_STATE(eConnCategory.LongTerm) == false)
throw new Exception();
}
catch (Exception e)
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"Fail db connect.[SystemX.Net.DB : XDBConnManager.OpenConnection - Parameter Type]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
return CONNECT_STATE;
}
IDBControl CreateDBConnMgr(eDbType eType)
{
switch (eType)
{
case eDbType.MS_SQL:
return new XDBTMSSQL();
default:
return null;
}
}
public SqlDataReader QueryDatabase(eConnCategory eConn, string strStmt)
{
IDBControl ctrlDB = null;
switch (eConn)
{
case eConnCategory.Main:
ctrlDB = MgrMainConnection;
break;
case eConnCategory.ShortTerm:
ctrlDB = MgrShortTermConnection;
break;
case eConnCategory.LongTerm:
ctrlDB = MgrLongTermConnection;
break;
}
SqlDataReader drResult = ctrlDB.QueryDatabase(strStmt);
return drResult;
}
public DataTable QueryDatabaseInTable(eConnCategory eConn, string strStmt)
{
IDBControl ctrlDB = null;
switch (eConn)
{
case eConnCategory.Main:
ctrlDB = MgrMainConnection;
break;
case eConnCategory.ShortTerm:
ctrlDB = MgrShortTermConnection;
break;
case eConnCategory.LongTerm:
ctrlDB = MgrLongTermConnection;
break;
}
DataTable dtResult = ctrlDB.QueryDataTable(strStmt);
return dtResult;
}
public DataSet QueryDatabaseInSet(eConnCategory eConn, string strStmt)
{
IDBControl ctrlDB = null;
switch (eConn)
{
case eConnCategory.Main:
ctrlDB = MgrMainConnection;
break;
case eConnCategory.ShortTerm:
ctrlDB = MgrShortTermConnection;
break;
case eConnCategory.LongTerm:
ctrlDB = MgrLongTermConnection;
break;
}
DataSet dsResult = ctrlDB.QueryDataSet(strStmt);
return dsResult;
}
}
}

447
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.DB/DBType/DBTMSSQL - Query.cs Normal file
View File

@ -0,0 +1,447 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SystemX.Common;
using SystemX.Common.Serialization;
using static SystemX.Net.Platform.Common.Util.LogMessage;
namespace SystemX.Net.DB.DBType
{
public partial class XDBTMSSQL : IDBControl, IDisposable
{
public bool ExecuteNonQuery(SqlCommand cmd)
{
bool bStatus = true;
int iRecordsAffected = 0;
if (cmd == null)
return false;
try
{
if (cmd.Connection == null)
cmd.Connection = dbConnection;
iRecordsAffected = cmd.ExecuteNonQuery();
}
catch (Exception e)
{
iRecordsAffected = 0;
bStatus = false;
string strErrorMsg = e.Message;
string strSetData = DateTime.Now.ToString("yyyy -MM-dd HH:mm:ss>>");
MessageOutput.ConsoleWrite(strSetData + @"! Message [" + strErrorMsg + "] ExecuteNonQuery command failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
MessageOutput.ConsoleWrite(strSetData + @"! Command [" + cmd.CommandText + "] ExecuteNonQuery command failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
}
if (iRecordsAffected > 0)
bStatus = true;
else
bStatus = false;
return bStatus;
}
public bool ExecuteNonCommandQuery(SqlCommand cmd)
{
bool bStatus = true;
int iRecordsAffected = 0;
if (cmd == null)
return false;
try
{
if (cmd.Connection == null)
cmd.Connection = dbConnection;
iRecordsAffected = cmd.ExecuteNonQuery();
}
catch (Exception e)
{
string strErrorMsg = e.Message;
iRecordsAffected = 0;
bStatus = false;
string strSetData = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>");
MessageOutput.ConsoleWrite(strSetData + @"! Message [" + strErrorMsg + "] ExecuteNonQuery command failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
MessageOutput.ConsoleWrite(strSetData + @"! Command [" + cmd.CommandText + "] ExecuteNonQuery command failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
}
if (iRecordsAffected > 0)
bStatus = true;
else
bStatus = false;
return bStatus;
}
public bool ExecuteNonStreamQuery(SqlCommand cmd)
{
bool bStatus = true;
int iRecordsAffected = 0;
if (cmd == null)
return false;
try
{
if (cmd.Connection == null)
cmd.Connection = dbConnection;
iRecordsAffected = cmd.ExecuteNonQuery();
}
catch (Exception e)
{
string strErrorMsg = e.Message;
iRecordsAffected = 0;
bStatus = false;
string strSetData = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>");
MessageOutput.ConsoleWrite(strSetData + @"! Message [" + strErrorMsg + "] ExecuteNonQuery command failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
MessageOutput.ConsoleWrite(strSetData + @"! Command [" + cmd.CommandText + "] ExecuteNonQuery command failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
}
if (iRecordsAffected > 0)
bStatus = true;
else
bStatus = false;
return bStatus;
}
public SqlDataReader QueryDatabase(string strSQL)
{
bool bHasRow = false;
int nCnt = 0;
SqlDataReader QueryReader = null;
try
{
using (var dbExcuteCommand = new SqlCommand(strSQL, dbConnection))
{
QueryReader = dbExcuteCommand.ExecuteReader();
}
}
catch (Exception e)
{
if (QueryReader != null)
QueryReader.Close();
QueryReader = null;
string strErrorMsg = e.Message;
string strSetData = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>");
MessageOutput.ConsoleWrite(strSetData + @"! Message [" + strErrorMsg + "] QueryDatabase failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
MessageOutput.ConsoleWrite(strSetData + @"! Command [" + strSQL + "] QueryDatabase failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
}
finally
{
if (QueryReader != null)
{
bHasRow = QueryReader.HasRows;
nCnt = QueryReader.RecordsAffected;
}
}
return QueryReader;
}
public SqlDataReader QueryDatabaseSub(string strSQL)
{
bool bHasRow = false;
int nCnt = 0;
SqlDataReader QueryReader = null;
try
{
using (var dbExcuteCommand = new SqlCommand(strSQL, dbConnection))
{
QueryReader = dbExcuteCommand.ExecuteReader();
}
}
catch (Exception e)
{
if (QueryReader != null)
QueryReader.Close();
QueryReader = null;
string strErrorMsg = e.Message;
string strSetData = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>");
MessageOutput.ConsoleWrite(strSetData + @"! Message [" + strErrorMsg + "] QueryDatabaseSub failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
MessageOutput.ConsoleWrite(strSetData + @"! Command [" + strSQL + "] QueryDatabaseSub failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
}
finally
{
if (QueryReader != null)
{
bHasRow = QueryReader.HasRows;
nCnt = QueryReader.RecordsAffected;
}
}
return QueryReader;
}
public SqlDataReader QueryStreamDatabase(string strSQL)
{
bool bHasRow = false;
int nCnt = 0;
SqlDataReader QueryReader = null;
try
{
using (var dbExcuteCommand = new SqlCommand(strSQL, dbConnection))
{
QueryReader = dbExcuteCommand.ExecuteReader();
}
}
catch (Exception e)
{
if (QueryReader != null)
QueryReader.Close();
QueryReader = null;
string strErrorMsg = e.Message;
string strSetData = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>");
MessageOutput.ConsoleWrite(strSetData + @"! Message [" + strErrorMsg + "] QueryStreamDatabase failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
MessageOutput.ConsoleWrite(strSetData + @"! Command [" + strSQL + "] QueryStreamDatabase failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
}
finally
{
if (QueryReader != null)
{
bHasRow = QueryReader.HasRows;
nCnt = QueryReader.RecordsAffected;
}
}
return QueryReader;
}
public SqlDataReader QueryCommandDatabase(string strSQL, bool bUseTransaction = false)
{
bool bHasRow = false;
int nCnt = 0;
SqlDataReader QueryReader = null;
try
{
if (bUseTransaction)
{
// Start a local transaction.
SqlTransaction sqlTran = dbConnection.BeginTransaction();
// Enlist a command in the current transaction.
SqlCommand command = dbConnection.CreateCommand();
command.Transaction = sqlTran;
try
{
// Execute two separate commands.
command.CommandText = strSQL;
QueryReader = command.ExecuteReader();
// Commit the transaction.
sqlTran.Commit();
}
catch (Exception ex)
{
// Handle the exception if the transaction fails to commit.
string strErrorMsg = ex.Message;
string strSetData = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>");
MessageOutput.ConsoleWrite(strSetData + @"! Message [" + strErrorMsg + "] QueryCommandDatabase Transaction failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
MessageOutput.ConsoleWrite(strSetData + @"! Command [" + strSQL + "] QueryCommandDatabase Transaction failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
try
{
// Attempt to roll back the transaction.
sqlTran.Rollback();
}
catch (Exception exRollback)
{
// Throws an InvalidOperationException if the connection
// is closed or the transaction has already been rolled
// back on the server.
strErrorMsg = exRollback.Message;
strSetData = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>");
MessageOutput.ConsoleWrite(strSetData + @"! Message [" + strErrorMsg + "] QueryCommandDatabase Transaction-Rollback failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
}
}
}
else
{
using (var dbExcuteCommand = new SqlCommand(strSQL, dbConnection))
{
QueryReader = dbExcuteCommand.ExecuteReader();
}
}
}
catch (Exception e)
{
if (QueryReader != null)
QueryReader.Close();
QueryReader = null;
string strErrorMsg = e.Message;
string strSetData = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>");
MessageOutput.ConsoleWrite(strSetData + @"! Message [" + strErrorMsg + "] QueryCommandDatabase failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
MessageOutput.ConsoleWrite(strSetData + @"! Command [" + strSQL + "] QueryCommandDatabase failed. [SystemX.Net.DB.DBType : XDBTMSSQL.ExecuteNonQuery]", ConsoleColor.Red, LogMessageLevel.DEBUG);
}
finally
{
if (QueryReader != null)
{
bHasRow = QueryReader.HasRows;
nCnt = QueryReader.RecordsAffected;
}
}
return QueryReader;
}
public DataTable QueryDataTable(string strSQL)
{
SqlDataReader Sqldr = null;
try
{
Sqldr = QueryDatabase(strSQL);
queryDataTable = new DataTable();
queryDataTable.Load(Sqldr);
}
catch(Exception e)
{
;//
}
finally
{
if (Sqldr != null)
Sqldr.Close();
}
return queryDataTable;
//return null;
}
public DataTable QueryDataTable(string strSQL, out bool bHasRows)
{
bHasRows = false;
return null;
}
public DataTable QueryDataTable(string strSQL, out int iRecordsAffected)
{
iRecordsAffected = 0;
return null;
}
public DataTable QueryDataTable(string strSQL, out bool bHasRows, out int iRecordsAffected)
{
bHasRows = false;
iRecordsAffected = 0;
return null;
}
public DataSet QueryDataSet(string strSQL)
{
SqlDataReader Sqldr = null;
try
{
Sqldr = QueryDatabase(strSQL);
queryDataTable = new DataTable();
queryDataTable.Load(Sqldr);
queryDataSet = new DataSet();
queryDataSet.Tables.Add(queryDataTable);
}
catch (Exception e)
{
;//
}
finally
{
if (Sqldr != null)
Sqldr.Close();
}
return queryDataSet;
}
public DataSet QueryDataSet(string strSQL, out bool bHasRows)
{
bHasRows = false;
return null;
}
public DataSet QueryDataSet(string strSQL, out int iRecordsAffected)
{
iRecordsAffected = 0;
return null;
}
public DataSet QueryDataSet(string strSQL, out bool bHasRows, out int iRecordsAffected)
{
bHasRows = false;
iRecordsAffected = 0;
return null;
}
/*
public DataSet Query(string strSetCommand, out int iRecordsAffect)
{
iRecordsAffect = 0;
queryDataSet = null;
try
{
dbCommand.CommandText = strSetCommand;
queryDataReader = dbCommand.ExecuteReader();
queryDataTable = new DataTable();
queryDataTable.Load(queryDataReader);
queryDataSet = new DataSet();
queryDataSet.Tables.Add(queryDataTable);
}
catch (Exception e)
{
//throw new CommonQueryException("Execution failed for the statement.[SystemX.Net.DB : MSSQL|COMMON.Query]");
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"General packet marshalling failed.[SystemX.Common : COMMON.GetHeaderProtocol]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
return queryDataSet;
}
*/
}
}

468
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.DB/DBType/DBTMSSQL.cs Normal file
View File

@ -0,0 +1,468 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SystemX.Common;
using SystemX.Common.Serialization;
using static SystemX.Net.Platform.Common.Util.LogMessage;
namespace SystemX.Net.DB.DBType
{
public partial class XDBTMSSQL : IDBControl, IDisposable
{
private SqlConnection dbConnection;
private SqlCommand dbCommand;
private SqlDataReader queryDataReader;
private DataSet queryDataSet;
private DataTable queryDataTable;
private byte[] ucCollectSerializationSchema;
private XTableInfo XSchemaTables;
private DataTable HostList;
private DataTable UserList;
public string ConnectionText { get; set; }
public bool IsConnected { get; set; }
private string strSetHostTableName;
private string strSetUserTableName;
public byte[] GetCollectSerializationSchemaInfo()
{
return ucCollectSerializationSchema;
}
public XTableInfo GetCollectSchemaInfo()
{
return XSchemaTables;
}
public DataTable GetHostList(bool bDBQueryCheck = false)
{
if(bDBQueryCheck == false)
return HostList;
else
{
if (QueryHostList(strSetHostTableName))
return HostList;
else
return null;
}
}
public DataTable GetUserList(bool bDBQueryCheck = false)
{
if (bDBQueryCheck == false)
return UserList;
else
{
if (QueryUserList(strSetUserTableName))
return UserList;
else
return null;
}
}
public XDBTMSSQL()
{
HostList = null;
}
~XDBTMSSQL()
{
Dispose(false);
}
public void Dispose()
{
Dispose(true);
}
protected virtual void Dispose(bool bDisposing)
{
if (bDisposing)
ChkCloseConnect();
// do releasing unmanaged resource (종결자가 없는 객체의 자원 해제)
// i.e. close file handle of operating systems
// suppress calling of Finalizer
GC.SuppressFinalize(this);
}
public bool InitConnection()
{
try
{
ChkCloseConnect();
dbConnection = null;
dbCommand = null;
queryDataReader = null;
queryDataSet = null;
queryDataTable = null;
IsConnected = false;
}
catch (Exception ex)
{
Console.WriteLine($"SystemX Database Initialization is Failed. Error: {ex.Message}");
return false;
}
return true;
}
public void ChkCloseConnect()
{
if (IsConnected)
{
if (dbConnection != null)
{
dbConnection.Close();
dbConnection.Dispose();
dbConnection = null;
}
IsConnected = false;
}
}
public bool OpenConnection()
{
ChkCloseConnect();
try
{
dbCommand = new SqlCommand();
dbConnection = new SqlConnection(ConnectionText);
dbConnection.Open();
dbCommand.Connection = dbConnection;
if (CollectSchemaInfomation())
IsConnected = true;
else
Console.WriteLine($"SystemX Database CollectSchemaInfomation() is Failed.");
}
catch (SqlException exsql)
{
Console.WriteLine($"SystemX Database Connection Open is Failed. Error: {exsql.Message}");
IsConnected = false;
}
catch (Exception ex)
{
Console.WriteLine($"SystemX Database Connection Open is Failed. Error: {ex.Message}");
IsConnected = false;
}
return IsConnected;
}
public bool OpenConnection(bool bUseHostInfo, string strHostTableName, string strUserTableName)
{
ChkCloseConnect();
strSetHostTableName = string.Empty;
strSetUserTableName = string.Empty;
try
{
dbCommand = new SqlCommand();
dbConnection = new SqlConnection(ConnectionText);
dbConnection.Open();
dbCommand.Connection = dbConnection;
if (CollectSchemaInfomation())
{
if (bUseHostInfo)
{
strSetHostTableName = strHostTableName;
strSetUserTableName = strUserTableName;
if (QueryHostList(strSetHostTableName) &&
QueryUserList(strSetUserTableName))
IsConnected = true;
else
Console.WriteLine($"SystemX Database QueryHostList() is Failed.");
}
else
IsConnected = true;
}
else
Console.WriteLine($"SystemX Database CollectSchemaInfomation() is Failed.");
}
catch (SqlException exsql)
{
Console.WriteLine($"SystemX Database Connection Open is Failed. Error: {exsql.Message}");
IsConnected = false;
}
catch (Exception ex)
{
Console.WriteLine($"SystemX Database Connection Open is Failed. Error: {ex.Message}");
IsConnected = false;
}
return IsConnected;
}
public bool CloseConnection()
{
try
{
ChkCloseConnect();
}
catch (SqlException exsql)
{
Console.WriteLine($"SystemX Database Connection Open is Failed. Error: {exsql.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"SystemX Database Connection Open is Failed. Error: {ex.Message}");
throw;
}
return true;
}
public SqlConnection getConnection()
{
return dbConnection;
}
public string MakeTableInfoQuery(string strTableName)
{
//--컬럼 정보 가져오기
string strTableColInfoCommand = "SELECT A.TABLE_CATALOG" +
",A.TABLE_NAME" +
",A.ORDINAL_POSITION" +
",A.COLUMN_NAME" +
",A.DATA_TYPE" +
",ISNULL(A.CHARACTER_MAXIMUM_LENGTH, '') CHARACTER_LENGTH" +
",ISNULL(A.NUMERIC_PRECISION, '') NUMBERIC_LENGTH" +
",A.IS_NULLABLE" +
",ISNULL(A.COLUMN_DEFAULT, '')" +
",ISNULL(B.CONSTRAINT_NAME, '')" +
",ISNULL(A.CHARACTER_SET_NAME, '')" +
",ISNULL(A.COLLATION_NAME, '')" +
",CASE WHEN ISNULL(C.NAME, '') = '' THEN '' ELSE 'Identity' END AUTO" +
" FROM INFORMATION_SCHEMA.COLUMNS A LEFT OUTER JOIN" +
" INFORMATION_SCHEMA.KEY_COLUMN_USAGE B" +
" ON A.TABLE_NAME = B.TABLE_NAME" +
" AND A.COLUMN_NAME = B.COLUMN_NAME" +
" LEFT OUTER JOIN" +
" syscolumns C" +
" ON C.ID = object_id(A.TABLE_NAME) AND A.COLUMN_NAME = C.NAME AND C.COLSTAT & 1 = 1 WHERE A.TABLE_NAME = " +
"'" + strTableName + "'" +
" ORDER BY A.ORDINAL_POSITION";
return strTableColInfoCommand;
}
public bool CollectSchemaInfomation()
{
bool bInfoCollectResult = true;
try
{
dbCommand.CommandText = "SELECT * FROM INFORMATION_SCHEMA.TABLES A ORDER BY A.TABLE_NAME;";
queryDataReader = dbCommand.ExecuteReader();
DataTable dtQueryTable = new DataTable();
dtQueryTable.Load(queryDataReader);
List<string> listTableInfo = new List<string>();
if (dtQueryTable.Columns.Contains("TABLE_NAME"))
{
int iColPos = dtQueryTable.Columns.IndexOf("TABLE_NAME");
for (int i = 0; i < dtQueryTable.Columns[0].Table.Rows.Count; i++)
{
object[] objRows = dtQueryTable.Columns[0].Table.Rows[i].ItemArray;
string strGetTableName = objRows[iColPos] as string;
if (strGetTableName.IndexOf("sysdiagrams") < 0)
listTableInfo.Add(objRows[iColPos] as string);
}
}
int iNamePos = 0, iTypePos = 0, iCharLengPos = 0, iNumLengPos = 0, iIsNullAblePos = 0, iAutoPos = 0;
int iPosition = 0;
XTable[] listTable = new XTable[listTableInfo.Count];
foreach (string strTbName in listTableInfo)
{
dbCommand.CommandText = MakeTableInfoQuery(strTbName);
queryDataReader = dbCommand.ExecuteReader();
dtQueryTable = new DataTable();
dtQueryTable.Load(queryDataReader);
if (dtQueryTable.Columns.Contains("COLUMN_NAME"))
iNamePos = dtQueryTable.Columns.IndexOf("COLUMN_NAME");
if (dtQueryTable.Columns.Contains("DATA_TYPE"))
iTypePos = dtQueryTable.Columns.IndexOf("DATA_TYPE");
if (dtQueryTable.Columns.Contains("CHARACTER_LENGTH"))
iCharLengPos = dtQueryTable.Columns.IndexOf("CHARACTER_LENGTH");
if (dtQueryTable.Columns.Contains("NUMBERIC_LENGTH"))
iNumLengPos = dtQueryTable.Columns.IndexOf("NUMBERIC_LENGTH");
if (dtQueryTable.Columns.Contains("IS_NULLABLE"))
iIsNullAblePos = dtQueryTable.Columns.IndexOf("IS_NULLABLE");
if (dtQueryTable.Columns.Contains("AUTO"))
iAutoPos = dtQueryTable.Columns.IndexOf("AUTO");
listTable[iPosition] = new XTable(strTbName);
for (int i = 0; i < dtQueryTable.Rows[0].Table.Rows.Count; i++)
{
object[] objRows = dtQueryTable.Columns[0].Table.Rows[i].ItemArray;
string strGetName = objRows[iNamePos] as string;
string strGetTypeName = objRows[iTypePos] as string;
int iGetTypeCharLeng = Convert.ToInt32(objRows[iCharLengPos]);
int iGetTypeNumLeng = Convert.ToInt32(objRows[iNumLengPos]);
string strGetNullState = objRows[iIsNullAblePos] as string;
string strGetAuto = objRows[iAutoPos] as string;
bool bGetIsNullAble = false;
if (strGetNullState.IndexOf("YES") >= 0)
bGetIsNullAble = true;
else if (strGetNullState.IndexOf("NO") >= 0)
bGetIsNullAble = false;
Type SetThisType = null;
switch (strGetTypeName)
{
case "bit":
//SET_CODE = TypeCode.Boolean;
SetThisType = typeof(Boolean);
break;
case "tinyint":
//SET_CODE = TypeCode.Int64;
SetThisType = typeof(Byte);
break;
case "int":
//SET_CODE = TypeCode.Int32;
SetThisType = typeof(Int32);
break;
case "bigint":
//SET_CODE = TypeCode.Int64;
SetThisType = typeof(Int64);
break;
case "float":
//SET_CODE = TypeCode.Double;
SetThisType = typeof(Double);
break;
case "nvarchar":
//SET_CODE = TypeCode.String;
SetThisType = typeof(String);
break;
case "nchar":
//SET_CODE = TypeCode.String;
SetThisType = typeof(String);
break;
case "datetime":
//SET_CODE = TypeCode.DateTime;
SetThisType = typeof(DateTime);
break;
}
listTable[iPosition].XTableAdd(i, strGetName, SetThisType, iGetTypeCharLeng, bGetIsNullAble);
}
iPosition++;
}
XSchemaTables = new XTableInfo(listTable);
ucCollectSerializationSchema = SystemXNetSerialization.ObjectToByteArray(XSchemaTables);
XTableInfo XTablesReturn = (XTableInfo)SystemXNetSerialization.ByteArrayToObject(ucCollectSerializationSchema);
}
catch (Exception e)
{
bInfoCollectResult = false;
//throw new Exception("Collect Schema infomation fail!");
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"Collect Schema infomation fail![SystemX.Net.DB.DBType : XDBTMSSQL.CollectSchemaInfomation]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
finally
{
if (queryDataReader != null)
queryDataReader.Close();
}
return bInfoCollectResult;
}
public bool QueryHostList(string strTableName)
{
bool bReuslt = true;
try
{
dbCommand.CommandText = "SELECT * FROM " + $"{strTableName} WITH(NOLOCK) ORDER BY NO ASC;";
queryDataReader = dbCommand.ExecuteReader();
HostList = new DataTable();
HostList.Load(queryDataReader);
}
catch(Exception e)
{
HostList = null;
bReuslt = false;
}
finally
{
if (queryDataReader != null)
queryDataReader.Close();
}
return bReuslt;
}
public bool QueryUserList(string strTableName)
{
bool bReuslt = true;
try
{
dbCommand.CommandText = "SELECT * FROM " + $"{strTableName} WITH(NOLOCK) ORDER BY NO ASC;";
queryDataReader = dbCommand.ExecuteReader();
UserList = new DataTable();
UserList.Load(queryDataReader);
}
catch (Exception e)
{
UserList = null;
bReuslt = false;
}
finally
{
if (queryDataReader != null)
queryDataReader.Close();
}
return bReuslt;
}
}
}

51
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.DB/DBType/IDBControl.cs Normal file
View File

@ -0,0 +1,51 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.Net.DB.DBType
{
public interface IDBControl
{
string ConnectionText { get; set; }
bool IsConnected { get; set; }
bool InitConnection();
bool OpenConnection();
bool OpenConnection(bool bUseHostInfo, string strHostTableName, string strUserTableName);
bool CloseConnection();
SqlConnection getConnection();
string MakeTableInfoQuery(string strTableName);
bool CollectSchemaInfomation();
byte[] GetCollectSerializationSchemaInfo();
XTableInfo GetCollectSchemaInfo();
DataTable GetHostList(bool bDBQueryCheck = false);
DataTable GetUserList(bool bDBQueryCheck = false);
bool ExecuteNonQuery(SqlCommand cmd);
bool ExecuteNonCommandQuery(SqlCommand cmd);
bool ExecuteNonStreamQuery(SqlCommand cmd);
SqlDataReader QueryDatabase(string strSQL);
SqlDataReader QueryDatabaseSub(string strSQL);
SqlDataReader QueryCommandDatabase(string strSQL, bool bUseTransaction = false);
SqlDataReader QueryStreamDatabase(string strSQL);
DataTable QueryDataTable(string strSQL);
DataTable QueryDataTable(string strSQL, out bool bHasRows);
DataTable QueryDataTable(string strSQL, out int iRecordsAffected);
DataTable QueryDataTable(string strSQL, out bool bHasRows, out int iRecordsAffected);
DataSet QueryDataSet(string strSQL);
DataSet QueryDataSet(string strSQL, out bool bHasRows);
DataSet QueryDataSet(string strSQL, out int iRecordsAffected);
DataSet QueryDataSet(string strSQL, out bool bHasRows, out int iRecordsAffected);
}
}

112
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.DB/DBType/MariaDB.cs Normal file
View File

@ -0,0 +1,112 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static SystemX.Net.Platform.Common.Util.LogMessage;
//using MySql.Data.MySqlClient;
namespace SystemX.Net.DB.DBType
{
public class MariaXDB
{
//private MySqlConnection sqlConnection;
//private MySqlCommand sqlCommand;
//private MySqlDataReader sqlDataReader;
private DataSet sqlDataSet;
private DataTable sqlDataTable;
private string m_strConnectionText;
private bool m_bConnect;
public bool CONNECT { get { return m_bConnect; } }
public MariaXDB(string strSetConnectionInfo)
{
//sqlConnection = null;
//sqlCommand = null;
//sqlDataReader = null;
sqlDataSet = null;
sqlDataTable = null;
m_strConnectionText = strSetConnectionInfo;
m_bConnect = false;
}
~MariaXDB()
{
ChkCloseConnect();
}
public void ChkCloseConnect()
{
if (m_bConnect)
{
m_bConnect = false;
/*
if (sqlConnection != null)
{
sqlConnection.Close();
sqlConnection.Dispose();
sqlConnection = null;
}
*/
}
}
public bool ConnectDatabase()
{
ChkCloseConnect();
try
{
//sqlConnection = new MySqlConnection(m_strConnectionText);
//sqlCommand.Connection = sqlConnection;
m_bConnect = true;
}
catch (Exception e)
{
m_bConnect = false;
string strErrorMsg = e.Message;
string strSetData = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>");
MessageOutput.ConsoleWrite(strSetData + @"! Message [" + strErrorMsg + "] ConnectDatabase failed. [SystemX.Net.DB.DBType : MariaXDB.ConnectDatabase]", ConsoleColor.Red, LogMessageLevel.DEBUG);
}
return m_bConnect;
}
public DataSet Query(string strSetCommand, out int iRecordsAffect)
{
iRecordsAffect = 0;
sqlDataSet = null;
try
{
//sqlCommand.CommandText = strSetCommand;
//sqlDataReader = sqlCommand.ExecuteReader();
//iRecordsAffect = sqlDataReader.RecordsAffected;
sqlDataTable = new DataTable();
//sqlDataTable.Load(sqlDataReader);
sqlDataSet = new DataSet();
sqlDataSet.Tables.Add(sqlDataTable);
}
catch (Exception e)
{
;// throw new XDBCommonQueryException("Execution failed for the statement.[SystemX.Net.DB : MariaDB|COMMON.Query]");
string strErrorMsg = e.Message;
string strSetData = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>");
MessageOutput.ConsoleWrite(strSetData + @"! Message [" + strErrorMsg + "] Query failed. [SystemX.Net.DB.DBType : MariaXDB.Query]", ConsoleColor.Red, LogMessageLevel.DEBUG);
MessageOutput.ConsoleWrite(strSetData + @"! Command [" + strSetCommand + "] Query failed. [SystemX.Net.DB.DBType : MariaXDB.Query]", ConsoleColor.Red, LogMessageLevel.DEBUG);
}
return sqlDataSet;
}
}
}

1049
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.Schedule/PacketFlowControl.cs Normal file
View File

File diff suppressed because it is too large Load Diff

225
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net.Schedule/Schedule.cs Normal file
View File

@ -0,0 +1,225 @@
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using SystemX.Common;
using SystemX.Common.Archive;
using SystemX.Common.Serialization;
using SystemX.Net.BaseProtocol;
namespace SystemX.Net.Schedule
{
public class ScheduleLabelManage
{
private byte ucLabelSize = 128;
// 해당 위치 토큰 사용 여부
private bool[] bLabelUse;
// 해당 위치 처리 여부
private bool[] bLabelComplete;
private XData[] XLabelData;
public byte GetLabelSize()
{
return ucLabelSize;
}
public void SetManageLabel()
{
bLabelUse = new bool[ucLabelSize];
bLabelComplete = new bool[ucLabelSize];
XLabelData = new XData[ucLabelSize];
bLabelUse.ToArray().Initialize();
bLabelComplete.ToArray().Initialize();
}
public byte GetLabel(int nLabelPos = -1)
{
byte ucLabelPos = 0;
if (nLabelPos == -1)
{
for (int i = 1; i < ucLabelSize - 1; i++)
{
if (bLabelUse[i] == false)
{
ucLabelPos = (byte)i;
break;
}
}
}
else
ucLabelPos = (byte)nLabelPos;
if (ucLabelPos != 0)
{
bLabelComplete[ucLabelPos] = false;
bLabelUse[ucLabelPos] = true;
}
return ucLabelPos;
}
public bool SetLabel(byte ucCheckLabelPos, XData setXLabelData)
{
if (ucCheckLabelPos < 0 || ucCheckLabelPos >= ucLabelSize)
return false;
if (bLabelUse[ucCheckLabelPos])
{
XLabelData[ucCheckLabelPos] = setXLabelData;
bLabelComplete[ucCheckLabelPos] = true;
}
return bLabelComplete[ucCheckLabelPos];
}
public bool ClearLabel(byte ucCheckLabelPos)
{
if (ucCheckLabelPos < 0 || ucCheckLabelPos >= ucLabelSize)
return false;
if (bLabelUse[ucCheckLabelPos])
{
bLabelUse[ucCheckLabelPos] = false;
bLabelComplete[ucCheckLabelPos] = false;
}
return bLabelUse[ucCheckLabelPos];
}
public XData CheckLabel(byte ucCheckLabelPos, ref bool bLabelProcessResult)
{
if (ucCheckLabelPos < 0 || ucCheckLabelPos >= ucLabelSize)
return null;
if (bLabelComplete[ucCheckLabelPos])
{
bLabelComplete[ucCheckLabelPos] = false;
bLabelUse[ucCheckLabelPos] = false;
bLabelProcessResult = true;
return XLabelData[ucCheckLabelPos];
}
else
{
bLabelProcessResult = false;
return null;
}
}
}
/// <summary>
/// Packet Time, Retrty Num, Replay Packet, Packet Data, Packet Event, Label
/// </summary>
/// <summary>
/// Data Time, Data Replay Result, Packet Protocol Info, Packet Header Info, Result Data Object, Label
/// </summary>
public class XPacket
{
public DateTime dtPacketTime;
public int iRetryNum;
public bool bReplayPacket;
public byte[] ucPacketBytes;
public SendRecvCallEvent deleCallEvt;
public byte nLabel;
}
public class XData
{
public DateTime dtTime;
public bool bReplayResult;
public BASE_PROTOCOL BaseProtocol;
public HEADER_PACKET HeaderPacket;
public object objData;
public byte nLabel;
}
public enum FlowControlType
{
Commnad = 0,
Stream,
}
[Serializable]
public class XDataSchedule
{
public List<byte[]> SendQueue;
public List<byte[]> ReplySendQueue;
public List<byte[]> SendRawSetQueue;
public List<byte[]> RecvQueue;
public XDataSchedule()
{
SendQueue = new List<byte[]>();
ReplySendQueue = new List<byte[]>();
SendRawSetQueue = new List<byte[]>();
RecvQueue = new List<byte[]>();
}
}
[Serializable]
public class XSchedule
{
public ConcurrentQueue<XPacket> SendQueue { get; }
public ConcurrentQueue<XPacket> ReplySendQueue { get; }
public ConcurrentQueue<XPacket> SendRawSetQueue { get; }
public ConcurrentQueue<XPacket> RecvQueue { get; }
//
public ConcurrentQueue<XData> RecvResultData { get; }
public XSchedule()
{
SendQueue = new ConcurrentQueue<XPacket>();
ReplySendQueue = new ConcurrentQueue<XPacket>();
SendRawSetQueue = new ConcurrentQueue<XPacket>();
RecvQueue = new ConcurrentQueue<XPacket>();
RecvResultData = new ConcurrentQueue<XData>();
}
}
public class EventAwaiter<TEventArgs>
{
private readonly TaskCompletionSource<TEventArgs> _eventArrived = new TaskCompletionSource<TEventArgs>();
private readonly Action<EventHandler<TEventArgs>> _unsubscribe;
public EventAwaiter(Action<EventHandler<TEventArgs>> subscribe, Action<EventHandler<TEventArgs>> unsubscribe)
{
subscribe(Subscription);
_unsubscribe = unsubscribe;
}
public Task<TEventArgs> Task => _eventArrived.Task;
private EventHandler<TEventArgs> Subscription => (s, e) =>
{
_eventArrived.TrySetResult(e);
_unsubscribe(Subscription);
};
/*
var valueChangedEventAwaiter = new EventAwaiter<YourEventArgs>(
h => example.YourEvent += h,
h => example.YourEvent -= h);
await valueChangedEventAwaiter.Task;
*/
}
}

155
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net/Base.cs Normal file
View File

@ -0,0 +1,155 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace SystemX.Net
{
public static class Base
{
public static bool CheckPath(string strPath)
{
Regex r = new Regex(@"^(([a-zA-Z]\:)|(\\))(\\{1}|((\\{1})[^\\]([^/:*?<>""|]*))+)$");
return r.IsMatch(strPath);
}
}
//Table Info(Serializatiopn) object.
[Serializable]
public class XTable
{
public string tableName;
public List<int> lstIndex;
public List<string> lstName;
public List<Type> lstType;
public List<int> lstCharSize;
public List<bool> lstNullAble;
public XTable(string fName)
{
this.tableName = fName;
lstIndex = new List<int>();
lstName = new List<string>();
lstType = new List<Type>();
lstCharSize = new List<int>();
lstNullAble = new List<bool>();
}
public void XTableAdd(int iIndex, string strName, Type SetType, int iCharSize, bool bNullable)
{
lstIndex.Add(iIndex);
lstName.Add(strName);
lstType.Add(SetType);
lstCharSize.Add(iCharSize);
lstNullAble.Add(bNullable);
}
}
public enum eLogDataType
{
None = -1,
//CpLog
Normal = 0,
//Leak
CSV_Type0 = 1,
//Laser Trimming Vision
CSV_Type1 = 2,
//Pin Vision
CSV_Type2 = 3
}
public enum eLogAccessType
{
None = -1,
//File
FileData = 0,
//VarBinary
VarBinaryData = 1,
}
// implements IEnumerable so that it can be used
[Serializable]
public class XTableInfo : IEnumerable
{
public XTable[] _table;
public XTableInfo(XTable[] pArrayTable)
{
_table = new XTable[pArrayTable.Length];
for (int i = 0; i < pArrayTable.Length; i++)
{
_table[i] = pArrayTable[i];
}
}
// Implementation for the GetEnumerator method.
IEnumerator IEnumerable.GetEnumerator()
{
return (IEnumerator)GetEnumerator();
}
public TableEnum GetEnumerator()
{
return new TableEnum(_table);
}
}
//implement IEnumerable, implement IEnumerator.
[Serializable]
public class TableEnum : IEnumerator
{
public XTable[] _table;
// Enumerators are positioned before the first element
// until the first MoveNext() call.
int position = -1;
public TableEnum(XTable[] list)
{
_table = list;
}
public bool MoveNext()
{
position++;
return (position < _table.Length);
}
public void Reset()
{
position = -1;
}
object IEnumerator.Current
{
get
{
return Current;
}
}
public XTable Current
{
get
{
try
{
return _table[position];
}
catch (IndexOutOfRangeException)
{
throw new InvalidOperationException();
}
}
}
}
}

12
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net/BaseContainer.cs Normal file
View File

@ -0,0 +1,12 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SystemX.Common;
using SystemX.Net.BaseProtocol;
namespace SystemX.Net
{
}

551
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net/Info.cs Normal file
View File

@ -0,0 +1,551 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Xml.Linq;
using SystemX.Net.BaseProtocol;
namespace SystemX.Net
{
/// <summary>
/// Num, Command Port, Stream Port, Use, ProcessCode, TestID, ProcessName, PLCCOnfilgFileName, PLCUseType
/// </summary>
//using PLC_DEVICE_BASE_CONFIG = Tuple<int, int, int, bool, int, string, string, Tuple<string, string>>;
using static SystemX.Net.Platform.Common.Util.LogMessage;
/// <summary>
///
/// </summary>
public class PLCDeviceBaseConfig {
public int nNum;
public int nCommandPort;
public int nStreamPort;
public bool bUse;
public int nProcessCode;
public string strTestID;
public string strProcessName;
public string strPLCCOnfilgFileName;
public string strPLCUseType;
}
public class ServerInfo {
public bool READ_INFO_STATE { set; get; }
private string strInfoFilePos;
private int MAX_PROCESS_NUM;
public string SERVER_IP;
public bool LOOP_BACK;
public string TITLE;
public int[] nListenCommandPort;
public int[] nListenStreamPort;
public int nListenCommandPortNum;
public int nListenCommandStartPort;
public int nListenCommandEndPort;
public int nListenStreamPortNum;
public int nListenStreamStartPort;
public int nListenStreamEndPort;
public int nDistributionCommandPortNum;
public int nDistributionCommandStartPort;
public int nDistributionCommandEndPort;
public int nDistributionStreamPortNum;
public int nDistributionStreamStartPort;
public int nDistributionStreamEndPort;
public bool USE_HOST_INFO;
public string HOST_TABLE_NAME;
public string USER_TABLE_NAME;
public string DISK_MONITOR_POS1;
public string DISK_MONITOR_POS2;
public string SERVER_SAVE_POS;
public string MES_SAVE_POS;
public string SyncTimeServerAddress;
public int SyncTimeServerPort;
public int TimeServerSyncTimeHour;
public int TimeServerSyncTimeMinute;
public int TimeServerSyncTimeSecond;
public ServerInfo(string strGetInfoPath, int iMaxProcessNum)
{
strInfoFilePos = strGetInfoPath;
MAX_PROCESS_NUM = iMaxProcessNum;
}
public bool Load()
{
READ_INFO_STATE = true;
try
{
XDocument xDoc = XDocument.Load(strInfoFilePos);
var xElement = xDoc.Element("ROOT");
int iPort = 0;
if (xElement != null)
{
var xGetElement = xElement.Element("Configure");
SERVER_IP = xGetElement.Element("UseIP").Value;
iPort = Convert.ToInt32((xGetElement.Element("Port").Value.IndexOf("-") >= 0) ? "0" : xGetElement.Element("Port").Value);
LOOP_BACK = Convert.ToBoolean(xGetElement.Element("Loopback").Value);
TITLE = xGetElement.Element("Title").Value;
nListenCommandStartPort = Convert.ToInt32(xGetElement.Element("ListenCommandPort").Attribute("Start").Value);
nListenCommandEndPort = Convert.ToInt32(xGetElement.Element("ListenCommandPort").Attribute("End").Value);
nListenCommandPortNum = nListenCommandEndPort - nListenCommandStartPort;
nListenStreamStartPort = Convert.ToInt32(xGetElement.Element("ListenStreamPort").Attribute("Start").Value);
nListenStreamEndPort = Convert.ToInt32(xGetElement.Element("ListenStreamPort").Attribute("End").Value);
nListenStreamPortNum = nListenStreamEndPort - nListenStreamStartPort;
nListenCommandPort = new int[nListenCommandPortNum];
nListenStreamPort = new int[nListenStreamPortNum];
for (int i = 0; i < nListenCommandPortNum; i++)
nListenCommandPort[i] = nListenCommandStartPort + i;
for (int i = 0; i < nListenStreamPortNum; i++)
nListenStreamPort[i] = nListenStreamStartPort + i;
nDistributionCommandStartPort = Convert.ToInt32(xGetElement.Element("DistributionCommandPort").Attribute("Start").Value);
nDistributionCommandEndPort = Convert.ToInt32(xGetElement.Element("DistributionCommandPort").Attribute("End").Value);
nDistributionCommandPortNum = nDistributionCommandEndPort - nDistributionCommandStartPort;
nDistributionStreamStartPort = Convert.ToInt32(xGetElement.Element("DistributionStreamPort").Attribute("Start").Value);
nDistributionStreamEndPort = Convert.ToInt32(xGetElement.Element("DistributionStreamPort").Attribute("End").Value);
nDistributionStreamPortNum = nDistributionStreamEndPort - nDistributionStreamStartPort;
SERVER_SAVE_POS = @xGetElement.Element("LogFileSavePos").Value;
MES_SAVE_POS = @xGetElement.Element("MESFileSavePos").Value;
USE_HOST_INFO = Convert.ToBoolean(xGetElement.Element("UseHostInfo").Value);
HOST_TABLE_NAME = @xGetElement.Element("HostInfoTableName").Value;
USER_TABLE_NAME = @xGetElement.Element("UserInfoTableName").Value;
DISK_MONITOR_POS1 = xGetElement.Element("DiskMonitor1").Value;
DISK_MONITOR_POS2 = xGetElement.Element("DiskMonitor2").Value;
if (DISK_MONITOR_POS1.Length <= 0)
DISK_MONITOR_POS1 = @"C:\";
if (DISK_MONITOR_POS2.Length <= 0)
DISK_MONITOR_POS2 = @"D:\";
SyncTimeServerAddress = xGetElement.Element("SyncTimeServerAddress").Attribute("Address").Value;
SyncTimeServerPort = int.MinValue;
if (int.TryParse(xGetElement.Element("SyncTimePort").Attribute("Port").Value, out SyncTimeServerPort) == false)
SyncTimeServerPort = int.MinValue;
TimeServerSyncTimeHour = 24;
TimeServerSyncTimeMinute = 0;
TimeServerSyncTimeSecond = 0;
if (int.TryParse(xGetElement.Element("TimeServer-SyncTime").Attribute("H").Value, out TimeServerSyncTimeHour) == false)
TimeServerSyncTimeHour = 24;
if (int.TryParse(xGetElement.Element("TimeServer-SyncTime").Attribute("M").Value, out TimeServerSyncTimeMinute) == false)
TimeServerSyncTimeMinute = 0;
if (int.TryParse(xGetElement.Element("TimeServer-SyncTime").Attribute("S").Value, out TimeServerSyncTimeSecond) == false)
TimeServerSyncTimeSecond = 0;
if (Base.CheckPath(SERVER_SAVE_POS)) {
if (Directory.Exists(SERVER_SAVE_POS) == false)
Directory.CreateDirectory(SERVER_SAVE_POS);
}
else {
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"ServerInfo read failed.(SERVER SAVE POS - Folder name error)[SystemX.Common : SystemX.Net.ServerInfo]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
throw new Exception();
}
if (Base.CheckPath(MES_SAVE_POS)) {
if (Directory.Exists(MES_SAVE_POS) == false) {
Directory.CreateDirectory(MES_SAVE_POS);
/*MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"ServerInfo read failed.(MES SAVE POS - Folder exist error)[SystemX.Common : SystemX.Net.ServerInfo]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
throw new Exception();*/
}
}
else {
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"ServerInfo read failed.(MES SAVE POS - Folder name error)[SystemX.Common : SystemX.Net.ServerInfo]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
throw new Exception();
}
}
}
catch (Exception e) {
READ_INFO_STATE = false;
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"ServerInfo read failed.[SystemX.Common : SystemX.Net.ServerInfo]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
return READ_INFO_STATE;
}
}
public class MapLogOption
{
public bool bReadInfoState { set; get; }
private string strInfoFilePos;
public bool bUseMapLog;
public string strMapLogEnterMutexName;
public string strMapLogAccessMutexName;
public string strMapLogPath;
public string strMapLogFileName;
public string strMapLogName;
public string strMapInfoLogEnterMutexName;
public string strMapInfoLogAccessMutexName;
public string strMapInfoLogPath;
public string strMapInfoLogFileName;
public string strMapInfoLogName;
public MapLogOption(string strGetInfoPath)
{
strInfoFilePos = strGetInfoPath;
}
public bool Load()
{
bReadInfoState = true;
try
{
XDocument xDoc = XDocument.Load(strInfoFilePos);
var xElement = xDoc.Element("ROOT");
if (xElement != null)
{
var xGetElement = xElement.Element("Configure");
XElement xEle = xGetElement.Element("UseMapLog");
if (xEle?.IsEmpty == false)
bUseMapLog = Convert.ToBoolean(xGetElement.Element("UseMapLog").Value);
else
bUseMapLog = false;
strMapLogEnterMutexName = xGetElement.Element("MapLogEnterMutexName").Value;
strMapLogAccessMutexName = xGetElement.Element("MapLogAccessMutexName").Value;
strMapLogPath = @xGetElement.Element("MapLogFilePath").Value;
strMapLogFileName = xGetElement.Element("MapLogFileName").Value;
strMapLogName = xGetElement.Element("MapLogName").Value;
strMapInfoLogEnterMutexName = xGetElement.Element("MapInfoLogEnterMutexName").Value;
strMapInfoLogAccessMutexName = xGetElement.Element("MapInfoLogAccessMutexName").Value;
strMapInfoLogPath = @xGetElement.Element("MapInfoLogFilePath").Value;
strMapInfoLogFileName = xGetElement.Element("MapInfoLogFileName").Value;
strMapInfoLogName = xGetElement.Element("MapInfoLogName").Value;
if (Base.CheckPath(strMapLogPath))
{
if (Directory.Exists(strMapLogPath) == false)
Directory.CreateDirectory(strMapLogPath);
}
else
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"MapLogOption read failed. (Map Log Path - Folder name error)[SystemX.Common : SystemX.Net.MapLogOption]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
throw new Exception();
}
if (Base.CheckPath(strMapInfoLogPath))
{
if (Directory.Exists(strMapInfoLogPath) == false)
Directory.CreateDirectory(strMapInfoLogPath);
}
else
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"MapLogOption read failed. (Map Info Log Path - Folder name error)[SystemX.Common : SystemX.Net.MapLogOption]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
throw new Exception();
}
}
}
catch (Exception e)
{
bReadInfoState = false;
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"MapLogOption read failed. [SystemX.Common : SystemX.Net.MapLogOption]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
return bReadInfoState;
}
}
/// <summary>
/// PLC Device Base Infomation
/// </summary>
/// <param name="index"> Num, Port, Use, ProcessCode, TestID, ProcessName, PLCCOnfilgFileName </param>
public class PLCBaseInfo {
public bool READ_INFO_STATE { set; get; }
private string strInfoFilePos;
private int MAX_DEVICE_NUM;
public string SERVER_IP;
public bool LOOP_BACK;
public PLCDeviceBaseConfig[] BaseInfo;
public PLCBaseInfo(string strGetInfoPath, int iMaxDeviceNum) {
strInfoFilePos = strGetInfoPath;
MAX_DEVICE_NUM = iMaxDeviceNum;
BaseInfo = new PLCDeviceBaseConfig[MAX_DEVICE_NUM];
}
public bool Load() {
READ_INFO_STATE = true;
try
{
XDocument xDoc = XDocument.Load(strInfoFilePos);
var xElement = xDoc.Element("ROOT");
int iPort = 0;
if (xElement != null) {
var xGetElement = xElement.Element("Configure");
SERVER_IP = xGetElement.Element("UseIP").Value;
LOOP_BACK = Convert.ToBoolean(xGetElement.Element("Loopback").Value);
var ListGetElement = xElement.Elements("MiddlewareConnect").ToList();
foreach (var getXElement in ListGetElement) {
if (getXElement.Attribute("INFO")?.Value.CompareTo("COMMON") == 0) {
for (int i = 0; i < MAX_DEVICE_NUM; i++) {
BaseInfo[i] = new PLCDeviceBaseConfig();
BaseInfo[i].nNum = i;
BaseInfo[i].nCommandPort = Convert.ToInt32(getXElement.Element("Device" + (i + 1).ToString()).Attribute("Command_PortNumber").Value);
BaseInfo[i].nStreamPort = Convert.ToInt32(getXElement.Element("Device" + (i + 1).ToString()).Attribute("Stream_PortNumber").Value);
BaseInfo[i].bUse = Convert.ToBoolean(getXElement.Element("Device" + (i + 1).ToString()).Attribute("Use").Value);
BaseInfo[i].nProcessCode = Convert.ToInt32(getXElement.Element("Device" + (i + 1).ToString()).Attribute("ProcessCode").Value);
BaseInfo[i].strTestID = getXElement.Element("Device" + (i + 1).ToString()).Attribute("TestID").Value;
BaseInfo[i].strProcessName = getXElement.Element("Device" + (i + 1).ToString()).Attribute("ProcessName").Value;
BaseInfo[i].strPLCCOnfilgFileName = getXElement.Element("Device" + (i + 1).ToString()).Attribute("PLCConfigFileName").Value;
BaseInfo[i].strPLCUseType = getXElement.Element("Device" + (i + 1).ToString()).Attribute("PLCUseType").Value;
}
}
}
}
}
catch (Exception e) {
READ_INFO_STATE = false;
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"PLCBaseInfo read failed.[SystemX.Common : SystemX.Net.PLCBaseInfo]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
return READ_INFO_STATE;
}
}
/// <summary>
/// PC Client Base Infomation
/// </summary>
public class ClientInfo {
public bool READ_INFO_STATE { set; get; }
private string strInfoFilePos;
public string CONNECT_IP;
public int COMMAND_PORT;
public int STREAM_PORT;
public bool LOOP_BACK;
public string HOST_ID;
public string SECTION;
public string TEST_CODE;
/* TODO : UIM Mode 및 기존 코드 정리 필요 */
//SIMPLE_LOOKUP_OPTION
//ISSUE_WORKER_WAIT_TIME_ms
//SESSION_TIMEOUT_TIME_S
//UIM
public bool SIMPLE_LOOKUP_OPTION;
public double ISSUE_WORKER_WAIT_TIME_ms;
public double SESSION_TIMEOUT_TIME_S;
//TODO : Client ALIS FTP
public bool FTP_Use;
public string FTP_IPAddress;
public string FTP_Port;
public string FTP_Account;
public string FTP_Password;
public ClientInfo() {
strInfoFilePos = "";
}
public ClientInfo(string strGetInfoPath) {
strInfoFilePos = strGetInfoPath;
}
public bool Load() {
READ_INFO_STATE = true;
SIMPLE_LOOKUP_OPTION = false;
ISSUE_WORKER_WAIT_TIME_ms = 3000.0;
SESSION_TIMEOUT_TIME_S = 300.0;
TEST_CODE = string.Empty;
try
{
XDocument xDoc = XDocument.Load(strInfoFilePos);
var xElement = xDoc.Element("ROOT");
if (xElement != null) {
var xGetElement = xElement.Element("Configure");
CONNECT_IP = xGetElement.Element("UseIP").Value;
COMMAND_PORT = Convert.ToInt32((xGetElement.Element("CommandPort").Value.IndexOf("-") >= 0) ? "0" : xGetElement.Element("CommandPort").Value);
STREAM_PORT = Convert.ToInt32((xGetElement.Element("StreamPort").Value.IndexOf("-") >= 0) ? "0" : xGetElement.Element("StreamPort").Value);
LOOP_BACK = Convert.ToBoolean(xGetElement.Element("Loopback").Value);
HOST_ID = @xGetElement.Element("HostID").Value;
SECTION = @xGetElement.Element("Section").Value;
XElement xEle = xGetElement.Element("TestCode");
if (xEle?.IsEmpty == false)
TEST_CODE = @xGetElement.Element("TestCode").Value;
/*SCAN_LOG_FOLDER = Convert.ToBoolean(xGetElement.Element("LogFileScan").Value);
SCAN_LOG_FOLDER_POS = xGetElement.Element("LogFileScanPos").Value;
if (SCAN_LOG_FOLDER) {
if (Base.CheckPath(SCAN_LOG_FOLDER_POS)) {
if (Directory.Exists(SCAN_LOG_FOLDER_POS) == false) {
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"ClientInfo read failed.(Scan log folder not exist)[SystemX.Common : SystemX.Net.ClientInfo]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
throw new Exception();
}
}
else {
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"ClientInfo read failed.(Scan log folder name error)[SystemX.Common : SystemX.Net.ClientInfo]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
throw new Exception();
}
}
SCAN_DEVICE_FOLDER = Convert.ToBoolean(xGetElement.Element("DeviceFileScan").Value);
SCAN_DEVICE_FOLDER_TYPE = xGetElement.Element("DeviceFileScanType").Value;
SCAN_DEVICE_FOLDER_POS = xGetElement.Element("DeviceFileScanPos").Value;
if (SCAN_DEVICE_FOLDER) {
if (Base.CheckPath(SCAN_DEVICE_FOLDER_POS)) {
if (Directory.Exists(SCAN_DEVICE_FOLDER_POS) == false) {
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"ClientInfo read failed.(Scan device folder not exist)[SystemX.Common : SystemX.Net.ClientInfo]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
throw new Exception();
}
}
else
{
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"ClientInfo read failed.(Scan device folder name error)[SystemX.Common : SystemX.Net.ClientInfo]", ConsoleColor.Yellow, LogMessageLevel.DEBUG);
throw new Exception();
}
}*/
xEle = xGetElement.Element("SimpleLookUpOption");
bool bValue = false;
//string strValue;
if (xEle?.IsEmpty == false) {
if (bool.TryParse(xEle.Value, out bValue))
SIMPLE_LOOKUP_OPTION = Convert.ToBoolean(xEle.Value);
}
xEle = xGetElement.Element("IssueWorkerWaitTime_ms");
double dValue = double.NaN;
if (xEle?.IsEmpty == false) {
if(double.TryParse(xEle.Value, out dValue))
ISSUE_WORKER_WAIT_TIME_ms = Convert.ToDouble(xEle.Value);
}
xEle = xGetElement.Element("SessionTimeout_s");
if (xGetElement.Element("SessionTimeout_s")?.IsEmpty == false) {
dValue = double.NaN;
if (double.TryParse(xEle.Value, out dValue))
SESSION_TIMEOUT_TIME_S = Convert.ToDouble(xEle.Value);
}
//TODO : Client ALIS FTP
xEle = xGetElement.Element("UseFTP");
if (xEle?.IsEmpty == false)
{
if (bool.TryParse(xEle.Value, out bValue))
FTP_Use = bValue;
}
else
FTP_Use = false;
xEle = xGetElement.Element("IPAddressFTP");
if (xEle?.IsEmpty == false)
FTP_IPAddress = xEle.Value;
else
FTP_IPAddress = "0.0.0.0";
xEle = xGetElement.Element("PortFTP");
if (xEle?.IsEmpty == false)
FTP_Port = xEle.Value;
else
FTP_Port = "21";
xEle = xGetElement.Element("AccountFTP");
if (xEle?.IsEmpty == false)
FTP_Account = xEle.Value;
else
FTP_Account = "";
xEle = xGetElement.Element("PasswordFTP");
if (xEle?.IsEmpty == false)
FTP_Password = xEle.Value;
else
FTP_Password = "";
}
}
catch (Exception e) {
READ_INFO_STATE = false;
MessageOutput.ConsoleWrite(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss>>") + @"ClientInfo read failed.[SystemX.Common : SystemX.Net.ClientInfo]\r\n" + e.Message, ConsoleColor.Yellow, LogMessageLevel.DEBUG);
}
return READ_INFO_STATE;
}
}
}

2640
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net/Protocol/BasePacket.cs Normal file
View File

File diff suppressed because it is too large Load Diff

672
SystemX.Net.CP.Platform/SystemX.Net.Platform/SystemX.Net/Protocol/BaseProtocol.cs Normal file
View File

@ -0,0 +1,672 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.Net.BaseProtocol
{
[Serializable]
public enum PROCESS_TYPE
{
NONE = -1,
SYSTEM = 0,
PLC = 1,
PC = 2,
DEVICE = 3,
UIM = 4,
UIM_SERVER = 5,
PC_PORT_SERVER = 6
}
/*
* Adaptor
*/
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), Serializable]
public struct STRING_4
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 4)]
public string Data;
}
//------------------------------------------------------------------------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), Serializable]
public struct STRING_8
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
public string Data;
}
//------------------------------------------------------------------------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), Serializable]
public struct STRING_16
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
public string Data;
}
//------------------------------------------------------------------------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), Serializable]
public struct STRING_32
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
public string Data;
}
//------------------------------------------------------------------------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), Serializable]
public struct STRING_64
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
public string Data;
}
//------------------------------------------------------------------------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), Serializable]
public struct STRING_128
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
public string Data;
}
//------------------------------------------------------------------------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), Serializable]
public struct STRING_256
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string Data;
}
//------------------------------------------------------------------------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), Serializable]
public struct STRING_512
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
public string Data;
}
//------------------------------------------------------------------------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), Serializable]
public struct STRING_1024
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 1024)]
public string Data;
}
//------------------------------------------------------------------------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), Serializable]
public struct STRING_2048
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 2048)]
public string Data;
}
//------------------------------------------------------------------------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), Serializable]
public struct STRING_4096
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 4096)]
public string Data;
}
//------------------------------------------------------------------------------------------
/*
* System Query
*/
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), Serializable]
public struct QUERY_STRING
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 2048)]
public string Data;
}
//------------------------------------------------------------------------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct SYSTEMTIME
{
public short wYear;
public short wMonth;
public short wDayOfWeek;
public short wDay;
public short wHour;
public short wMinute;
public short wSecond;
public short wMilliseconds;
}
//------------------------------------------------------------------------------------------
/*
* Initialize Comm Body
*/
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct COMM_INFO_PACKET
{
//Use Port Distribution
[MarshalAs(UnmanagedType.Bool)]
public bool bPortDistribution;
//COMMAND 포트 번호
[MarshalAs(UnmanagedType.U2)]
public ushort usPortCommandNumber;
//STREAM 포트 번호
[MarshalAs(UnmanagedType.U2)]
public ushort usPortStreamNumber;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_32[] objConnLocalAddress;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_32[] objConnLocalPort;
}
//------------------------------------------------------------------------------------------
/*
* Initialize Comm Body
*/
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct PING_PACKET
{
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_8[] objCheckMsg;
}
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct TIME_PACKET
{
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_32[] objMsg;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public SYSTEMTIME[] objTime;
}
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct MESSAGE_PACKET
{
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_512[] objMessage;
}
//------------------------------------------------------------------------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct TRANSFER_PACKET
{
//수신 결과
[MarshalAs(UnmanagedType.Bool)]
public bool bRecvResult;
//처리 결과
[MarshalAs(UnmanagedType.Bool)]
public bool bProcessResult;
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
/*
* Packet Header
*/
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct HEADER_PACKET
{
[MarshalAs(UnmanagedType.U2)]
public ushort usHeader;
//응답 결과
[MarshalAs(UnmanagedType.Bool)]
public bool bResponsState;
//네트워크 번호
[MarshalAs(UnmanagedType.U1)]
public byte ucNetworkNo;
//데이터베이스 ID
[MarshalAs(UnmanagedType.U1)]
public byte ucDatabaseID;
//테이블 ID
[MarshalAs(UnmanagedType.U2)]
public ushort usTableID;
//Pallet Number
[MarshalAs(UnmanagedType.U1)]
public byte ucPalletNumber;
//Pallet Index
[MarshalAs(UnmanagedType.U2)]
public ushort usPalletIndex;
//해당 헤더 크기
[MarshalAs(UnmanagedType.U4)]
public uint uiHeaderLength;
//선택된 바디 패킷 길이
[MarshalAs(UnmanagedType.U4)]
public uint uiBodyLength;
//전체 패킷 크기
[MarshalAs(UnmanagedType.U4)]
public uint uiPacketLength;
//실제 데이터 크기
[MarshalAs(UnmanagedType.U4)]
public uint uiDataLength;
//로그 파일 전송시 이름
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_128[] objOptionName;
//최종 변환 확장자 명
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_8[] objOptionExtension;
//연속 패킷(대용량) 현재 번호 Default 0 Else 1 ~
[MarshalAs(UnmanagedType.U4)]
public uint uiSourDataNum;
//연속 패킷(대용량) 최종 번호 Default 0 Else 1 ~
[MarshalAs(UnmanagedType.U4)]
public uint uiDestDataNum;
//주 명령
[MarshalAs(UnmanagedType.U2)]
public ushort usCommand;
//서브 명령
[MarshalAs(UnmanagedType.U2)]
public ushort usSubCommand;
//옵션 명령
[MarshalAs(UnmanagedType.U4)]
public uint uiOptionCommand;
//다목적 사용 파라미터1
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_64[] objVarParam1;
//다목적 사용 파라미터2
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_128[] objVarParam2;
//다목적 사용 파라미터3
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_256[] objVarParam3;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public CP_PACKET[] objCP_Packet;
}
//------------------------------------------------------------------------------------------
/*
* CP Info Header
*/
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct CP_PACKET
{
//CP ALIS StationName
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_64[] objStationName;
//CP ALIS ProdP
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objProdNo_P;
//CP ALIS ProdC
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objProdNo_C;
//CP ALIS TestType
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_8[] objTestType;
//CP ALIS TestCode
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objTestCode;
//CP ALIS Version
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_4[] objVersion;
//CP ALIS ProdCode
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_4[] objProdCode;
//CP ALIS TestListNo
[MarshalAs(UnmanagedType.U4)]
public uint uiTestListNo;
}
//------------------------------------------------------------------------------------------
/*
* PLC Adaptor 지원
*/
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct USER_PACKET
{
//파레트 정보 및 제품 아이디 및 품번
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public PROCESS_PACKET[] objProcessInfo;
//명령 INSERT, UPDATE, DELETE SELECT 등 현재는 INSERT 만.
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objTableCommand;
//테이블 명칭
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_64[] objTableName;
//컬럼 길이
[MarshalAs(UnmanagedType.U4)]
public uint uiSubLength;
//0 부터 해당 컬럼 명
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_512[] objNames;
//0 부터 해당 컬럼 데이터
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_512[] objDatas;
//처리 결과
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objCommandResult;
}
//------------------------------------------------------------------------------------------
/*
* SYSTEM 지원
*/
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct QUERY_PACKET
{
//QUERY 문
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public QUERY_STRING[] objQueryText;
//다목적 파라미터1
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_64[] objVarParam1;
//다목적 파라미터2
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_128[] objVarParam2;
//다목적 파라미터3
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_256[] objVarParam3;
}
//------------------------------------------------------------------------------------------
/*
* HOST LOGIN
*/
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct SYSTEM_HOST_PACKET
{
//UIM Use
[MarshalAs(UnmanagedType.Bool)]
public bool bUseUIM;
//UIM Use
[MarshalAs(UnmanagedType.Bool)]
public bool bUseSimpleLookupOption;
//HOST ID
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_64[] objHostID;
//SECTION
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_64[] objSection;
//TEST CODE
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_64[] objTestCode;
//MESSAGE
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_512[] objMessage;
}
//------------------------------------------------------------------------------------------
/*
* PROCESS QUERY(PC, PLC Adaptor) 지원
*/
[StructLayout(LayoutKind.Sequential, Pack = 1), Serializable]
public struct PROCESS_PACKET
{
//Station ID
[MarshalAs(UnmanagedType.U4)]
public uint nStationID;
//ProdC
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objProdNo_C;
//TestType
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_8[] objTestType;
//TestCode
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_16[] objTestCode;
//FileVersion
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_4[] objTestListFileVersion;
//ProductionCode
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_4[] objProductionCode;
//Product ID
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public STRING_64[] objProductID;
}
//------------------------------------------------------------------------------------------
public class BASE_PROTOCOL
{
//BASE PROTOCOL Main Command 0 - Private
public enum PROTOCOL_CODE
{
NONE = -1,
//PC Adaptor File Save
FILE_TRANSFER = 0,
DATASET_TRANSEFER = 1,
//Just reply
SIMPLE_RESPONSE = 2,
//PLC Adaptor
ETC = 3,
RAW_SIZE = 4,
RAW_END = 5,
//System Program
SYSTEM_QUERY = 6,
INITILALIZE_INFO = 7,
PROCESS_QUERY = 8,
USER_QUERY = 9,
TRANSFER_RESULT = 10,
//Time Server Sync Request
SYNC_TIME_SERVER = 128,
//Host Info Check
HOST_INFO_CHECK = 256,
//Middleware send message
MIDDLEWARE_MESSAGE = 512,
//Ping
CONNECT_STATE = 1024
}
[Flags]
public enum OPTION_CODE
{
NONE = 0x00000000,
QUERY_TESTLIST = 0x00000001,
GET_ISSUANCE_MACADDRESS = 0x00000002,
CHECK_VAILD_TESTLIST = 0x00000004,
}
public OPTION_CODE GetOptionCode()
{
return (OPTION_CODE)uiOptionCommand;
}
public void SetOptionCode(OPTION_CODE SET_OPTION)
{
uiOptionCommand = (uint)SET_OPTION;
}
//
private ushort usCommand;
private ushort usSubCommand;
private uint uiOptionCommand;
public PROTOCOL_CODE GET_CURRENT_PROTOCOL
{
get { return ProtocolDecoder(); }
}
public ushort COMMAND
{
get { return usCommand; }
}
public ushort SUB_COMMAND
{
get { return usSubCommand; }
}
public uint OPTION_COMMAND
{
get { return uiOptionCommand; }
}
public PROTOCOL_CODE ProtocolDecoder()
{
PROTOCOL_CODE SET_CODE = new PROTOCOL_CODE();
SET_CODE = PROTOCOL_CODE.NONE;
string TextCode = usCommand.ToString("D3") + "_" + usSubCommand.ToString("D3");
if (TextCode.CompareTo("000_001") == 0)
SET_CODE = PROTOCOL_CODE.FILE_TRANSFER;
else if (TextCode.CompareTo("000_002") == 0)
SET_CODE = PROTOCOL_CODE.DATASET_TRANSEFER;
else if (TextCode.CompareTo("000_003") == 0)
SET_CODE = PROTOCOL_CODE.SIMPLE_RESPONSE;
else if (TextCode.CompareTo("000_004") == 0)
SET_CODE = PROTOCOL_CODE.RAW_SIZE;
else if (TextCode.CompareTo("000_005") == 0)
SET_CODE = PROTOCOL_CODE.RAW_END;
else if (TextCode.CompareTo("000_006") == 0)
SET_CODE = PROTOCOL_CODE.SYSTEM_QUERY;
else if (TextCode.CompareTo("000_007") == 0)
SET_CODE = PROTOCOL_CODE.INITILALIZE_INFO;
else if (TextCode.CompareTo("000_009") == 0)
SET_CODE = PROTOCOL_CODE.USER_QUERY;
else if (TextCode.CompareTo("000_010") == 0)
SET_CODE = PROTOCOL_CODE.TRANSFER_RESULT;
else if (TextCode.CompareTo("001_000") == 0)
SET_CODE = PROTOCOL_CODE.ETC;
else if (TextCode.CompareTo("002_001") == 0)
SET_CODE = PROTOCOL_CODE.PROCESS_QUERY;
else if (TextCode.CompareTo("999_004") == 0)
SET_CODE = PROTOCOL_CODE.SYNC_TIME_SERVER;
else if (TextCode.CompareTo("999_003") == 0)
SET_CODE = PROTOCOL_CODE.HOST_INFO_CHECK;
else if (TextCode.CompareTo("999_002") == 0)
SET_CODE = PROTOCOL_CODE.MIDDLEWARE_MESSAGE;
else if (TextCode.CompareTo("999_001") == 0)
SET_CODE = PROTOCOL_CODE.CONNECT_STATE;
else
SET_CODE = PROTOCOL_CODE.NONE;
return SET_CODE;
}
public BASE_PROTOCOL()
{
}
public BASE_PROTOCOL(ushort usGetCommnad, ushort usGetSubCommand, uint uiGetOptionCommand = 0)
{
usCommand = usGetCommnad;
usSubCommand = usGetSubCommand;
//
uiOptionCommand = uiGetOptionCommand;
}
/*
public void PROTOCOL_CHANGE(PROTOCOL_CODE SET_CODE, OPTION_CODE SET_OPTION = OPTION_CODE.NONE)
{
new BASE_PROTOCOL(SET_CODE, SET_OPTION);
}
*/
public BASE_PROTOCOL(PROTOCOL_CODE SET_CODE, OPTION_CODE SET_OPTION = OPTION_CODE.NONE)
{
uiOptionCommand = (uint)SET_OPTION;
if (SET_CODE == PROTOCOL_CODE.NONE)
{
usCommand = 0;
usSubCommand = 0;
}
else if (SET_CODE == PROTOCOL_CODE.FILE_TRANSFER)
{
usCommand = 0;
usSubCommand = 1;
}
else if (SET_CODE == PROTOCOL_CODE.DATASET_TRANSEFER)
{
usCommand = 0;
usSubCommand = 2;
}
else if (SET_CODE == PROTOCOL_CODE.SIMPLE_RESPONSE)
{
usCommand = 0;
usSubCommand = 3;
}
else if (SET_CODE == PROTOCOL_CODE.RAW_SIZE)
{
usCommand = 0;
usSubCommand = 4;
}
else if (SET_CODE == PROTOCOL_CODE.RAW_END)
{
usCommand = 0;
usSubCommand = 5;
}
else if (SET_CODE == PROTOCOL_CODE.SYSTEM_QUERY)
{
usCommand = 0;
usSubCommand = 6;
}
else if (SET_CODE == PROTOCOL_CODE.INITILALIZE_INFO)
{
usCommand = 0;
usSubCommand = 7;
}
else if (SET_CODE == PROTOCOL_CODE.USER_QUERY)
{
usCommand = 0;
usSubCommand = 9;
}
else if (SET_CODE == PROTOCOL_CODE.TRANSFER_RESULT)
{
usCommand = 0;
usSubCommand = 10;
}
//
else if (SET_CODE == PROTOCOL_CODE.ETC)
{
usCommand = 1;
usSubCommand = 0;
}
else if (SET_CODE == PROTOCOL_CODE.PROCESS_QUERY)
{
usCommand = 2;
usSubCommand = 1;
}
else if (SET_CODE == PROTOCOL_CODE.SYNC_TIME_SERVER)
{
usCommand = 999;
usSubCommand = 4;
}
else if (SET_CODE == PROTOCOL_CODE.HOST_INFO_CHECK)
{
usCommand = 999;
usSubCommand = 3;
}
else if (SET_CODE == PROTOCOL_CODE.MIDDLEWARE_MESSAGE)
{
usCommand = 999;
usSubCommand = 2;
}
else if (SET_CODE == PROTOCOL_CODE.CONNECT_STATE)
{
usCommand = 999;
usSubCommand = 1;
}
else
{
usCommand = 0;
usSubCommand = 0;
}
}
}
}

42
SystemX.Net.CP.Platform/SystemX.Net.Platform/packages.config Normal file
View File

@ -0,0 +1,42 @@
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="Microsoft.NETCore.Platforms" version="1.1.0" targetFramework="net452" />
<package id="NETStandard.Library" version="1.6.1" targetFramework="net452" />
<package id="Remotion.Linq" version="2.1.1" targetFramework="net452" />
<package id="System.Collections" version="4.3.0" targetFramework="net452" />
<package id="System.Collections.Concurrent" version="4.3.0" targetFramework="net452" />
<package id="System.Collections.Immutable" version="1.3.0" targetFramework="net452" />
<package id="System.ComponentModel" version="4.3.0" targetFramework="net452" />
<package id="System.Diagnostics.Debug" version="4.3.0" targetFramework="net452" />
<package id="System.Diagnostics.DiagnosticSource" version="4.3.1" targetFramework="net452" />
<package id="System.Diagnostics.Tools" version="4.3.0" targetFramework="net452" />
<package id="System.Diagnostics.Tracing" version="4.3.0" targetFramework="net452" />
<package id="System.Globalization" version="4.3.0" targetFramework="net452" />
<package id="System.Interactive.Async" version="3.0.0" targetFramework="net452" />
<package id="System.IO" version="4.3.0" targetFramework="net452" />
<package id="System.IO.Compression" version="4.3.0" targetFramework="net452" />
<package id="System.Linq" version="4.3.0" targetFramework="net452" />
<package id="System.Linq.Expressions" version="4.3.0" targetFramework="net452" />
<package id="System.Linq.Queryable" version="4.0.1" targetFramework="net452" />
<package id="System.Net.Http" version="4.3.0" targetFramework="net452" />
<package id="System.Net.Primitives" version="4.3.0" targetFramework="net452" />
<package id="System.ObjectModel" version="4.3.0" targetFramework="net452" />
<package id="System.Reflection" version="4.3.0" targetFramework="net452" />
<package id="System.Reflection.Extensions" version="4.3.0" targetFramework="net452" />
<package id="System.Reflection.Primitives" version="4.3.0" targetFramework="net452" />
<package id="System.Resources.ResourceManager" version="4.3.0" targetFramework="net452" />
<package id="System.Runtime" version="4.3.0" targetFramework="net452" />
<package id="System.Runtime.CompilerServices.Unsafe" version="4.3.0" targetFramework="net452" />
<package id="System.Runtime.Extensions" version="4.3.0" targetFramework="net452" />
<package id="System.Runtime.InteropServices" version="4.3.0" targetFramework="net452" />
<package id="System.Runtime.InteropServices.RuntimeInformation" version="4.3.0" targetFramework="net452" />
<package id="System.Runtime.Numerics" version="4.3.0" targetFramework="net452" />
<package id="System.Text.Encoding" version="4.3.0" targetFramework="net452" />
<package id="System.Text.Encoding.Extensions" version="4.3.0" targetFramework="net452" />
<package id="System.Text.RegularExpressions" version="4.3.0" targetFramework="net452" />
<package id="System.Threading" version="4.3.0" targetFramework="net452" />
<package id="System.Threading.Tasks" version="4.3.0" targetFramework="net452" />
<package id="System.Threading.Timer" version="4.3.0" targetFramework="net452" />
<package id="System.Xml.ReaderWriter" version="4.3.0" targetFramework="net452" />
<package id="System.Xml.XDocument" version="4.3.0" targetFramework="net452" />
</packages>

18
SystemX.Net.CP.Platform/SystemX.PLC/App.config Normal file
View File

@ -0,0 +1,18 @@
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
</startup>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="FSharp.Core" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-4.3.1.0" newVersion="4.3.1.0" />
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name="log4net" publicKeyToken="669e0ddf0bb1aa2a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-2.0.8.0" newVersion="2.0.8.0" />
</dependentAssembly>
</assemblyBinding>
</runtime>
</configuration>

39
SystemX.Net.CP.Platform/SystemX.PLC/Form1.Designer.cs generated Normal file
View File

@ -0,0 +1,39 @@
namespace SystemX.PLC
{
partial class Form1
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.components = new System.ComponentModel.Container();
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.Text = "Form1";
}
#endregion
}
}

20
SystemX.Net.CP.Platform/SystemX.PLC/Form1.cs Normal file
View File

@ -0,0 +1,20 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace SystemX.PLC
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
}
}

497
SystemX.Net.CP.Platform/SystemX.PLC/Interface/McProtocol/PLCCommMcPMgr.cs Normal file
View File

@ -0,0 +1,497 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using SystemX.Net.Platform.Common.Event;
using SystemX.Net.Platform.Common.Util;
using static SystemX.PLC.Interface.PLCCommDefinition;
namespace SystemX.PLC.Interface.McProtocol
{
public class PLCCommMcPMgr : PLCCommManager
{
private int TimeOut;
public Dictionary<ePLCRWType, PLCModMxCMgr> PLCManagers { get; set; } = new Dictionary<ePLCRWType, PLCModMxCMgr>();
public PLCCommMcPMgr(string strPLCConnInfoXmlPath)
: base(strPLCConnInfoXmlPath)
{
AddrMgr = new PLCAddressManager(strPLCConnInfoXmlPath);
EventChangeUpdate = new FunctionEventHandler();
TimeOut = 0;
foreach (PLCConnectionInfo coninfo in AddrMgr.ConnInfoDictionary.Values)
{
if (TimeOut < int.Parse(coninfo.Timeout))
TimeOut = int.Parse(coninfo.Timeout);
PLCManagers.Add((ePLCRWType)Enum.Parse(typeof(ePLCRWType), coninfo.RWType), new PLCModMxCMgr(coninfo));
}
}
public override bool OpenPLCConnection()
{
Task<bool> openconn = new Task<bool>(() => TryOpenPLCConnection());
openconn.Start();
bool bResult = openconn.Result;
if (bResult)
{
//Task plcoperation = openconn.ContinueWith(x => StartPLCOperation());
Task<bool> plcoperation = new Task<bool>(() => StartPLCOperation());
plcoperation.Start();
bResult = plcoperation.Result;
}
return bResult;
/*
if (plcoperation.Wait(TimeOut))
return true;
else
return false;
*/
}
public bool TryOpenPLCConnection()
{
try
{
foreach (PLCModMxCMgr conmgr in PLCManagers.Values)
{
if (!conmgr.OpenDevice())
return false;
Stopwatch stTimeOut = new Stopwatch();
stTimeOut.Start();
while (true)
{
if (conmgr.IsOpened == true)
break;
if (stTimeOut.ElapsedMilliseconds >= TimeOut)
{
LogMessage.MessageOutput.ConsoleWrite("PLC Connection Waiting TimeOut.", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
Thread.Sleep(50);
}
conmgr.EventPLC += ReceivePLCEvent;
SetAddress(conmgr, AddrMgr.OperationDictionary);
SetAddress(conmgr, AddrMgr.DataDictionary);
}
LogMessage.MessageOutput.ConsoleWrite("PLC Connection Waiting for Success.", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Open Error.\n - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
public override bool StartPLCOperation()
{
try
{
Thread.Sleep(300);
PLCManagers[ePLCRWType.Read].SingleScanStartAsync(); // Do not use await
UpdateAll();
OperationStarted = true;
LogMessage.MessageOutput.ConsoleWrite("PLC Operation Started.", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Open Error.\n - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
public override void NowScanDataArea()
{
}
public override bool ClosePLCConnection()
{
try
{
foreach (PLCModMxCMgr conmgr in PLCManagers.Values)
conmgr.CloseDevice();
OperationStarted = false;
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Close Error.\n - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
public override void ReceivePLCEvent(string address, int value)
{
PLCAddressTemplate tmpltSearch = SearchMySubscription(address);
if (tmpltSearch == null)
return;
UpdateDevice(tmpltSearch, address, value);
EventChangeUpdate.DoReceive(this, address);
}
public PLCAddressTemplate SearchMySubscription(string strAddress)
{
PLCAddressTemplate tmpltOp = AddrMgr.FindPLCAddressElementByAssociatedKeyAddress(strAddress, AddrMgr.OperationDictionary);
PLCAddressTemplate tmpltData = AddrMgr.FindPLCAddressElementByAssociatedKeyAddress(strAddress, AddrMgr.DataDictionary);
if (tmpltOp != null)
return tmpltOp;
else
return tmpltData;
}
void SetAddress(PLCModMxCMgr module, Dictionary<string, PLCAddressTemplate> addressInfo)
{
foreach (PLCAddressTemplate addrinfo in addressInfo.Values)
{
int nLength = Convert.ToInt32(addrinfo.Length);
int nStartAddr = Convert.ToInt32(addrinfo.Address);
for (int i = 0; i < nLength; i++)
{
int nAddr = nStartAddr + i;
module.AddDevices(addrinfo.Area + nAddr.ToString());
}
}
}
public PLCAddressTemplate UpdateDevice(PLCAddressTemplate tmplt, string strDevice, int nValue)
{
if (tmplt == null)
{
LogMessage.MessageOutput.ConsoleWrite($"Cannot Find a Corresponding Data. Device: {strDevice}");
return null;
}
tmplt.UpdateValue(strDevice, nValue);
return tmplt;
}
public PLCAddressTemplate UpdateDevice(string strDevice)
{
PLCAddressTemplate tmplt = AddrMgr.FindPLCAddressElement(strDevice);
if (tmplt == null)
{
LogMessage.MessageOutput.ConsoleWrite($"Cannot Find a Corresponding Data. Device: {strDevice}");
return null;
}
UpdateValue(tmplt);
return tmplt;
}
void UpdateValue(PLCAddressTemplate tmplt)
{
List<int> vValues = GetReadValues(tmplt);
eDataType eType = (eDataType)Enum.Parse(typeof(eDataType), tmplt.DataType);
string strData = string.Empty;
tmplt.SetAssociatedValues(vValues);
}
public override string ReadDevice(string strDevice, bool bRefineWrongChar = true)
{
PLCAddressTemplate tmplt = UpdateDevice(strDevice);
return (tmplt != null) ? tmplt.Value : string.Empty;
}
public override string ReadDevice(PLCAddressTemplate tmplt)
{
try
{
tmplt = UpdateDevice(tmplt.AddressKey);
return (tmplt != null) ? tmplt.Value : string.Empty;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Manager is failed to Read Device. The Address: {tmplt.AddressKey} has not been read by unidentified errors. ", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
LogMessage.MessageOutput.ConsoleWrite($" - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return string.Empty;
}
}
public override void UpdateAll(bool bRefineWrongChar = false)
{
UpdateArea(AddrMgr.OperationDictionary.Keys.ToList());
UpdateArea(AddrMgr.DataDictionary.Keys.ToList());
}
public virtual void SelectUpdate(PLCAddressTemplate tmplt, bool bRefineWrongChar)
{
}
void UpdateArea(List<string> strKeys)
{
foreach (string strKey in strKeys)
UpdateDevice(strKey);
}
public override bool WriteDevice(PLCAddressTemplate tmplt, string strValue, bool bVerification = false)
{
try
{
tmplt.SetStringValue(strValue);
WriteDevice(tmplt);
if (bVerification)
{
string strReadValue = ReadDevice(tmplt.PLCAddress);
if (strReadValue == strValue)
{
LogMessage.MessageOutput.ConsoleWrite($"The Address: {tmplt.PLCAddress} has not been written #Intent:{strValue} - #Actual:{tmplt.Value} by unidentified errors. ", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
return false;
}
}
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Manager is failed to Write Device. The Address: {tmplt.AddressKey} has not been written by unidentified errors. ", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
LogMessage.MessageOutput.ConsoleWrite($" - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
public void WriteDevice(string strDevice)
{
int nCount = 0;
if (!OperationStarted)
{
while (true)
{
if (OperationStarted || nCount > 100)
break;
nCount++;
Thread.Sleep(100);
}
}
PLCAddressTemplate tmplt = AddrMgr.FindPLCAddressElement(strDevice);
WriteDevice(tmplt);
}
public bool WriteDevice(PLCAddressTemplate tmplt)
{
try
{
int nCount = 0;
if (!OperationStarted)
{
while (true)
{
if (OperationStarted || nCount > 100)
break;
nCount++;
Thread.Sleep(100);
}
}
int nLength = Convert.ToInt32(tmplt.Length);
if (nLength > 1)
WriteBlockDevice(tmplt, nLength, tmplt.RawValue);
else
WriteDeviceSequence(tmplt, nLength, tmplt.RawValue);
//UpdateValue(tmplt, false);
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Manager is failed to Write Device. The Address: {tmplt.AddressKey} has not been written by unidentified errors. ", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
LogMessage.MessageOutput.ConsoleWrite($" - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
bool WriteBlockDevice(PLCAddressTemplate tmplt, int nLength, List<int> vnValues)
{
try
{
string strAddr = tmplt.Area + (Convert.ToInt32(tmplt.Address)).ToString();
bool result = PLCManagers[ePLCRWType.Write].WriteBlockDevice(strAddr, vnValues.Count, vnValues.ToArray());
return result;
/*
if (result)
{
int[] anResult = PLCManagers[ePLCRWType.Read].ReadBlockDevice(strAddr, nLength);
for(int nIdx = 0; nIdx < vnValues.Count; nIdx++)
if (anResult[nIdx] != vnValues[nIdx])
{
LogMessage.MessageOutput.ConsoleWrite($"During: WriteBlockDevice, The Address: {strAddr} + {nIdx} has not been written #Intent:{vnValues[nIdx]} - #Actual:{anResult[nIdx]} by unidentified errors. ", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
return false;
}
}
*/
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"During: WriteBlockDevice, PLC Manager is failed to Write Device. The Address: {tmplt.AddressKey} has not been written by unidentified errors. ", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
LogMessage.MessageOutput.ConsoleWrite($" - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
bool WriteDeviceSequence(PLCAddressTemplate tmplt, int nLength, List<int> vnValues)
{
try
{
for (int i = 0; i < nLength; i++)
{
//LogMessage.MessageOutput.ConsoleWrite($"The Address: {tmplt.AddressKey}. ", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
string strAddr = tmplt.Area + (Convert.ToInt32(tmplt.Address) + i).ToString();
bool result = PLCManagers[ePLCRWType.Write].WriteDevice(strAddr, vnValues[i]);
return result;
/*
if (i >= vnValues.Count)
PLCManagers[ePLCRWType.Write].WriteDevice(strAddr, 0);
else
{
bool result = PLCManagers[ePLCRWType.Write].WriteDevice(strAddr, vnValues[i]);
return result;
if (result)
{
int nResult = PLCManagers[ePLCRWType.Read].ReadDevice(strAddr);
if (nResult != vnValues[i])
{
LogMessage.MessageOutput.ConsoleWrite($"During: WriteDeviceSequence, The Address: {strAddr} has not been written #Intent:{vnValues[i]} - #Actual:{nResult} by unidentified errors. ", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
return false;
}
}
}*/
}
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"During: WriteDeviceSequence, PLC Manager is failed to Write Device. The Address: {tmplt.AddressKey} has not been written by unidentified errors. ", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
LogMessage.MessageOutput.ConsoleWrite($" - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
return true;
}
List<int> GetWriteValues(PLCAddressTemplate tmplt)
{
List<int> vnValues = new List<int>();
int nLength = Convert.ToInt32(tmplt.Length);
eDataType eType = (eDataType)Enum.Parse(typeof(eDataType), tmplt.DataType);
if (eType == eDataType.ASCII)
vnValues = (from value in CommonUtil.HexStringToBytes(tmplt.Value) select Convert.ToInt32(value)).ToList();
else if (eType == eDataType.DECIMAL)
{
int nInputValue = string.IsNullOrWhiteSpace(tmplt.Value) ? 0 : Convert.ToInt32(tmplt.Value);
vnValues.Add(nInputValue);
}
return vnValues;
}
List<int> GetReadValues(PLCAddressTemplate tmplt)
{
List<int> vnValues = new List<int>();
int nLength = Convert.ToInt32(tmplt.Length);
/*
for (int i = 0; i < nLength; i++)
{
int nAddress = Convert.ToInt32(tmplt.Address) + i;
int nValue = PLCManagers[ePLCRWType.Read].ReadDevice(tmplt.Area + nAddress.ToString());
vnValues.Add(nValue);
}
*/
if (nLength > 1)
{
int[] anResult = PLCManagers[ePLCRWType.Read].ReadBlockDevice(tmplt.PLCAddress, nLength);
if (anResult != null)
vnValues = anResult.ToList();
}
else
{
for (int i = 0; i < nLength; i++)
{
int nAddress = Convert.ToInt32(tmplt.Address) + i;
int nValue = PLCManagers[ePLCRWType.Read].ReadDevice(tmplt.Area + nAddress.ToString());
vnValues.Add(nValue);
}
}
return vnValues;
}
}
}

157
SystemX.Net.CP.Platform/SystemX.PLC/Interface/McProtocol/PLCDeviceMXC.cs Normal file
View File

@ -0,0 +1,157 @@
using Dsu.PLC;
using Dsu.PLC.Common;
using Dsu.PLC.Melsec;
using System;
using System.Diagnostics;
using System.Linq;
using System.Reactive.Linq;
using System.Reflection;
using System.Threading.Tasks;
using SystemX.Net.Platform.Common.Event;
using SystemX.Net.Platform.Common.Util;
namespace SystemX.PLC.Interface.McProtocol
{
public class PLCDeviceMXC
{
public FunctionEventHandler FuncEvtHndl { get; set; }
public string CPU_TYPE_STR { set; get; } //Example: "Q03UDECPU";
public string PLC_IP_ADDR { set; get; }
public int PLC_PORT_NUMBER { set; get; }
public string CONNECTION_TYPE_STR { set; get; }
public int TIMEOUT { set; get; }
public bool READPORT { set; get; }
public string DeviceID { set; get; }
private MxConnection _conn; // Read port UDP Write port TCP
public bool DevClose()
{
return _conn.Disconnect();
}
public bool DevOpen()
{
try
{
TransportProtocol ConType = CONNECTION_TYPE_STR.ToUpper() == "TCP" ? TransportProtocol.Tcp : TransportProtocol.Udp;
_conn = new MxConnection(new MxConnectionParameters(PLC_IP_ADDR, Convert.ToUInt16(PLC_PORT_NUMBER), ConType));
return _conn.Connect();
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite(ex.Message, ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
public bool AddDevices(string deviceNames)
{
_conn.CreateTag(deviceNames);
return true;
}
public async Task SingleScanStartAsync()
{
if (_conn.Tags.Count == 0)
return;
int readCount = 0;
_conn.PerRequestDelay = TIMEOUT;
_conn.Subject.OfType<TagValueChangedEvent>().Subscribe(evt =>
{
readCount++;
EventTag((MxTag)evt.Tag);
});
_conn.StartDataExchangeLoopAsync(); // Do not use await
// _conn.Disconnect();
Stopwatch xSW = new Stopwatch();
xSW.Start();
bool bSuccess = true;
while (true)
{
if (_conn.Tags.Count <= readCount)
break;
else
System.Threading.Thread.Sleep(50);
if (xSW.ElapsedMilliseconds > 5000)
{
bSuccess = false;
break;
}
}
if (!bSuccess)
{
LogMessage.MessageOutput.ConsoleWrite("Trouble in Single Scan Start Async", ConsoleColor.White, LogMessage.LogMessageLevel.FATAL);
//await SingleScanStartAsync();
}
}
private void EventTag(MxTag tag)
{
if (tag.IsBitDevice)
FuncEvtHndl.DoReceive(this, tag.Name + ";" + (Convert.ToBoolean(tag.Value) ? 1 : 0).ToString());
else
FuncEvtHndl.DoReceive(this, tag.Name + ";" + tag.Value.ToString());
}
public bool WriteBitDevice(string strDeviceWrite, int[] value)
{
//Console.WriteLine(string.Format("{0} : {1}", strDeviceWrite, value[0]));
return _conn.McProtocol.SetBitDevice(strDeviceWrite, 1, value) == 0;
}
public bool WriteDevice(string strDeviceWrite, int value)
{
//Console.WriteLine(string.Format("{0} : {1}", strDeviceWrite, value));
return _conn.McProtocol.SetDevice(strDeviceWrite, Convert.ToInt32(value)) == 0;
}
public bool WriteBlockDevice(string strDeviceWrite, int nLength, int[] nValues)
{
//Console.WriteLine(string.Format("{0} : {1}", strDeviceWrite, value));
return _conn.McProtocol.WriteDeviceBlock(strDeviceWrite, nLength, nValues) == 0;
}
public int ReadDevice(string strDeviceRead)
{
int value;
_conn.McProtocol.GetDevice(strDeviceRead, out value);
return value;
}
public int[] ReadBlockDevice(string strDeviceRead, int nLength)
{
try
{
int[] anvalue = new int[nLength];
int nResult = _conn.McProtocol.ReadDeviceBlock(strDeviceRead, nLength, anvalue);
return anvalue;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"Trouble in McComponent during ReadBlockDevice:{strDeviceRead} - {nLength}", ConsoleColor.White, LogMessage.LogMessageLevel.FATAL);
LogMessage.MessageOutput.ConsoleWrite($"\t- Error Message {ex.Message}", ConsoleColor.White, LogMessage.LogMessageLevel.FATAL);
return new int[1];
}
}
public string GetModuleName()
{
return Assembly.GetExecutingAssembly().ManifestModule.Name.Replace(".dll", string.Empty);
}
}
}

199
SystemX.Net.CP.Platform/SystemX.PLC/Interface/McProtocol/PLCModMxCMgr.cs Normal file
View File

@ -0,0 +1,199 @@
using System;
using System.Threading.Tasks;
using System.Net.NetworkInformation;
using System.Threading;
using SystemX.Net.Platform.Common.Event;
using SystemX.Net.Platform.Common.Util;
using static SystemX.PLC.Interface.PLCCommDefinition;
namespace SystemX.PLC.Interface.McProtocol
{
public class PLCModMxCMgr
{
public event EventPLCHandler EventPLC;
public FunctionEventHandler EventAlwaysUpdate { get; set; }
public FunctionEventHandler EventChangeUpdate { get; set; }
public PLCDeviceMXC plcDev;
PLCConnectionInfo PLCInfo;
public string CPU_TYPE_STR { set; get; } //Example: "Q03UDECPU";
public string PLC_IP_ADDR { set; get; }
public int PLC_PORT_NUMBER { set; get; }
public string CONNECTION_TYPE_STR { set; get; }
public int TIMEOUT { set; get; }
public bool IsOpened { get; set; } = false;
public PLCModMxCMgr(PLCConnectionInfo infoinput)
{
PLCInfo = infoinput;
}
public bool CloseDevice()
{
bool bResult = plcDev.DevClose();
IsOpened = !bResult;
return true;
}
public bool OpenDevice()
{
if (IsOpened == true)
return IsOpened;
plcDev = new PLCDeviceMXC();
EventChangeUpdate = new FunctionEventHandler();
plcDev.FuncEvtHndl = EventChangeUpdate;
plcDev.DeviceID = PLCInfo.Name;
plcDev.CPU_TYPE_STR = PLCInfo.CPUType;
plcDev.PLC_IP_ADDR = PLCInfo.IP;
plcDev.PLC_PORT_NUMBER = Convert.ToInt32(PLCInfo.Port);
plcDev.CONNECTION_TYPE_STR = PLCInfo.ConnectionType != "UDP" ? "TCP" : "UDP";
plcDev.READPORT = (PLCInfo.RWType == PLCCommDefinition.ePLCRWType.Read.ToString()) ? true : false;
plcDev.TIMEOUT = Convert.ToInt32(PLCInfo.Timeout);
EventChangeUpdate.OnReceive += FuncEvtHndl_OnPLCReceive;
Task<bool> conPing = new Task<bool>(() => PingToPLC());
conPing.Start();
Task<bool> conPLC = conPing.ContinueWith(x => ConnectToPLC());
return true;
}
public bool PingToPLC()
{
try
{
Ping pingtoPLC = new Ping();
int nCount = 0;
while (true)
{
PingReply reply = pingtoPLC.Send(plcDev.PLC_IP_ADDR);
if (reply.Status == IPStatus.Success)
break;
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Failed. Retry #{nCount} - IP:{plcDev.PLC_IP_ADDR}, Port:{plcDev.PLC_PORT_NUMBER}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
Thread.Sleep(1000);
nCount++;
}
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($" - PLC Connection error: {PLCInfo.Name}, {PLCInfo.IP}:{PLCInfo.Port} - {PLCInfo.ConnectionType}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
LogMessage.MessageOutput.ConsoleWrite($" -> Reason: {ex.Message}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
throw;
}
}
public bool ConnectToPLC()
{
try
{
IsOpened = plcDev.DevOpen();
if (IsOpened == false)
plcDev = null;
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Success. - IP:{plcDev.PLC_IP_ADDR}, Port:{plcDev.PLC_PORT_NUMBER} ", ConsoleColor.Green, LogMessage.LogMessageLevel.NONE);
return IsOpened;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($" - PLC Connection error: {PLCInfo.Name}, {PLCInfo.IP}:{PLCInfo.Port} - {PLCInfo.ConnectionType}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
LogMessage.MessageOutput.ConsoleWrite($" -> Reason: {ex.Message}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
throw;
}
}
private void FuncEvtHndl_OnPLCReceive(object sender, object objdata)
{
string data = objdata as string;
if (data == null)
return;
if (data.Contains(";"))
{
string address = data.Split(';')[0];
int value = Convert.ToInt32(data.Split(';')[1]);
EventPLC?.Invoke(address, value);
}
}
public async Task SingleScanStartAsync()
{
if (!IsOpened) return;
await plcDev.SingleScanStartAsync();
}
public bool AddDevices(string deviceNames)
{
if (!IsOpened) return false;
return plcDev.AddDevices(deviceNames);
}
public int ReadDevice(string deviceName)
{
try
{
if (!IsOpened) return -1;
return plcDev.ReadDevice(deviceName);
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Device Reading Error in PLCModMxCMgr: {deviceName}", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
LogMessage.MessageOutput.ConsoleWrite($" - Detail: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
throw;
}
}
public int[] ReadBlockDevice(string deviceName, int nLength)
{
try
{
if (!IsOpened) return null;
return plcDev.ReadBlockDevice(deviceName, nLength);
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Device Reading Error in PLCModMxCMgr: {deviceName}", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
LogMessage.MessageOutput.ConsoleWrite($" - Detail: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
throw;
}
}
public bool WriteDevice(string deviceName, int value)
{
if (!IsOpened) return false;
return plcDev.WriteDevice(deviceName, value);
}
public bool WriteBlockDevice(string deviceName, int nLength, int[] aValues)
{
if (!IsOpened) return false;
return plcDev.WriteBlockDevice(deviceName, nLength, aValues);
}
public bool WriteBitDevice(string deviceName, int[] value)
{
if (!IsOpened) return false;
return plcDev.WriteBitDevice(deviceName, value);
}
}
}

420
SystemX.Net.CP.Platform/SystemX.PLC/Interface/MxComponent/PLCCommMxCMgr.cs Normal file
View File

@ -0,0 +1,420 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using SystemX.Net.Platform.Common.Event;
using SystemX.Net.Platform.Common.Util;
using static SystemX.PLC.Interface.PLCCommDefinition;
namespace SystemX.PLC.Interface.MxComponent
{
public class PLCCommMxCMgr : PLCCommManager
{
private int TimeOut;
public Dictionary<ePLCRWType, PLCModMxCMgr> PLCManagers { get; set; } = new Dictionary<ePLCRWType, PLCModMxCMgr>();
public FunctionEventHandler EventAlwaysUpdate { get; set; }
public PLCCommMxCMgr(string strPLCConnInfoXmlPath) : base(strPLCConnInfoXmlPath)
{
AddrMgr = new PLCAddressManager(strPLCConnInfoXmlPath);
EventAlwaysUpdate = new FunctionEventHandler();
EventChangeUpdate = new FunctionEventHandler();
TimeOut = 0;
foreach (PLCConnectionInfo coninfo in AddrMgr.ConnInfoDictionary.Values)
{
if (TimeOut < int.Parse(coninfo.Timeout))
TimeOut = int.Parse(coninfo.Timeout);
PLCManagers.Add((ePLCRWType)Enum.Parse(typeof(ePLCRWType), coninfo.RWType), new PLCModMxCMgr(coninfo, EventAlwaysUpdate, EventChangeUpdate));
}
}
public override bool OpenPLCConnection()
{
Task<bool> openconn = new Task<bool>(() => TryOpenPLCConnection());
openconn.Start();
bool bResult = openconn.Result;
if (bResult)
{
//Task plcoperation = openconn.ContinueWith(x => StartPLCOperation());
Task<bool> plcoperation = new Task<bool>(() => StartPLCOperation());
plcoperation.Start();
bResult = plcoperation.Result;
}
return bResult;
/*
if (plcoperation.Wait(TimeOut))
return true;
else
return false;
*/
}
public bool TryOpenPLCConnection()
{
try
{
foreach (PLCModMxCMgr conmgr in PLCManagers.Values)
{
if (!conmgr.OpenDevice())
return false;
Stopwatch stTimeOut = new Stopwatch();
stTimeOut.Start();
while (true)
{
if (conmgr.IsOpened == true)
break;
if (stTimeOut.ElapsedMilliseconds >= TimeOut)
{
LogMessage.MessageOutput.ConsoleWrite("PLC Connection Waiting TimeOut.", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
Thread.Sleep(50);
}
SetAddress(conmgr, AddrMgr.OperationDictionary, true);
SetAddress(conmgr, AddrMgr.DataDictionary, false);
}
LogMessage.MessageOutput.ConsoleWrite("PLC Connection Waiting for Success.", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Open Error.\n - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
private bool findType(ePLCRWType type)
{
var findValue = PLCManagers.FirstOrDefault(t => t.Key == type);
if (findValue.Value != null)
return true;
else
return false;
}
private PLCModMxCMgr findMgr(ePLCRWType type)
{
var findValue = PLCManagers.FirstOrDefault(t => t.Key == type);
if (findValue.Value != null)
return findValue.Value;
else
return null;
}
public override bool StartPLCOperation()
{
try
{
OperationStarted = true;
if(findType(ePLCRWType.Read))
{
findMgr(ePLCRWType.Read).SingleScanStartAsync();
findMgr(ePLCRWType.Read).StartMonitor();
}
if (findType(ePLCRWType.ReadWrite))
{
findMgr(ePLCRWType.ReadWrite).SingleScanStartAsync();
findMgr(ePLCRWType.ReadWrite).StartMonitor();
}
LogMessage.MessageOutput.ConsoleWrite("PLC Operation has been Started.", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Open Error.\n - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
public override void NowScanDataArea()
{
if (findType(ePLCRWType.Read))
findMgr(ePLCRWType.Read).NowScanDataArea();
if (findType(ePLCRWType.ReadWrite))
findMgr(ePLCRWType.ReadWrite).NowScanDataArea();
}
public override bool StopPLCOperation()
{
try
{
OperationStarted = false;
if (findType(ePLCRWType.Read))
findMgr(ePLCRWType.Read).StopMonitor();
if (findType(ePLCRWType.ReadWrite))
findMgr(ePLCRWType.ReadWrite).StopMonitor();
LogMessage.MessageOutput.ConsoleWrite("PLC Operation has been Stopped.", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Open Error.\n - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
public override bool ClosePLCConnection()
{
try
{
foreach (PLCModMxCMgr conmgr in PLCManagers.Values)
conmgr.CloseDevice();
OperationStarted = false;
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Close Error.\n - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
public void ReceivePLCEvent(PLCModMxCMgr sender, PLCAddressTemplate template)
{
if (template == null)
return;
if (IsMySubscription(template))
{
ReceivePLCEvent(template.Address, template.RawValue[0]);
}
}
public override void ReceivePLCEvent(string address, int value)
{
}
public bool IsMySubscription(PLCAddressTemplate template)
{
if (AddrMgr.OperationDictionary.ContainsValue(template))
return true;
if (AddrMgr.DataDictionary.ContainsValue(template))
return true;
return false;
}
void SetAddress(PLCModMxCMgr module, Dictionary<string, PLCAddressTemplate> addressInfo, bool bOperation)
{
foreach (PLCAddressTemplate addrinfo in addressInfo.Values)
module.AddDevices(addrinfo, bOperation);
}
public override void UpdateAll(bool bRefineWrongChar)
{
foreach (PLCModMxCMgr conmgr in PLCManagers.Values)
{
conmgr.UpdateArea(AddrMgr.OperationDictionary.Values.ToList(), bRefineWrongChar);
conmgr.UpdateArea(AddrMgr.DataDictionary.Values.ToList(), bRefineWrongChar);
}
}
public override void SelectUpdate(ePLCAreaType pat, PLCAddressTemplate tmplt, bool bRefineWrongChar)
{
if (pat == ePLCAreaType.Operation)
{
foreach (PLCModMxCMgr conmgr in PLCManagers.Values)
{
conmgr.UpdateSelectArea(tmplt, bRefineWrongChar);
//conmgr.UpdateArea(AddrMgr.DataDictionary.Values.ToList(), bRefineWrongChar);
}
}
if (pat == ePLCAreaType.Data)
{
foreach (PLCModMxCMgr conmgr in PLCManagers.Values)
{
//conmgr.UpdateArea(AddrMgr.OperationDictionary.Values.ToList(), bRefineWrongChar);
conmgr.UpdateSelectArea(tmplt, bRefineWrongChar);
}
}
}
public override string GetDeviceValue(PLCAddressTemplate tmplt)
{
try
{
if (!CheckConnectionState(tmplt))
return string.Empty;
string strReadValue = "";
if (findType(ePLCRWType.Read))
strReadValue = findMgr(ePLCRWType.Read).GetDeviceValue(tmplt);
else if (findType(ePLCRWType.ReadWrite))
strReadValue = findMgr(ePLCRWType.ReadWrite).GetDeviceValue(tmplt);
return strReadValue;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Manager is failed to Get Device Value. The Address: {tmplt.AddressKey} has not been read by unidentified errors. ", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
LogMessage.MessageOutput.ConsoleWrite($" - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return string.Empty;
}
}
public override string ReadDevice(PLCAddressTemplate tmplt)
{
try
{
if (!CheckConnectionState(tmplt))
return string.Empty;
string strReadValue = "";
if (findType(ePLCRWType.Read))
strReadValue = findMgr(ePLCRWType.Read).ReadDevice(tmplt);
else if (findType(ePLCRWType.ReadWrite))
strReadValue = findMgr(ePLCRWType.ReadWrite).ReadDevice(tmplt);
return strReadValue;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Manager is failed to Read Device. The Address: {tmplt.AddressKey} has not been read by unidentified errors. ", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
LogMessage.MessageOutput.ConsoleWrite($" - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return string.Empty;
}
}
public override string ReadDevice(PLCAddressTemplate tmplt, bool bAsciiReverse = false)
{
try
{
if (!CheckConnectionState(tmplt))
return string.Empty;
string strReadValue = "";
if (findType(ePLCRWType.Read))
strReadValue = findMgr(ePLCRWType.Read).ReadDevice(tmplt, bAsciiReverse);
else if (findType(ePLCRWType.ReadWrite))
strReadValue = findMgr(ePLCRWType.ReadWrite).ReadDevice(tmplt, bAsciiReverse);
return strReadValue;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Manager is failed to Read Device. The Address: {tmplt.AddressKey} has not been read by unidentified errors. ", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
LogMessage.MessageOutput.ConsoleWrite($" - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return string.Empty;
}
}
public override bool WriteDevice(PLCAddressTemplate tmplt, string strValue, bool bVerification = false)
{
try
{
if (!CheckConnectionState(tmplt))
return false;
if (findType(ePLCRWType.Write))
findMgr(ePLCRWType.Write).WriteDevice(tmplt, strValue);
else if (findType(ePLCRWType.ReadWrite))
findMgr(ePLCRWType.ReadWrite).WriteDevice(tmplt, strValue);
if (bVerification)
{
string strReadValue = "";
if (findType(ePLCRWType.Read))
strReadValue = findMgr(ePLCRWType.Read).ReadDevice(tmplt);
else if (findType(ePLCRWType.ReadWrite))
strReadValue = findMgr(ePLCRWType.ReadWrite).ReadDevice(tmplt);
if (strReadValue == strValue)
{
LogMessage.MessageOutput.ConsoleWrite($"The Address: {tmplt.PLCAddress} has not been written #Intent:{strValue} - #Actual:{tmplt.Value} by unidentified errors. ", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
return false;
}
}
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Manager is failed to Write Device. The Address: {tmplt.AddressKey} has not been written by unidentified errors. ", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
LogMessage.MessageOutput.ConsoleWrite($" - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
bool CheckConnectionState(PLCAddressTemplate tmplt)
{
try
{
int nCount = 0;
bool bConError = false;
if (!OperationStarted)
{
while (true)
{
if (OperationStarted || nCount > 100)
{
bConError = true;
break;
}
nCount++;
Thread.Sleep(100);
}
}
if (bConError == true)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Trouble has been detected. ", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
LogMessage.MessageOutput.ConsoleWrite($"The Address: {tmplt.PLCAddress} has not been written. ", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
return true;
}
catch (Exception)
{
throw;
}
}
}
}

314
SystemX.Net.CP.Platform/SystemX.PLC/Interface/MxComponent/PLCDeviceMXC.cs Normal file
View File

@ -0,0 +1,314 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reactive.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using SystemX.Net.Platform.Common.Event;
using SystemX.Net.Platform.Common.Util;
using static SystemX.PLC.Interface.PLCCommDefinition;
namespace SystemX.PLC.Interface.MxComponent
{
public class PLCDeviceMXC
{
public FunctionEventHandler EventAlwaysUpdate { get; set; }
public FunctionEventHandler EventChangeUpdate { get; set; }
public int STATION_ID { set; get; } //PLC STATION
private int ScanningIntervalOperation = 100;
private int ScanningIntervalDataTime = 500;
private bool MonitorExe = true;
private Stopwatch stReadTimeCheck;
private PLCMxComponent _conn; //MxComponent PLC Instance
Dictionary<string, PLCAddressTemplate> DicOperationAddresses = new Dictionary<string, PLCAddressTemplate>();
Dictionary<string, PLCAddressTemplate> DicDataAddresses = new Dictionary<string, PLCAddressTemplate>();
Stopwatch xSwDiag = new Stopwatch();
private static object objLock = new object();
public PLCDeviceMXC()
{
stReadTimeCheck = new Stopwatch();
stReadTimeCheck.Start();
}
public bool DevClose()
{
if (_conn != null)
{
StopMonitor();
return _conn.Close();
}
return true;
}
public bool DevOpen()
{
try
{
_conn = new PLCMxComponent();
_conn.Initialize();
return _conn.Open(STATION_ID.ToString());
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"Error during PLC Open : {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
public bool AddOperationDevices(PLCAddressTemplate deviceReg)
{
DicOperationAddresses.Add(deviceReg.PLCAddress, deviceReg);
return true;
}
public bool AddDataDevices(PLCAddressTemplate deviceReg)
{
DicDataAddresses.Add(deviceReg.PLCAddress, deviceReg);
return true;
}
public void SingleScanStartAsync()
{
lock (objLock)
{
ScanDataArea();
ScanOperationArea(true);
}
}
public void NowDataAreaScan()
{
lock (objLock)
{
ScanDataArea();
}
}
public void StartMonitor()
{
MonitorExe = true;
Task<int> monitor = new Task<int>(() => ExecuteMonitor().Result);
monitor.Start();
}
public void StopMonitor()
{
MonitorExe = false;
}
private async Task<int> ExecuteMonitor()
{
//int nCountTime = 0;
stReadTimeCheck.Restart();
while (MonitorExe)
{
lock (objLock)
{
ScanOperationArea();
/*
if (stReadTimeCheck.ElapsedMilliseconds >= ScanningIntervalDataTime)
{
ScanDataArea();
stReadTimeCheck.Restart();
}
*/
//
/*
if (nCountTime % ScanningIntervalDataTime == 0)
{
nCountTime = 1;
ScanDataArea();
}
nCountTime++;
*/
}
await Task.Delay(ScanningIntervalOperation);
}
return 0;
}
void ScanDataArea()
{
foreach (PLCAddressTemplate addrTemplate in DicDataAddresses.Values)
UpdateDevice(addrTemplate, true);
}
void ScanOperationArea(bool bSingleScan = false)
{
foreach (PLCAddressTemplate addrTemplate in DicOperationAddresses.Values)
{
string strFormerValue = addrTemplate.Value;
UpdateDevice(addrTemplate, true);
EventAlwaysUpdate.DoReceive(this, addrTemplate);
if (addrTemplate.Value != strFormerValue)
EventChangeUpdate.DoReceive(this, addrTemplate);
if (bSingleScan)
EventChangeUpdate.DoReceive(this, addrTemplate);
}
}
public string GetModuleName()
{
return Assembly.GetExecutingAssembly().ManifestModule.Name.Replace(".dll", string.Empty);
}
Int16[] ReadPLCData(PLCAddressTemplate template)
{
if (_conn == null)
return null;
int nSize = Convert.ToInt32(template.Length);
Int16[] readData = new Int16[nSize];
_conn.BlockReadData(template.PLCAddress, nSize, ref readData);
return readData;
}
bool WritePLCData(PLCAddressTemplate template, Int16[] arnWriteData)
{
if (_conn == null)
return false;
int nSize = Convert.ToInt32(template.Length);
bool ret = _conn.BlockWriteData(template.PLCAddress, nSize, arnWriteData);
if (ret == false)
{
_conn.BlockWriteData(template.PLCAddress, nSize, arnWriteData);
Thread.Sleep(30);
}
Thread.Sleep(30);
//bool ret = PLC_COMM.WriteData(addr, nSize, arnWriteData);
return ret;
}
List<int> GetReadValues(PLCAddressTemplate tmplt)
{
int nLength = Convert.ToInt32(tmplt.Length);
List<int> vnValues = (from value in ReadPLCData(tmplt) let value32 = Convert.ToInt32(value) select value32).ToList();
return vnValues;
}
List<short> GetWriteValues(PLCAddressTemplate tmplt, string strValue)
{
List<short> vnValues = new List<short>();
int nLength = Convert.ToInt32(tmplt.Length);
eDataType eType = (eDataType)Enum.Parse(typeof(eDataType), tmplt.DataType);
if (eType == eDataType.ASCII)
vnValues = (from value in CommonUtil.HexStringToBytes(strValue) select Convert.ToInt16(value)).ToList();
else if (eType == eDataType.DECIMAL)
{
int nInputValue = string.IsNullOrWhiteSpace(strValue) ? 0 : Convert.ToInt16(strValue);
vnValues.Add(Convert.ToInt16(nInputValue));
}
return vnValues;
}
void UpdateValue(PLCAddressTemplate tmplt, bool bRefineWrongChar, bool bAsciiReverseBit = false)
{
List<int> vValues = GetReadValues(tmplt);
eDataType eType = (eDataType)Enum.Parse(typeof(eDataType), tmplt.DataType);
string strData = string.Empty;
if (eType == eDataType.ASCII)
strData = CommonUtil.GetStringFromASCII(vValues.ToArray(), bAsciiReverseBit);
else if (eType == eDataType.BIT)
strData = vValues[0].ToString();
else if (eType == eDataType.DECIMAL)
strData = vValues[0].ToString();
string strResult = bRefineWrongChar ? RefineInvalidChars(strData) : strData;
tmplt.SetStringValue(strResult);
}
string RefineInvalidChars(string strSource)
{
string strReturn = strSource.Trim(InvalidChars);
strReturn = new string((from cCode in strSource.ToCharArray() where (48 <= Convert.ToInt32(cCode) && Convert.ToInt32(cCode) <= 95) select cCode).ToArray());
return strReturn;
}
public string GetDeviceValue(PLCAddressTemplate tmplt)
{
List<PLCAddressTemplate> Oper = DicOperationAddresses.Values.Where(x => x.DataName == tmplt.DataName).ToList();
List<PLCAddressTemplate> Data = DicDataAddresses.Values.Where(x => x.DataName == tmplt.DataName).ToList();
if (Oper.Count > 0)
return Oper.First().Value;
else if (Data.Count > 0)
return Data.First().Value;
else
return string.Empty;
}
public PLCAddressTemplate UpdateDevice(PLCAddressTemplate tmplt, bool bRefineWrongChar, bool bAsciiReverse = false)
{
if (tmplt == null)
{
LogMessage.MessageOutput.ConsoleWrite($"Cannot Find a Corresponding Data.");
return null;
}
UpdateValue(tmplt, bRefineWrongChar, bAsciiReverse);
return tmplt;
}
public bool WriteDevice(PLCAddressTemplate tmplt, string strValue)
{
List<short> vValues = GetWriteValues(tmplt, strValue);
return WritePLCData(tmplt, vValues.ToArray());
}
}
}

228
SystemX.Net.CP.Platform/SystemX.PLC/Interface/MxComponent/PLCModMxCMgr.cs Normal file
View File

@ -0,0 +1,228 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Net.NetworkInformation;
using System.Threading;
using SystemX.Net.Platform.Common.Event;
using SystemX.Net.Platform.Common.Util;
namespace SystemX.PLC.Interface.MxComponent
{
/// <summary>
/// Example to represent how to build a device manager.
/// A Device Manager constructs a device in run-time environment using a defined dll name in the configuration xml.
/// The named dll for a device is bound in run-time environment as well.
/// Device manager is an inherited class from a CpDeviceManagerBase and a corresponding interface.
/// </summary>
public class PLCModMxCMgr
{
public FunctionEventHandler EventAlwaysUpdate { get; set; }
public FunctionEventHandler EventChangeUpdate { get; set; }
public PLCDeviceMXC plcMXCompDev;
public PLCConnectionInfo PLCInfo;
public bool IsOpened { get; set; } = false;
public PLCModMxCMgr(PLCConnectionInfo infoinput, FunctionEventHandler evtHndlAlways, FunctionEventHandler evtHndlChanges)
{
PLCInfo = infoinput;
EventAlwaysUpdate = evtHndlAlways;
EventChangeUpdate = evtHndlChanges;
}
public bool CloseDevice()
{
if (plcMXCompDev == null)
return true;
bool bResult = plcMXCompDev.DevClose();
IsOpened = !bResult;
return true;
}
public bool OpenDevice()
{
if (IsOpened == true)
return IsOpened;
plcMXCompDev = new PLCDeviceMXC();
plcMXCompDev.STATION_ID = Convert.ToInt32(PLCInfo.Port);
plcMXCompDev.EventAlwaysUpdate = EventAlwaysUpdate;
plcMXCompDev.EventChangeUpdate = EventChangeUpdate;
Task<bool> conPing = new Task<bool>(() => PingToPLC());
conPing.Start();
Task<bool> conPLC = conPing.ContinueWith(x => ConnectToPLC());
return true;
}
public bool PingToPLC()
{
try
{
Ping pingtoPLC = new Ping();
int nCount = 0;
while (true)
{
PingReply reply = pingtoPLC.Send(PLCInfo.IP);
if (reply.Status == IPStatus.Success)
break;
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Failed. Retry #{nCount} - IP:{PLCInfo.IP}, Station ID:{PLCInfo.Port}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
Thread.Sleep(1000);
nCount++;
}
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($" - PLC Connection error: {PLCInfo.Name}, {PLCInfo.IP}:{PLCInfo.Port} - {PLCInfo.ConnectionType}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
LogMessage.MessageOutput.ConsoleWrite($" -> Reason: {ex.Message}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
throw;
}
}
public bool ConnectToPLC()
{
try
{
IsOpened = plcMXCompDev.DevOpen();
if (IsOpened == false)
plcMXCompDev = null;
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Success. - IP:{PLCInfo.IP}, Port:{PLCInfo.Port} ", ConsoleColor.Green, LogMessage.LogMessageLevel.NONE);
return IsOpened;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($" - PLC Connection error: {PLCInfo.Name}, {PLCInfo.IP}:{PLCInfo.Port} - {PLCInfo.ConnectionType}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
LogMessage.MessageOutput.ConsoleWrite($" -> Reason: {ex.Message}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
throw;
}
}
public void SingleScanStartAsync()
{
if (!IsOpened) return;
plcMXCompDev.SingleScanStartAsync();
}
public void NowScanDataArea()
{
if (!IsOpened) return;
plcMXCompDev.NowDataAreaScan();
}
public void StartMonitor()
{
plcMXCompDev.StartMonitor();
}
public void StopMonitor()
{
plcMXCompDev.StopMonitor();
}
public bool AddDevices(PLCAddressTemplate deviceReg, bool bOperation)
{
try
{
if (!IsOpened) return false;
if (bOperation)
plcMXCompDev.AddOperationDevices(deviceReg);
else
plcMXCompDev.AddDataDevices(deviceReg);
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($" - PLC Connection AddDevices: {PLCInfo.Name}, {PLCInfo.IP}:{PLCInfo.Port} - {PLCInfo.ConnectionType}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
LogMessage.MessageOutput.ConsoleWrite($" -> Reason: {ex.Message}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
return false;
}
}
public void UpdateArea(List<PLCAddressTemplate> vTemplates, bool bRefineWrongChar)
{
foreach (PLCAddressTemplate keyTemplate in vTemplates)
plcMXCompDev.UpdateDevice(keyTemplate, bRefineWrongChar);
}
public void UpdateSelectArea(PLCAddressTemplate keyTemplate, bool bRefineWrongChar)
{
plcMXCompDev.UpdateDevice(keyTemplate, bRefineWrongChar);
}
public string GetDeviceValue(PLCAddressTemplate tmplt)
{
try
{
if (!IsOpened) return string.Empty;
return plcMXCompDev.GetDeviceValue(tmplt);
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Device Get Value Error: {tmplt.PLCAddress}", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
LogMessage.MessageOutput.ConsoleWrite($" - Detail: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
throw;
}
}
public string ReadDevice(PLCAddressTemplate tmplt, bool bAsciiReverse = false)
{
try
{
if (!IsOpened) return string.Empty;
plcMXCompDev.UpdateDevice(tmplt, true, bAsciiReverse);
return tmplt.Value;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Device Reading Error: {tmplt.PLCAddress}", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
LogMessage.MessageOutput.ConsoleWrite($" - Detail: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
throw;
}
}
public bool WriteDevice(PLCAddressTemplate tmplt, string value)
{
try
{
if (!IsOpened) return false;
return plcMXCompDev.WriteDevice(tmplt, value);
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Device Writting Error: {tmplt.PLCAddress}", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
LogMessage.MessageOutput.ConsoleWrite($" - Detail: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
throw;
}
}
}
}

222
SystemX.Net.CP.Platform/SystemX.PLC/Interface/MxComponent/PLCMxComponent.cs Normal file
View File

@ -0,0 +1,222 @@

using System;
using System.Windows.Forms;
using SystemX.Net.Platform.Common.Util;
using ActUtlTypeLib;
//using MITSUBISHI.Component;
namespace SystemX.PLC.Interface.MxComponent
{
class PLCMxComponent
{
//DotUtlType _DotUtlType;
ActUtlTypeLib.ActUtlType _ActUtlType;
public bool m_IsPlcConnected;
bool m_bLockFin = false;
// Set the read/write timeouts
int m_nReadTimeOut = 500;
int m_nWriteTimeOut = 500;
public PLCMxComponent()
{
}
public void SetTimeOut(int nWriteTimeOut, int nReadTimeOut)
{
m_nReadTimeOut = nReadTimeOut;
m_nWriteTimeOut = nWriteTimeOut;
}
public void Initialize()
{
try
{
_ActUtlType = new ActUtlTypeLib.ActUtlType();
//_DotUtlType = new DotUtlType();
}
catch (Exception ex)
{
Console.WriteLine("Error in Initialization for plc: " + ex.Message);
}
}
public bool Open(string localStationNum)
{
int lRet;
try
{
_ActUtlType.ActLogicalStationNumber = Convert.ToInt32(localStationNum);
//_DotUtlType.ActLogicalStationNumber = Convert.ToInt32(localStationNum);
lRet = _ActUtlType.Open();
//lRet = _DotUtlType.Open();
if (lRet == 0)
{
m_IsPlcConnected = true;
return true;
}
else
{
LogMessage.MessageOutput.ConsoleWrite("Error Open PLC Connection.", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
m_IsPlcConnected = false;
return false;
}
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite("Error during logical station opening: " + ex.Message, ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
public bool Close()
{
try
{
if (m_IsPlcConnected)
{
//_DotUtlType.Close();
_ActUtlType.Close();
}
m_IsPlcConnected = false;
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite("Error during plc close: " + ex.Message, ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
public bool ReadData(string deviceName, int size, ref short[] data)
{
bool ret = false;
int iRet = 0;
try
{
iRet = _ActUtlType.ReadDeviceRandom2(deviceName, size, out data[0]);
//iRet = _DotUtlType.ReadDeviceRandom2(ref deviceName, size, ref data);
if (iRet == 0)
ret = true;
else
ret = false;
}
catch (System.Exception ex)
{
#if DEBUG
MessageBox.Show(ex.ToString());
#endif
ret = false;
}
return ret;
}
public bool BlockReadData(string deviceName, int size, ref short[] data)
{
bool ret = false;
int iRet = 0;
try
{
iRet = _ActUtlType.ReadDeviceBlock2(deviceName, size, out data[0]);
//iRet = _DotUtlType.ReadDeviceBlock2(ref deviceName, size, ref data);
if (iRet == 0)
ret = true;
else
ret = false;
}
catch (System.Exception ex)
{
#if DEBUG
MessageBox.Show(ex.ToString());
#endif
ret = false;
}
return ret;
}
public bool WriteData(string deviceName, int size, short[] data)
{
bool ret = false;
int iRet = 0;
try
{
iRet = _ActUtlType.WriteDeviceRandom2(deviceName, size, data[0]);
//iRet = _DotUtlType.WriteDeviceRandom2(ref deviceName, size, ref data);
if (iRet == 0)
ret = true;
else
ret = false;
}
catch (System.Exception ex)
{
#if DEBUG
MessageBox.Show(ex.ToString());
#endif
ret = false;
}
return ret;
}
public bool BlockWriteData(string deviceName, int size, short[] data)
{
bool ret = false;
int iRet = 0;
try
{
short[] blockValue = new short[size];
Array.Copy(data, blockValue, data.Length);
//Buffer.BlockCopy(data, 0, blockValue, 0, size);
iRet = _ActUtlType.WriteDeviceBlock2(deviceName, size, blockValue[0]);
//iRet = _DotUtlType.WriteDeviceBlock2(ref deviceName, size, blockValue);
if (iRet == 0)
ret = true;
else
ret = false;
}
catch (System.Exception ex)
{
#if DEBUG
MessageBox.Show(ex.ToString());
#endif
ret = false;
}
return ret;
}
public void ReleaseLock()
{
m_bLockFin = false;
}
public bool GetLockState()
{
return m_bLockFin;
}
}
}

250
SystemX.Net.CP.Platform/SystemX.PLC/Interface/PLCAddressManager.cs Normal file
View File

@ -0,0 +1,250 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Xml.Linq;
using SystemX.Net.Platform.Common.Util;
using static SystemX.PLC.Interface.PLCCommDefinition;
using static SystemX.PLC.Model.ModelSetupTemplate;
namespace SystemX.PLC.Interface
{
public class PLCAddressManager
{
public bool AutoConnection { get; set; } = false;
public Dictionary<string, ModelElementData> DescriptionDictionary { get; set; } = new Dictionary<string, ModelElementData>();
public Dictionary<string, PLCAddressTemplate> DataDictionary { get; set; } = new Dictionary<string, PLCAddressTemplate>();
public Dictionary<string, PLCAddressTemplate> OperationDictionary { get; set; } = new Dictionary<string, PLCAddressTemplate>();
public Dictionary<string, PLCConnectionInfo> ConnInfoDictionary { get; set; } = new Dictionary<string, PLCConnectionInfo>();
public PLCAddressManager(string strPath)
{
LoadAddressXML(strPath);
}
public ePLCAreaType AddressSectionCheck(string strName)
{
if (DataDictionary.Values.Where(x => x.DataName == strName).ToList().Count > 0)
return ePLCAreaType.Data;
else if (OperationDictionary.Values.Where(x => x.DataName == strName).ToList().Count > 0)
return ePLCAreaType.Operation;
else
return ePLCAreaType.None;
}
public bool IsDataSectionSignal(string strName)
{
if (DataDictionary.Values.Where(x => x.DataName == strName).ToList().Count > 0)
return true;
else
return false;
}
public bool IsOperationSectionSignal(string strName)
{
if (OperationDictionary.Values.Where(x => x.DataName == strName).ToList().Count > 0)
return true;
else
return false;
}
public PLCAddressTemplate FindDataDicPLCAddressElementByDataName(string strName)
{
List<PLCAddressTemplate> vtmplt = DataDictionary.Values.Where(x => x.DataName == strName).ToList();
List<PLCAddressTemplate> vOpTmplt = OperationDictionary.Values.Where(x => x.DataName == strName).ToList();
vtmplt = vtmplt.Union(vOpTmplt).ToList();
if (vtmplt.Count == 0)
{
LogMessage.MessageOutput.ConsoleWrite($"Cannot Find PLC Address which has a name as : {strName}.", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return null;
}
return vtmplt[0];
}
public PLCAddressTemplate FindOperationPLCAddressElementByDataName(string strName)
{
List<PLCAddressTemplate> vtmplt = OperationDictionary.Values.Where(x => x.DataName == strName).ToList();
if (vtmplt.Count == 0)
{
LogMessage.MessageOutput.ConsoleWrite($"Cannot Find PLC Address which has a name as : {strName}.", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return null;
}
return vtmplt[0];
}
public PLCAddressTemplate FindPLCOperationTemplateElementByPLCDevice(string PLCDevice)
{
List<PLCAddressTemplate> vTemplate = OperationDictionary.Values.Where(x => x.PLCAddress == PLCDevice).ToList();
if (vTemplate.Count <= 0)
return null;
return vTemplate[0];
}
public PLCAddressTemplate FindPLCAddressElement(string strKey)
{
PLCAddressTemplate tmplt = null;
if (DataDictionary.ContainsKey(strKey))
tmplt = DataDictionary[strKey];
else if (OperationDictionary.ContainsKey(strKey))
tmplt = OperationDictionary[strKey];
return tmplt;
}
public PLCAddressTemplate FindPLCAddressElementByDataName(string strDataName)
{
PLCAddressTemplate tmpltDataName = FindDataDicPLCAddressElementByDataName(strDataName);
if (tmpltDataName == null)
tmpltDataName = FindOperationPLCAddressElementByDataName(strDataName);
return tmpltDataName;
}
public PLCAddressTemplate FindPLCAddressElementByAssociatedKeyAddress(string strKeyAddress, Dictionary<string, PLCAddressTemplate> dicResult)
{
List<PLCAddressTemplate> vResults = (from addrTmplt in dicResult.Values where addrTmplt.IsMyAssociation(strKeyAddress) select addrTmplt).ToList();
if (vResults.Count > 0)
return vResults[0];
return null;
}
void LoadAddressXML(string strXmlPath)
{
if (!File.Exists(strXmlPath))
return;
XDocument xDoc = XDocument.Load(strXmlPath);
var xElement = xDoc.Element(PLCCommDefinition.ModelRoot);
if (xElement == null) return;
DescriptionDictionary = new Dictionary<string, ModelElementData>();
DataDictionary = new Dictionary<string, PLCAddressTemplate>();
OperationDictionary = new Dictionary<string, PLCAddressTemplate>();
ConnInfoDictionary = new Dictionary<string, PLCConnectionInfo>();
var xelemDescRoot = xElement.Element(PLCCommDefinition.DescriptionRoot);
var xelemConRoot = xElement.Element(PLCCommDefinition.ConnectionInfoRoot);
var xelemOpRoot = xElement.Element(PLCCommDefinition.OpearationAreaRoot);
var xelemDataRoot = xElement.Element(PLCCommDefinition.DataAreaRoot);
LoadXmlDataForDescTemplate(xelemDescRoot, DescriptionDictionary);
LoadXmlDataForConninfoTemplate(xelemConRoot, ConnInfoDictionary);
LoadXmlDataForDataTemplate(xelemOpRoot, OperationDictionary);
LoadXmlDataForDataTemplate(xelemDataRoot, DataDictionary);
AutoConnection = Convert.ToBoolean(xelemConRoot.Attribute("AutoConnection").Value);
}
void LoadXmlDataForDescTemplate(XElement xElemRoot, Dictionary<string, ModelElementData> dicResult)
{
foreach (XElement elem in xElemRoot.Elements())
{
if (elem.Name != PLCCommDefinition.DescElement)
continue;
string strName = string.Empty;
string strDataType = string.Empty;
string strDesc = string.Empty;
string strValue = elem.Value;
GetDescAttributes(elem, ref strName, ref strDataType, ref strDesc);
dicResult.Add(strName, new ModelElementData() { Name = strName, DataType = strDataType, Desc = strDesc });
}
}
void GetDescAttributes(XElement xElem, ref string strName, ref string strType, ref string strDesc)
{
strName = string.Empty;
strType = string.Empty;
strDesc = string.Empty;
foreach (XAttribute xattrb in xElem.Attributes())
{
if (xattrb.Name == PLCCommDefinition.AttrbName)
strName = xattrb.Value;
else if (xattrb.Name == PLCCommDefinition.AttrbDataType)
strType = xattrb.Value;
else if (xattrb.Name == PLCCommDefinition.AttrbDesc)
strDesc = xattrb.Value;
}
}
void LoadXmlDataForConninfoTemplate(XElement xElemRoot, Dictionary<string, PLCConnectionInfo> dicResult)
{
foreach (XElement elem in xElemRoot.Elements())
{
if (elem.Name != PLCCommDefinition.ConnectionInfoElement)
continue;
Dictionary<string, string> dicValue = new Dictionary<string, string>();
GetAddrAttributes(elem, dicValue);
dicResult.Add(dicValue[PLCCommDefinition.eConnectionElem.Name.ToString()],
new PLCConnectionInfo()
{
Name = dicValue[PLCCommDefinition.eConnectionElem.Name.ToString()],
CPUType = dicValue[PLCCommDefinition.eConnectionElem.CPUType.ToString()],
RWType = dicValue[PLCCommDefinition.eConnectionElem.RWType.ToString()],
IP = dicValue[PLCCommDefinition.eConnectionElem.IP.ToString()],
Port = dicValue[PLCCommDefinition.eConnectionElem.Port.ToString()],
ConnectionType = dicValue[PLCCommDefinition.eConnectionElem.ConnectionType.ToString()],
Timeout = dicValue[PLCCommDefinition.eConnectionElem.Timeout.ToString()]
});
}
}
void LoadXmlDataForDataTemplate(XElement xElemRoot, Dictionary<string, PLCAddressTemplate> dicResult)
{
try
{
foreach (XElement elem in xElemRoot.Elements())
{
if (elem.Name != PLCCommDefinition.AddrElement)
continue;
Dictionary<string, string> dicValue = new Dictionary<string, string>();
GetAddrAttributes(elem, dicValue);
dicResult.Add(dicValue[PLCCommDefinition.AttrbAddrArea] + dicValue[PLCCommDefinition.AttrbAddrAddress],
new PLCAddressTemplate()
{
Area = dicValue[PLCCommDefinition.AttrbAddrArea],
Address = dicValue[PLCCommDefinition.AttrbAddrAddress],
Length = dicValue[PLCCommDefinition.AttrbAddrLength],
DataName = dicValue[PLCCommDefinition.AttrbAddrDataName],
DataType = dicValue[PLCCommDefinition.AttrbAddrDataType],
Operation = dicValue[PLCCommDefinition.AttrbAddrOperation],
Desc = dicValue[PLCCommDefinition.AttrbAddrDesc]
});
dicResult[dicValue[PLCCommDefinition.AttrbAddrArea] + dicValue[PLCCommDefinition.AttrbAddrAddress]].SetAssocationKeys();
}
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"Error occured in LoadXmlDataForDataTemplate. \n - Error Message: {ex.Message}");
}
}
void GetAddrAttributes(XElement xElem, Dictionary<string, string> dicValue)
{
foreach (XAttribute xattrb in xElem.Attributes())
dicValue.Add(xattrb.Name.ToString(), xattrb.Value);
}
}
}

140
SystemX.Net.CP.Platform/SystemX.PLC/Interface/PLCAddressTemplate.cs Normal file
View File

@ -0,0 +1,140 @@
using System;
using System.Collections.Generic;
using System.Linq;
using SystemX.Net.Platform.Common.Util;
using static SystemX.PLC.Interface.PLCCommDefinition;
namespace SystemX.PLC.Interface
{
public class PLCAddressTemplate
{
public string Area { get; set; } = string.Empty;
public string Address { get; set; } = string.Empty;
public string Length { get; set; } = string.Empty;
public string DataName { get; set; } = string.Empty;
public string DataType { get; set; } = string.Empty;
public string Operation { get; set; } = string.Empty;
public string Desc { get; set; } = string.Empty;
public string AddressKey { get { return Area + Address; } }
List<string> AssociatedAddress { get; set; } = null;
List<int> KeyAddressValues { get; set; } = null;
public string Value
{
get { return RefineInvalidChars(MakeResultValue()); }
}
public List<int> RawValue
{
get { return KeyAddressValues; }
}
public PLCAddressTemplate()
{
}
public void UpdateValue(string strKey, int nValue)
{
int nFindKeyAddrIdx = AssociatedAddress.IndexOf(strKey);
KeyAddressValues[nFindKeyAddrIdx] = nValue;
}
public void SetStringValue(string strValue)
{
List<int> vnValues = new List<int>();
int nLength = Convert.ToInt32(Length);
eDataType eType = (eDataType)Enum.Parse(typeof(eDataType), DataType);
if (eType == eDataType.ASCII)
vnValues = (from value in CommonUtil.HexStringToBytes(strValue) select Convert.ToInt32(value)).ToList();
else if (eType == eDataType.DECIMAL)
{
int nInputValue = string.IsNullOrWhiteSpace(strValue) ? 0 : Convert.ToInt32(strValue);
vnValues.Add(nInputValue);
}
for (int i = 0; i < vnValues.Count; i++)
KeyAddressValues[i] = vnValues[i];
}
public void SetAssociatedValue(int nValue)
{
KeyAddressValues[0] = nValue;
}
public void SetAssociatedValues(List<int> nValues)
{
for (int i = 0; i < nValues.Count; i++)
KeyAddressValues[i] = nValues[i];
}
public void SetAssocationKeys()
{
AssociatedAddress = new List<string>();
KeyAddressValues = new List<int>();
int nLength = Convert.ToInt32(Length);
int nStartAddress = Convert.ToInt32(Address);
for (int i = 0; i < nLength; i++)
{
AssociatedAddress.Add(Area + (nStartAddress + i).ToString());
KeyAddressValues.Add(00);
}
}
public string PLCAddress { get { return Area + Address; } }
public bool IsMyAssociation(string strKey)
{
if (AssociatedAddress == null)
SetAssocationKeys();
if (AssociatedAddress.Contains(strKey))
return true;
return false;
}
string MakeResultValue()
{
eDataType eType = (eDataType)Enum.Parse(typeof(eDataType), DataType);
string strData = string.Empty;
if (eType == eDataType.ASCII)
strData = CommonUtil.GetStringFromASCII(KeyAddressValues.ToArray());
else if (eType == eDataType.BIT)
strData = KeyAddressValues[0].ToString();
else if (eType == eDataType.DECIMAL)
strData = KeyAddressValues[0].ToString();
return strData;
}
public string RefineInvalidChars(string strSource)
{
string strReturn = strSource.Trim(InvalidChars);
strReturn = new string((from cCode in strSource.ToCharArray() where (48 <= Convert.ToInt32(cCode) && Convert.ToInt32(cCode) <= 95) select cCode).ToArray());
return strReturn;
}
}
public class PLCConnectionInfo
{
public string Name { get; set; } = string.Empty;
public string CPUType { get; set; } = string.Empty;
public string RWType { get; set; } = string.Empty;
public string IP { get; set; } = string.Empty;
public string Port { get; set; } = string.Empty;
public string ConnectionType { get; set; } = string.Empty;
public string Timeout { get; set; } = string.Empty;
public PLCConnectionInfo()
{
}
}
}

76
SystemX.Net.CP.Platform/SystemX.PLC/Interface/PLCCommDefinition.cs Normal file
View File

@ -0,0 +1,76 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.PLC.Interface
{
public static class PLCCommDefinition
{
public delegate void EventPLCHandler(string address, int value);
public static string ModelRoot = "PLCAddress";
public static string DescriptionRoot = "Description";
public static string OpearationAreaRoot = "OpearationArea";
public static string DataAreaRoot = "DataArea";
public static string ConnectionInfoRoot = "ConnectionInfo";
public static char[] InvalidChars = new [] { '\\', '\n', '\r', '@', '#', '$', '%', '^', '&',
'*', '!', '(', ')', '┌', ''};
#region Description Attributes
public static string DescElement = "Element";
public static string AttrbName = "Name";
public static string AttrbDataType = "DataType";
public static string AttrbDesc = "Desc";
#endregion
#region ConnectionInfo Attributes
public static string ConnectionInfoElement = "ConnectionDef";
public enum eConnectionElem
{
Name ,
CPUType ,
RWType,
IP ,
Port ,
ConnectionType,
Timeout
}
#endregion
#region PLC Address Attributes
public static string AddrElement = "AddressElement";
public static string AttrbAddrArea = "Area";
public static string AttrbAddrAddress = "Address";
public static string AttrbAddrLength = "Length";
public static string AttrbAddrDataName = "DataName";
public static string AttrbAddrDataType = "DataType";
public static string AttrbAddrOperation = "Operation";
public static string AttrbAddrDesc = "Desc";
#endregion
public enum ePLCRWType
{
Read,
Write,
ReadWrite
}
public enum eDataType
{
ASCII,
DECIMAL,
BIT
}
public enum ePLCAreaType
{
None,
Operation,
Data
}
}
}

81
SystemX.Net.CP.Platform/SystemX.PLC/Interface/PLCCommManager.cs Normal file
View File

@ -0,0 +1,81 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using SystemX.Net.Platform.Common.Event;
using SystemX.Net.Platform.Common.Util;
using SystemX.PLC.Interface;
using static SystemX.PLC.Interface.PLCCommDefinition;
namespace SystemX.PLC.Interface
{
public class PLCCommManager
{
public PLCAddressManager AddrMgr { get; set; }
public FunctionEventHandler EventChangeUpdate { get; set; }
public bool OperationStarted { get; set; } = false;
public PLCCommManager(string strPLCConnInfoXmlPath)
{
}
public virtual bool OpenPLCConnection()
{
return false;
}
public virtual bool StartPLCOperation()
{
return false;
}
public virtual void NowScanDataArea()
{
}
public virtual bool StopPLCOperation()
{
return false;
}
public virtual bool ClosePLCConnection()
{
return false;
}
public virtual void ReceivePLCEvent(string address, int value)
{
}
public virtual string GetDeviceValue(PLCAddressTemplate tmplt)
{
return string.Empty;
}
public virtual string ReadDevice(string strDevice, bool bRefineWrongChar = true)
{
return string.Empty;
}
public virtual string ReadDevice(PLCAddressTemplate tmplt)
{
return string.Empty;
}
public virtual string ReadDevice(PLCAddressTemplate tmplt, bool bAsciiReverse = false)
{
return string.Empty;
}
public virtual void UpdateAll(bool bRefineWrongChar)
{
}
public virtual void SelectUpdate(ePLCAreaType pat, PLCAddressTemplate tmplt, bool bRefineWrongChar)
{
}
public virtual bool WriteDevice(PLCAddressTemplate tmplt, string strValue, bool bVerification = false)
{
return false;
}
}
}

129
SystemX.Net.CP.Platform/SystemX.PLC/Interface/PLCDevice.cs Normal file
View File

@ -0,0 +1,129 @@
using System;
using System.Reflection;
using Dsu.PLC.Melsec;
using Dsu.PLC;
using Dsu.PLC.Common;
using System.Diagnostics;
using System.Threading.Tasks;
using SystemX.Net.Platform.Common.Event;
using SystemX.Net.Platform.Common.Util;
using System.Reactive.Linq;
namespace SystemX.PLC.Interface
{
public class PLCDevice
{
public FunctionEventHandler FuncEvtHndl { get; set; }
public string CPU_TYPE_STR { set; get; } //Example: "Q03UDECPU";
public string PLC_IP_ADDR { set; get; }
public int PLC_PORT_NUMBER { set; get; }
public string CONNECTION_TYPE_STR { set; get; }
public int TIMEOUT { set; get; }
public bool READPORT { set; get; }
public string DeviceID { set; get; }
private MxConnection _conn; // Read port UDP Write port TCP
public bool DevClose()
{
return _conn.Disconnect();
}
public bool DevOpen()
{
try
{
TransportProtocol ConType = CONNECTION_TYPE_STR.ToUpper() == "TCP" ? TransportProtocol.Tcp : TransportProtocol.Udp;
_conn = new MxConnection(new MxConnectionParameters(PLC_IP_ADDR, Convert.ToUInt16(PLC_PORT_NUMBER), ConType));
return _conn.Connect();
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite(ex.Message, ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
public bool AddDevices(string deviceNames)
{
_conn.CreateTag(deviceNames);
return true;
}
public async Task SingleScanStartAsync()
{
if (_conn.Tags.Count == 0)
return;
int readCount = 0;
_conn.PerRequestDelay = TIMEOUT;
_conn.Subject.OfType<TagValueChangedEvent>().Subscribe(evt =>
{
readCount++;
EventTag((MxTag)evt.Tag);
});
_conn.StartDataExchangeLoopAsync(); // Do not use await
// _conn.Disconnect();
Stopwatch xSW = new Stopwatch();
xSW.Start();
bool bSuccess = true;
while (true)
{
if (_conn.Tags.Count <= readCount)
break;
else
System.Threading.Thread.Sleep(50);
if (xSW.ElapsedMilliseconds > 5000)
{
bSuccess = false;
break;
}
}
if (!bSuccess)
{
LogMessage.MessageOutput.ConsoleWrite("Trouble in Single Scan Start Async", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
//await SingleScanStartAsync();
}
}
private void EventTag(MxTag tag)
{
if (tag.IsBitDevice)
FuncEvtHndl.DoReceive(this, tag.Name + ";" + (Convert.ToBoolean(tag.Value) ? 1 : 0).ToString());
else
FuncEvtHndl.DoReceive(this, tag.Name + ";" + tag.Value.ToString());
}
public bool WriteBitDevice(string strDeviceWrite, int[] value)
{
//Console.WriteLine(string.Format("{0} : {1}", strDeviceWrite, value[0]));
return _conn.McProtocol.SetBitDevice(strDeviceWrite, 1, value) == 0;
}
public bool WriteDevice(string strDeviceWrite, int value)
{
//Console.WriteLine(string.Format("{0} : {1}", strDeviceWrite, value));
return _conn.McProtocol.SetDevice(strDeviceWrite, Convert.ToInt32(value)) == 0;
}
public int ReadDevice(string strDeviceRead)
{
int value;
_conn.McProtocol.GetDevice(strDeviceRead, out value);
return value;
}
public string GetModuleName()
{
return Assembly.GetExecutingAssembly().ManifestModule.Name.Replace(".dll", string.Empty);
}
}
}

171
SystemX.Net.CP.Platform/SystemX.PLC/Interface/PLCModMgr.cs Normal file
View File

@ -0,0 +1,171 @@
using System;
using System.Threading.Tasks;
using System.Net.NetworkInformation;
using System.Threading;
using SystemX.Net.Platform.Common.Event;
using SystemX.Net.Platform.Common.Util;
using static SystemX.PLC.Interface.PLCCommDefinition;
namespace SystemX.PLC.Interface
{
/// <summary>
/// Example to represent how to build a device manager.
/// A Device Manager constructs a device in run-time environment using a defined dll name in the configuration xml.
/// The named dll for a device is bound in run-time environment as well.
/// Device manager is an inherited class from a CpDeviceManagerBase and a corresponding interface.
/// </summary>
public class PLCModMgr
{
public event EventPLCHandler EventPLC;
public FunctionEventHandler FuncEvtHndl;
public PLCDevice plcDev;
public PLCConnectionInfo PLCInfo;
public bool IsOpened { get; set; } = false;
public PLCModMgr(PLCConnectionInfo infoinput)
{
PLCInfo = infoinput;
}
public bool CloseDevice()
{
bool bResult = plcDev.DevClose();
IsOpened = !bResult;
return true;
}
public bool OpenDevice()
{
if (IsOpened == true)
return IsOpened;
plcDev = new PLCDevice();
FuncEvtHndl = new FunctionEventHandler();
//FuncEvtHndl.OnReceive += FuncEvtHndl_OnPLCReceive;
plcDev.FuncEvtHndl = FuncEvtHndl;
plcDev.DeviceID = PLCInfo.Name;
plcDev.CPU_TYPE_STR = PLCInfo.CPUType;
plcDev.PLC_IP_ADDR = PLCInfo.IP;
plcDev.PLC_PORT_NUMBER = Convert.ToInt32(PLCInfo.Port);
plcDev.CONNECTION_TYPE_STR = PLCInfo.ConnectionType != "UDP" ? "TCP" : "UDP";
plcDev.READPORT = (PLCInfo.RWType == PLCCommDefinition.ePLCRWType.Read.ToString()) ? true : false;
plcDev.TIMEOUT = Convert.ToInt32(PLCInfo.Timeout);
Task<bool> conPing = new Task<bool>(() => PingToPLC());
conPing.Start();
Task<bool> conPLC = conPing.ContinueWith(x => ConnectToPLC());
return true;
}
public bool PingToPLC()
{
try
{
Ping pingtoPLC = new Ping();
int nCount = 0;
while (true)
{
PingReply reply = pingtoPLC.Send(PLCInfo.IP);
if (reply.Status == IPStatus.Success)
break;
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Failed. Retry #{nCount} - IP:{PLCInfo.IP}, Port:{PLCInfo.Port}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
Thread.Sleep(1000);
nCount++;
}
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($" - PLC Connection error: {PLCInfo.Name}, {PLCInfo.IP}:{PLCInfo.Port} - {PLCInfo.ConnectionType}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
LogMessage.MessageOutput.ConsoleWrite($" -> Reason: {ex.Message}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
throw;
}
}
public bool ConnectToPLC()
{
try
{
IsOpened = plcDev.DevOpen();
if (IsOpened == false)
plcDev = null;
LogMessage.MessageOutput.ConsoleWrite($"PLC Connection Success. - IP:{PLCInfo.IP}, Port:{PLCInfo.Port} ", ConsoleColor.Green, LogMessage.LogMessageLevel.NONE);
return IsOpened;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($" - PLC Connection error: {PLCInfo.Name}, {PLCInfo.IP}:{PLCInfo.Port} - {PLCInfo.ConnectionType}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
LogMessage.MessageOutput.ConsoleWrite($" -> Reason: {ex.Message}", ConsoleColor.Blue, LogMessage.LogMessageLevel.NONE);
throw;
}
}
private void FuncEvtHndl_OnPLCReceive(object sender, string data)
{
if (data.Contains(";"))
{
string address = data.Split(';')[0];
int value = Convert.ToInt32(data.Split(';')[1]);
EventPLC?.Invoke(address, value);
}
}
public async Task SingleScanStartAsync()
{
if (!IsOpened) return;
await plcDev.SingleScanStartAsync();
}
public bool AddDevices(string deviceNames)
{
if (!IsOpened) return false;
return plcDev.AddDevices(deviceNames);
}
public int ReadDevice(string deviceName)
{
try
{
if (!IsOpened) return -1;
return plcDev.ReadDevice(deviceName);
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"PLC Device Reading Error: {deviceName}", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
LogMessage.MessageOutput.ConsoleWrite($" - Detail: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.NONE);
throw;
}
}
public bool WriteDevice(string deviceName, int value)
{
if (!IsOpened) return false;
return plcDev.WriteDevice(deviceName, value);
}
public bool WriteBitDevice(string deviceName, int[] value)
{
if (!IsOpened) return false;
return plcDev.WriteBitDevice(deviceName, value);
}
}
}

210
SystemX.Net.CP.Platform/SystemX.PLC/Model/ModelCtrl.cs Normal file
View File

@ -0,0 +1,210 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using SystemX.Net.Platform.Common.Util;
using static SystemX.PLC.Model.ModelSetupTemplate;
namespace SystemX.PLC.Model
{
public class ModelCtrl
{
public Dictionary<string, ModelSetupTemplate> ModelDataResult { get; set; } = null;
public ModelSetupTemplate ModelTmpStd { get; set; }
public DataTable TemplateTable { get; set; } = null;
public DataTable ModelTable { get; set; } = null;
public string ModelPath { get; set; }
public ModelCtrl(string strModelTmpPath, string strModelPath)
{
ModelTmpStd = new ModelSetupTemplate(strModelTmpPath);
TemplateTable = CreateDescDataTable(ModelTmpStd);
ModelTable = OpenModelData(strModelPath);
ModelPath = strModelPath;
}
#region Initialization
DataTable OpenModelData(string strModelPath)
{
DataTable dtSetup = new DataTable();
List<string> vReadData = null;
CreateDTTemplate(dtSetup, ModelTmpStd);
if (File.Exists(strModelPath))
vReadData = OpenModelFile(strModelPath);
ModelDataResult = ReadModelData(vReadData, ModelTmpStd);
CreateModelDatatable(dtSetup, ModelDataResult);
return dtSetup;
}
DataTable CreateDescDataTable(ModelSetupTemplate model_tmpstd)
{
DataTable dtSetup = new DataTable();
dtSetup.Columns.Add(ModelTemplateDefinition.DescTableName);
dtSetup.Columns.Add(ModelTemplateDefinition.DescTableValue);
foreach (string strKey in model_tmpstd.ModelDescriptionDictionary.Keys)
{
DataRow dtRow = dtSetup.NewRow();
dtRow[ModelTemplateDefinition.DescTableName] = model_tmpstd.ModelDescriptionDictionary[strKey].Name;
dtRow[ModelTemplateDefinition.DescTableValue] = model_tmpstd.ModelDescriptionDictionary[strKey].Desc;
dtSetup.Rows.Add(dtRow);
}
return dtSetup;
}
void CreateDTTemplate(DataTable dtResult, ModelSetupTemplate model_tmpstd)
{
foreach (string strKey in model_tmpstd.ModelDataDictionary.Keys)
{
DataRow dtRow = dtResult.NewRow();
Type typeTarget = CommonUtil.GetType(model_tmpstd.ModelDataDictionary[strKey].DataType);
if (typeTarget == null) return;
dtResult.Columns.Add(model_tmpstd.ModelDataDictionary[strKey].Name, typeTarget, model_tmpstd.ModelDataDictionary[strKey].Desc);
if (model_tmpstd.ModelDataDictionary[strKey].IsIDKey)
dtResult.Columns[model_tmpstd.ModelDataDictionary[strKey].Name].Unique = true;
}
}
void CreateModelDatatable(DataTable dtResult, Dictionary<string, ModelSetupTemplate> vModelData)
{
try
{
if (vModelData == null)
return;
foreach (ModelSetupTemplate vModel in vModelData.Values)
{
DataRow dtRow = dtResult.NewRow();
foreach (string strKey in vModel.ModelDataDictionary.Keys)
{
ModelElementData elemData = vModel.ModelDataDictionary[strKey];
object objValue = elemData.RValue;
if (objValue == null)
continue;
dtRow[strKey] = objValue;
}
dtResult.Rows.Add(dtRow);
}
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"Error in CreateModelDatatable. Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
}
}
public void UpdateModelDataTable()
{
ModelTable.Clear();
CreateModelDatatable(ModelTable, ModelDataResult);
}
Dictionary<string, ModelSetupTemplate> ReadModelData(List<string> vstrModel, ModelSetupTemplate model_tmpstd)
{
if (vstrModel == null || vstrModel.Count <= 0)
return null;
Dictionary<string, ModelSetupTemplate> dicResultModel = new Dictionary<string, ModelSetupTemplate>();
List<string> vstrColumn = vstrModel[0].Split(ModelTemplateDefinition.ModelFileDelimiter.ToCharArray()).Where(x => x != string.Empty).ToList();
vstrModel.RemoveAt(0);
try
{
foreach (string strModel in vstrModel)
{
List<string> vstrModelLine = strModel.Split(ModelTemplateDefinition.ModelFileDelimiter.ToCharArray()).ToList();
ModelSetupTemplate modelstr = model_tmpstd.GetNewModelStructure();
if (!CreateModelData(vstrColumn, vstrModelLine, modelstr))
continue;
dicResultModel.Add(modelstr.GetPrimaryKey().Value, modelstr);
}
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"Error occured in ModelCtrl.ReadModelData. Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
}
return dicResultModel;
}
bool CreateModelData(List<string> vstrColumn, List<string> vstrModelLine, ModelSetupTemplate modelstr)
{
string strColumnName = string.Empty;
try
{
for (int i = 0; i < vstrColumn.Count; i++)
{
strColumnName = vstrColumn[i];
modelstr.ModelDataDictionary[strColumnName].Value = vstrModelLine[i];
}
return true;
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite("Error to find a column or a value. Column Name: " + strColumnName + "\n - Error Message: " + ex.Message, ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
return false;
}
}
List<string> OpenModelFile(string strPath)
{
List<string> vstrData = new List<string>();
//IntPtr safeADSHandle = NativeMethods.CreateFile(strPath, FileAccess.Read, FileShare.Read, IntPtr.Zero, FileMode.Open, FileAttributes.Normal, IntPtr.Zero);
FileStream fs = new FileStream(strPath, FileMode.Open, FileAccess.Read);
StreamReader sr = new StreamReader(fs);
while (!sr.EndOfStream)
vstrData.Add(sr.ReadLine());
sr.Close();
fs.Close();
return vstrData;
}
#endregion
public ModelSetupTemplate FindElement(string strKey)
{
return ModelDataResult[strKey];
}
public void SaveModel(string strPath)
{
string strSavePath = string.IsNullOrEmpty(strPath) ? ModelPath : strPath;
//IntPtr safeADSHandle = NativeMethods.CreateFile(strSavePath, FileAccess.Read, FileShare.Read, IntPtr.Zero, FileMode.Open, FileAttributes.Normal, IntPtr.Zero);
FileStream fs = new FileStream(strSavePath, FileMode.Truncate, FileAccess.ReadWrite);
StreamWriter sr = new StreamWriter(fs);
sr.WriteLine(ModelTmpStd.GetSaveModelColName());
foreach (ModelSetupTemplate model in ModelDataResult.Values)
{
string strLine = model.GetSaveModelValue();
sr.WriteLine(strLine);
}
sr.Close();
fs.Close();
}
}
}

218
SystemX.Net.CP.Platform/SystemX.PLC/Model/ModelSetupTemplate.cs Normal file
View File

@ -0,0 +1,218 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Xml.Linq;
using SystemX.Net.Platform.Common.Util;
namespace SystemX.PLC.Model
{
public class ModelSetupTemplate
{
public class ModelElementData
{
public ModelElementData() { }
public ModelElementData(ModelElementData model)
{
Name = model.Name;
DataType = model.DataType;
Desc = model.Desc;
Value = model.Value;
IsIDKey = model.IsIDKey;
ChangeType();
}
string InternalValue { get; set; } = string.Empty;
public string Name { get; set; } = string.Empty;
public string DataType { get; set; } = string.Empty;
public string Desc { get; set; } = string.Empty;
public string Value
{
get { return InternalValue; }
set
{
string strChangineValue = value;
Type tResult = CommonUtil.GetType(DataType);
if (tResult == typeof(System.Boolean) && !string.IsNullOrWhiteSpace(Value))
{
int nValue = strChangineValue == true.ToString() ? 1 : 0;
InternalValue = nValue.ToString();
}
else
InternalValue = strChangineValue;
}
}
public object RValue { get { ChangeType(); return objConvertedValue; } }
object objConvertedValue = null;
public bool IsIDKey { get; set; } = false;
void ChangeType()
{
try
{
Type tResult = CommonUtil.GetType(DataType);
string strChangineValue = Value;
if (string.IsNullOrEmpty(strChangineValue) && tResult != typeof(System.Boolean))
return;
if (tResult == typeof(System.Boolean))
{
if (!string.IsNullOrWhiteSpace(Value))
{
bool bValue = false;
int nValue = 0;
if (Boolean.TryParse(Value, out bValue))
strChangineValue = bValue.ToString();
else if (Int32.TryParse(Value, out nValue))
strChangineValue = nValue == 0 ? false.ToString() : true.ToString();
}
else
strChangineValue = false.ToString();
}
objConvertedValue = Convert.ChangeType(strChangineValue, tResult);
}
catch (Exception ex)
{
LogMessage.MessageOutput.ConsoleWrite($"Converting Error on <{Name}>, Value: {Value}. \n - Error Message: {ex.Message}", ConsoleColor.Red, LogMessage.LogMessageLevel.FATAL);
}
}
}
public Dictionary<string, ModelElementData> ModelDescriptionDictionary { get; set; }
public Dictionary<string, ModelElementData> ModelDataDictionary { get; set; }
public ModelSetupTemplate(ModelSetupTemplate model)
{
ModelDescriptionDictionary = CloneDictionary(model.ModelDescriptionDictionary);
ModelDataDictionary = CloneDictionary(model.ModelDataDictionary);
}
public ModelSetupTemplate(string strTemplatePath)
{
ModelDescriptionDictionary = new Dictionary<string, ModelElementData>();
ModelDataDictionary = new Dictionary<string, ModelElementData>();
LoadXmlConfig(strTemplatePath);
}
public ModelElementData GetPrimaryKey()
{
List<ModelElementData> vModelelemdata = ModelDataDictionary.Values.Where(x => x.IsIDKey == true).ToList();
return vModelelemdata.Count > 0 ? vModelelemdata[0] : null;
}
public ModelElementData FindKey(string strName)
{
return ModelDataDictionary[strName];
}
public string GetSaveModelColName()
{
string strResult = string.Empty;
foreach (ModelElementData element in ModelDataDictionary.Values)
strResult += element.Name + ModelTemplateDefinition.ModelFileDelimiter;
strResult = strResult.Remove((strResult.Length - 1), 1);
return strResult;
}
public string GetSaveModelValue()
{
string strResult = string.Empty;
foreach (ModelElementData element in ModelDataDictionary.Values)
strResult += element.Value + ModelTemplateDefinition.ModelFileDelimiter;
strResult = strResult.Remove((strResult.Length - 1), 1);
return strResult;
}
#region Initialization
void LoadXmlConfig(string strXmlPath)
{
if (!File.Exists(strXmlPath))
return;
XDocument xDoc = XDocument.Load(strXmlPath);
var xElement = xDoc.Element(ModelTemplateDefinition.ModelRoot);
if (xElement == null) return;
var xelemDescRoot = xElement.Element(ModelTemplateDefinition.DescriptionRoot);
var xelemDSRoot = xElement.Element(ModelTemplateDefinition.DSRoot);
LoadXmlDataForTemplate(xelemDescRoot, ModelDescriptionDictionary);
LoadXmlDataForTemplate(xelemDSRoot, ModelDataDictionary);
}
public void LoadXmlDataForTemplate(XElement xElemRoot, Dictionary<string, ModelElementData> dicResult)
{
foreach (XElement elem in xElemRoot.Elements())
{
if (elem.Name != ModelTemplateDefinition.Element)
continue;
string strName = string.Empty;
string strDataType = string.Empty;
string strDesc = string.Empty;
string strValue = elem.Value;
bool bIDKey = strValue == ModelTemplateDefinition.IDKeyMark ? true : false;
GetAttributes(elem, ref strName, ref strDataType, ref strDesc);
dicResult.Add(strName, new ModelElementData() { Name = strName, DataType = strDataType, Desc = strDesc, IsIDKey = bIDKey });
}
if (GetPrimaryKey() == null)
dicResult[dicResult.Keys.ElementAt(0)].IsIDKey = true;
}
void GetAttributes(XElement xElem, ref string strName, ref string strType, ref string strDesc)
{
strName = string.Empty;
strType = string.Empty;
strDesc = string.Empty;
foreach (XAttribute xattrb in xElem.Attributes())
{
if (xattrb.Name == ModelTemplateDefinition.AttrbName)
strName = xattrb.Value;
else if (xattrb.Name == ModelTemplateDefinition.AttrbDataType)
strType = xattrb.Value;
else if (xattrb.Name == ModelTemplateDefinition.AttrbDesc)
strDesc = xattrb.Value;
}
}
public ModelSetupTemplate GetNewModelStructure()
{
ModelSetupTemplate model = new ModelSetupTemplate(this);
return model;
}
Dictionary<string, ModelElementData> CloneDictionary(Dictionary<string, ModelElementData> dicOrg)
{
Dictionary<string, ModelElementData> dicClone = new Dictionary<string, ModelElementData>();
foreach (string strKey in dicOrg.Keys)
{
ModelElementData modeldata = new ModelElementData(dicOrg[strKey]);
dicClone.Add(strKey, modeldata);
}
return dicClone;
}
#endregion
}
}

21
SystemX.Net.CP.Platform/SystemX.PLC/Model/ModelTemplateDefinition.cs Normal file
View File

@ -0,0 +1,21 @@
namespace SystemX.PLC.Model
{
public static class ModelTemplateDefinition
{
public static string ModelRoot = "ModelTemplate";
public static string DescriptionRoot = "Description";
public static string DSRoot = "DataStructure";
public static string Element = "Element";
public static string AttrbName = "Name";
public static string AttrbDataType = "DataType";
public static string AttrbDesc = "Desc";
public static string DescTableName = "Name";
public static string DescTableValue = "Description";
public static string IDKeyMark = "IDKey";
public static string ModelFileDelimiter = ";";
}
}

33
SystemX.Net.CP.Platform/SystemX.PLC/PLCInstanciation.cs Normal file
View File

@ -0,0 +1,33 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SystemX.PLC.Interface;
using SystemX.PLC.Interface.McProtocol;
using SystemX.PLC.Interface.MxComponent;
namespace SystemX.PLC
{
public enum ConnectionType
{
Mitsubishi_McProtocol = 0,
Mitsubishi_MxComponent
}
public static class PLCInstanciation
{
public static PLCCommManager CreatePLCCommManager(ConnectionType type, string strConfigFilePath)
{
switch(type)
{
case ConnectionType.Mitsubishi_McProtocol:
return new PLCCommMcPMgr(strConfigFilePath);
case ConnectionType.Mitsubishi_MxComponent:
return new PLCCommMxCMgr(strConfigFilePath);
default:
return null;
}
}
}
}

22
SystemX.Net.CP.Platform/SystemX.PLC/Program.cs Normal file
View File

@ -0,0 +1,22 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace SystemX.PLC
{
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
}
}

36
SystemX.Net.CP.Platform/SystemX.PLC/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("SystemX.PLC")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("SystemX.PLC")]
[assembly: AssemblyCopyright("Copyright © 2020")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("56642dc5-c7ef-4040-acfc-fec17ec717d6")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

71
SystemX.Net.CP.Platform/SystemX.PLC/Properties/Resources.Designer.cs generated Normal file
View File

@ -0,0 +1,71 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace SystemX.PLC.Properties
{
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Resources
{
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Resources()
{
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager
{
get
{
if ((resourceMan == null))
{
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("SystemX.PLC.Properties.Resources", typeof(Resources).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture
{
get
{
return resourceCulture;
}
set
{
resourceCulture = value;
}
}
}
}

117
SystemX.Net.CP.Platform/SystemX.PLC/Properties/Resources.resx Normal file
View File

@ -0,0 +1,117 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
</root>

30
SystemX.Net.CP.Platform/SystemX.PLC/Properties/Settings.Designer.cs generated Normal file
View File

@ -0,0 +1,30 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace SystemX.PLC.Properties
{
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
{
private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
public static Settings Default
{
get
{
return defaultInstance;
}
}
}
}

7
SystemX.Net.CP.Platform/SystemX.PLC/Properties/Settings.settings Normal file
View File

@ -0,0 +1,7 @@
<?xml version='1.0' encoding='utf-8'?>
<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)">
<Profiles>
<Profile Name="(Default)" />
</Profiles>
<Settings />
</SettingsFile>

178
SystemX.Net.CP.Platform/SystemX.PLC/SystemX.PLC.csproj Normal file
View File

@ -0,0 +1,178 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{56642DC5-C7EF-4040-ACFC-FEC17EC717D6}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>SystemX.PLC</RootNamespace>
<AssemblyName>SystemX.PLC</AssemblyName>
<TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>..\..\Output.SystemX\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>..\..\Output.SystemX\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup>
<StartupObject />
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
<DebugSymbols>true</DebugSymbols>
<OutputPath>bin\x64\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<DebugType>full</DebugType>
<PlatformTarget>x64</PlatformTarget>
<LangVersion>7.3</LangVersion>
<ErrorReport>prompt</ErrorReport>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
<OutputPath>bin\x64\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<Optimize>true</Optimize>
<DebugType>pdbonly</DebugType>
<PlatformTarget>x64</PlatformTarget>
<LangVersion>7.3</LangVersion>
<ErrorReport>prompt</ErrorReport>
</PropertyGroup>
<ItemGroup>
<Reference Include="Dsu.Common.Utilities.Core">
<HintPath>..\ExtLib\McProtocol\Dsu.Common.Utilities.Core.dll</HintPath>
</Reference>
<Reference Include="Dsu.Common.Utilities.FS">
<HintPath>..\ExtLib\McProtocol\Dsu.Common.Utilities.FS.dll</HintPath>
</Reference>
<Reference Include="Dsu.Driver.Base.FS">
<HintPath>..\ExtLib\McProtocol\Dsu.Driver.Base.FS.dll</HintPath>
</Reference>
<Reference Include="Dsu.Driver.Util">
<HintPath>..\ExtLib\McProtocol\Dsu.Driver.Util.dll</HintPath>
</Reference>
<Reference Include="Dsu.PLC.Melsec">
<HintPath>..\ExtLib\McProtocol\Dsu.PLC.Melsec.dll</HintPath>
</Reference>
<Reference Include="FSharp.Core">
<HintPath>..\ExtLib\McProtocol\FSharp.Core.dll</HintPath>
</Reference>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Reactive.Core">
<HintPath>..\ExtLib\System.Reactive.Core.dll</HintPath>
</Reference>
<Reference Include="System.Reactive.Interfaces">
<HintPath>..\ExtLib\System.Reactive.Interfaces.dll</HintPath>
</Reference>
<Reference Include="System.Reactive.Linq">
<HintPath>..\ExtLib\System.Reactive.Linq.dll</HintPath>
</Reference>
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Data" />
<Reference Include="System.Deployment" />
<Reference Include="System.Drawing" />
<Reference Include="System.Net.Http" />
<Reference Include="System.Windows.Forms" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="Form1.cs">
<SubType>Form</SubType>
</Compile>
<Compile Include="Form1.Designer.cs">
<DependentUpon>Form1.cs</DependentUpon>
</Compile>
<Compile Include="Interface\PLCAddressManager.cs" />
<Compile Include="Interface\PLCAddressTemplate.cs" />
<Compile Include="Interface\PLCCommDefinition.cs" />
<Compile Include="Interface\McProtocol\PLCCommMcPMgr.cs" />
<Compile Include="Interface\PLCCommManager.cs" />
<Compile Include="Interface\PLCDevice.cs" />
<Compile Include="Interface\McProtocol\PLCDeviceMXC.cs" />
<Compile Include="Interface\PLCModMgr.cs" />
<Compile Include="Interface\McProtocol\PLCModMxCMgr.cs" />
<Compile Include="Interface\MxComponent\PLCCommMxCMgr.cs" />
<Compile Include="Interface\MxComponent\PLCDeviceMXC.cs" />
<Compile Include="Interface\MxComponent\PLCModMxCMgr.cs" />
<Compile Include="Interface\MxComponent\PLCMxComponent.cs" />
<Compile Include="Model\ModelCtrl.cs" />
<Compile Include="Model\ModelSetupTemplate.cs" />
<Compile Include="Model\ModelTemplateDefinition.cs" />
<Compile Include="PLCInstanciation.cs" />
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<EmbeddedResource Include="Properties\Resources.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Resources.Designer.cs</LastGenOutput>
<SubType>Designer</SubType>
</EmbeddedResource>
<Compile Include="Properties\Resources.Designer.cs">
<AutoGen>True</AutoGen>
<DependentUpon>Resources.resx</DependentUpon>
</Compile>
<None Include="Properties\Settings.settings">
<Generator>SettingsSingleFileGenerator</Generator>
<LastGenOutput>Settings.Designer.cs</LastGenOutput>
</None>
<Compile Include="Properties\Settings.Designer.cs">
<AutoGen>True</AutoGen>
<DependentUpon>Settings.settings</DependentUpon>
<DesignTimeSharedInput>True</DesignTimeSharedInput>
</Compile>
</ItemGroup>
<ItemGroup>
<None Include="App.config" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\SystemX.Net.Platform\SystemX.Net.CP.Platform.csproj">
<Project>{9e024203-a0d4-4a08-8041-9d31248b6f7b}</Project>
<Name>SystemX.Net.CP.Platform</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<COMReference Include="ACTETHERLib">
<Guid>{A306B168-AE98-11D3-83AE-00A024BDBF2B}</Guid>
<VersionMajor>3</VersionMajor>
<VersionMinor>0</VersionMinor>
<Lcid>0</Lcid>
<WrapperTool>tlbimp</WrapperTool>
<Isolated>False</Isolated>
<EmbedInteropTypes>True</EmbedInteropTypes>
</COMReference>
<COMReference Include="ActUtlTypeLib">
<Guid>{D217E54E-4A26-4A76-B0AB-57166B90F9AF}</Guid>
<VersionMajor>1</VersionMajor>
<VersionMinor>0</VersionMinor>
<Lcid>0</Lcid>
<WrapperTool>tlbimp</WrapperTool>
<Isolated>False</Isolated>
<EmbedInteropTypes>True</EmbedInteropTypes>
</COMReference>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>

36
SystemX.Net.CP.Platform/SystemX.XEFCore/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// 어셈블리에 대한 일반 정보는 다음 특성 집합을 통해
// 제어됩니다. 어셈블리와 관련된 정보를 수정하려면
// 이러한 특성 값을 변경하세요.
[assembly: AssemblyTitle("SystemX.XEFCore")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("SystemX.XEFCore")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// ComVisible을 false로 설정하면 이 어셈블리의 형식이 COM 구성 요소에
// 표시되지 않습니다. COM에서 이 어셈블리의 형식에 액세스하려면
// 해당 형식에 대해 ComVisible 특성을 true로 설정하세요.
[assembly: ComVisible(false)]
// 이 프로젝트가 COM에 노출되는 경우 다음 GUID는 typelib의 ID를 나타냅니다.
[assembly: Guid("aba6745f-3019-4551-8df2-ee85b7c9d7ad")]
// 어셈블리의 버전 정보는 다음 네 가지 값으로 구성됩니다.
//
// 주 버전
// 부 버전
// 빌드 번호
// 수정 버전
//
// 모든 값을 지정하거나 아래와 같이 '*'를 사용하여 빌드 번호 및 수정 번호를
// 기본값으로 할 수 있습니다.
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

83
SystemX.Net.CP.Platform/SystemX.XEFCore/SystemX.Net.XEFCore/DBContext/CPXV2/CPXV2.cs Normal file
View File

@ -0,0 +1,83 @@
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SystemX.XEFCore.SystemX.Net.XEFCore.DBContext.CPXV2.Tables;
namespace SystemX.XEFCore.SystemX.Net.XEFCore.DBContext.CPXV2
{
public class CPXV2 : DbContext
{
public string SqlServerConnectionString { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlServer(SqlServerConnectionString);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<HIST_TesterSummary>()
.HasKey(k => new { k.No });
modelBuilder.Entity<HIST_TestListFile>()
.HasKey(k => new { k.TestListFileNo });
modelBuilder.Entity<HIST_TestListFileLatestStepVersion>()
.HasKey(k => new { k.No });
modelBuilder.Entity<HIST_TestListFileVariantList>()
.HasKey(k => new { k.No });
modelBuilder.Entity<PROD_Group>()
.HasKey(k => new { k.No });
modelBuilder.Entity<PROD_Release>()
.HasKey(k => new { k.No });
modelBuilder.Entity<PROD_Variant>()
.HasKey(k => new { k.No });
modelBuilder.Entity<STAT_Host>()
.HasKey(k => new { k.No });
modelBuilder.Entity<STAT_TestCode>()
.HasKey(k => new { k.No });
modelBuilder.Entity<STAT_User>()
.HasKey(k => new { k.No });
modelBuilder.Entity<STOR_TestListFile>()
.HasKey(k => new { k.No });
modelBuilder.Entity<VRFY_TestListFileRelease>()
.HasKey(k => new { k.No });
}
public DbSet<HIST_TesterSummary> HIST_TesterSummary { get; set; }
public DbSet<HIST_TestListFile> HIST_TestListFile { get; set; }
public DbSet<HIST_TestListFileLatestStepVersion> HIST_TestListFileLatestStepVersion { get; set; }
public DbSet<HIST_TestListFileVariantList> HIST_TestListFileVariantList { get; set; }
public DbSet<PROD_Group> PROD_Group { get; set; }
public DbSet<PROD_Release> PROD_Release { get; set; }
public DbSet<PROD_Variant> PROD_Variant { get; set; }
public DbSet<STAT_Host> STAT_Host { get; set; }
public DbSet<STAT_TestCode> STAT_TestCode { get; set; }
public DbSet<STAT_User> STAT_User { get; set; }
public DbSet<STOR_TestListFile> STOR_TestListFile { get; set; }
public DbSet<VRFY_TestListFileRelease> VRFY_TestListFileRelease { get; set; }
}
}

24
SystemX.Net.CP.Platform/SystemX.XEFCore/SystemX.Net.XEFCore/DBContext/CPXV2/Tables/HIST_TestListFile.cs Normal file
View File

@ -0,0 +1,24 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.XEFCore.SystemX.Net.XEFCore.DBContext.CPXV2.Tables
{
public class HIST_TestListFile
{
public int TestListFileNo { get; set; }
public string Name { get; set; }
public byte[] TestListData11 { get; set; }
public byte[] TestListData12 { get; set; }
public byte[] TestListData13 { get; set; }
public byte[] TestListData14 { get; set; }
public byte[] TestListData15 { get; set; }
public byte[] TestListData16 { get; set; }
public byte[] TestListData17 { get; set; }
public byte[] TestListData18 { get; set; }
public byte[] TestListData19 { get; set; }
public byte[] TestListData110 { get; set; }
}
}

15
SystemX.Net.CP.Platform/SystemX.XEFCore/SystemX.Net.XEFCore/DBContext/CPXV2/Tables/HIST_TestListFileLatestStepVersion.cs Normal file
View File

@ -0,0 +1,15 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.XEFCore.SystemX.Net.XEFCore.DBContext.CPXV2.Tables
{
public class HIST_TestListFileLatestStepVersion
{
public long No { get; set; }
public int TestListFileNo { get; set; }
public int LatestStepVersion { get; set; }
}
}

15
SystemX.Net.CP.Platform/SystemX.XEFCore/SystemX.Net.XEFCore/DBContext/CPXV2/Tables/HIST_TestListFileVariantList.cs Normal file
View File

@ -0,0 +1,15 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.XEFCore.SystemX.Net.XEFCore.DBContext.CPXV2.Tables
{
public class HIST_TestListFileVariantList
{
public long No { get; set; }
public int TestListFileNo { get; set; }
public string VariantList { get; set; }
}
}

31
SystemX.Net.CP.Platform/SystemX.XEFCore/SystemX.Net.XEFCore/DBContext/CPXV2/Tables/HIST_TesterSummary.cs Normal file
View File

@ -0,0 +1,31 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.XEFCore.SystemX.Net.XEFCore.DBContext.CPXV2.Tables
{
public class HIST_TesterSummary
{
public long No { get; set; }
public string StationName { get; set; }
public string TestType { get; set; }
public string Version { get; set; }
public string ProdCode { get; set; }
public int TestListFileNo { get; set; }
public int TestListVariantNo { get; set; }
public string TestListCntID { get; set; }
public int StepVersion { get; set; }
public string HostID { get; set; }
public string Section { get; set; }
public string ProdNO_C { get; set; }
public string ProdNo_P { get; set; }
public string Testcode { get; set; }
public string TestListFileName { get; set; }
public string ProductID { get; set; }
public string Result { get; set; }
public string Duration { get; set; }
public DateTime TestDT { get; set; }
}
}

16
SystemX.Net.CP.Platform/SystemX.XEFCore/SystemX.Net.XEFCore/DBContext/CPXV2/Tables/PROD_Group.cs Normal file
View File

@ -0,0 +1,16 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.XEFCore.SystemX.Net.XEFCore.DBContext.CPXV2.Tables
{
public class PROD_Group
{
public int No { get; set; }
public string GroupName { get; set; }
public string ModelName { get; set; }
public string Comment { get; set; }
}
}

20
SystemX.Net.CP.Platform/SystemX.XEFCore/SystemX.Net.XEFCore/DBContext/CPXV2/Tables/PROD_Release.cs Normal file
View File

@ -0,0 +1,20 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.XEFCore.SystemX.Net.XEFCore.DBContext.CPXV2.Tables
{
public class PROD_Release
{
public int No { get; set; }
public string ProdNo_C { get; set; }
public int TestCodeNo { get; set; }
public int VariantNo { get; set; }
public string Config { get; set; }
public DateTime RegDT { get; set; }
public string RegUser { get; set; }
public string RegUserComment { get; set; }
}
}

24
SystemX.Net.CP.Platform/SystemX.XEFCore/SystemX.Net.XEFCore/DBContext/CPXV2/Tables/PROD_Variant.cs Normal file
View File

@ -0,0 +1,24 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.XEFCore.SystemX.Net.XEFCore.DBContext.CPXV2.Tables
{
public class PROD_Variant
{
public int No { get; set; }
public string ProdNo_P { get; set; }
public DateTime RegDT { get; set; }
public string RegUser { get; set; }
public DateTime UpdateDT { get; set; }
public string UpdateUser { get; set; }
public int GroupNo { get; set; }
public string Comment { get; set; }
public string Description { get; set; }
public int TestListFileNo { get; set; }
public int UseTLPosition { get; set; }
public sbyte IsUse { get; set; }
}
}

19
SystemX.Net.CP.Platform/SystemX.XEFCore/SystemX.Net.XEFCore/DBContext/CPXV2/Tables/STAT_Host.cs Normal file
View File

@ -0,0 +1,19 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SystemX.XEFCore.SystemX.Net.XEFCore.DBContext.CPXV2.Tables
{
public class STAT_Host
{
public int No { get; set; }
public string HostID { get; set; }
public string Section { get; set; }
public string IP { get; set; }
public string TestCode { get; set; }
public string Comment { get; set; }
public DateTime UpdateDT { get; set; }
}
}

Some files were not shown because too many files have changed in this diff Show More