362 lines
13 KiB
C#
362 lines
13 KiB
C#
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;
|
|
}
|
|
}
|
|
}
|