/// <summary>
/// 转发协议
/// </summary>
/// <param name="args">协议包</param>
protected void Shoot(ReceivedEventArgs args)
{
Shoot_Request request = new Shoot_Request();
ByteFormatter.Deserialize(request, args.Buffer, ProtocolHead.HeadSize);
IPEndPoint remoteEndPoint = new IPEndPoint(request.RemoteIp, request.RemotePort);
SocketResult result = SendAsync(request.Tag,
remoteEndPoint,
request.Buffer,
p => p.ProtocolId == request.ProtocolId,
p =>
{
Shoot_Response shoot = new Shoot_Response
{
Result = Convert.ToByte(SocketResult.Success),
Buffer = p.Buffer
};
List <byte> responseBuffer = Protocol.Response(args.TimeStamp, shoot);
args.Channel.Send(args.RemoteEndPoint, responseBuffer);
});
if (result != SocketResult.Success)
{
Shoot_Response response = new Shoot_Response
{
Result = Convert.ToByte(result),
Buffer = new List <byte>()
};
args.Channel.Send(remoteEndPoint, Protocol.Response(args.TimeStamp, response));
}
}
private void buttonInboundSend_Click(object sender, EventArgs e)
{
string sendData = this.textBoxClientSend.Text;
//SocketResult result = SocketHelper.SendData("127.0.0.1", (int)this.numericUpDownClientPort.Value, sendData);
SocketConfig config = new SocketConfig();
config.Port = (int)this.numericUpDownClientPort.Value;
config.IPAddress = "127.0.0.1";
config.SendEndSign = "</XMLRequestMessage>";
config.ReceiveEndSign = "</XMLResponseMessage>";
config.IncludeHeader = false;
SocketResult result = SocketHelper.SendData(config, sendData);
if (result.Type == SocketResultType.Success)
{
this.textBoxClientReceive.Text = result.ReceivedString;
}
else
{
//MessageBox.Show(result.ExceptionInfor, result.Type.ToString());
}
Application.DoEvents();
}
private static async Task Server_OnAccepted(IOCPBase server, int num, System.Net.Sockets.Socket socket)
{
while (true)
{
try
{
SocketResult result = await server.SendAsync(socket, Encoding.UTF8.GetBytes(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")));
Console.WriteLine("send result:" + result.SocketError);
if (result.SocketError != System.Net.Sockets.SocketError.Success)
{
server.CloseClientSocket(socket);
return;
}
result = await server.ReceiveAsync(socket);
Console.WriteLine("receive result:" + result.SocketError);
if (result.SocketError != System.Net.Sockets.SocketError.Success)
{
server.CloseClientSocket(socket);
return;
}
await Task.Delay(1000);
}
catch (Exception ex)
{
Console.WriteLine("error:" + ex.Message);
server.CloseClientSocket(socket);
return;
}
}
}
public override void Execute(SocketServer server, SocketSession session, SockectRequestMessage requestInfo)
{
try
{
SubscribeItem subscribeItem;
if (requestInfo.TryReadFromJsonStream(out subscribeItem))
{
var _MQMServer = (MQMServer)server;
_MQMServer.MessageQueueAgent.Subscribe(subscribeItem.PublisherId, subscribeItem);
var result = SocketResult <string> .Create(message : "订阅主题成功！");
session.SendObjectToJsonStream(RouteCode, result);
}
}
catch (NotAuthenticationException)
{
var result = SocketResult <string> .Create(code : "500", message : "未经授权的操作！");
session.SendObjectToJsonStream(RouteCode, result);
}
catch (Exception ex)
{
var result = SocketResult <string> .Create(code : "600", message : string.Format("订阅主题过程中发生无法预知错误，{0}！", ex.Message));
session.SendObjectToJsonStream(RouteCode, result);
}
}
/// <summary>
/// 向所有监听客户端发送数据
/// </summary>
/// <param name="target">监听目标</param>
/// <param name="data">数据</param>
/// <param name="endMessage">是否末尾数据</param>
/// <returns></returns>
async Task IWebSocket.SendListenerAsync(string target, SocketResult data, bool?endMessage)
{
foreach (var client in m_socket_listener[target])
{
await client.SendAsync(data, endMessage);
}
}
public override void Execute(SocketServer server, SocketSession session, SockectRequestMessage requestInfo)
{
try
{
PublisherInformaction publisher;
if (requestInfo.TryReadFromJsonStream(out publisher))
{
var _MQMServer = (MQMServer)server;
if (_MQMServer.MessageQueueAgent.Authentication(new ClientIndetity()
{
IsWebSite = publisher.IsWebSite, PublisherId = publisher.PublisherId, SessionId = session.SessionID, WebSiteHost = publisher.WebSiteHost
}, publisher.MQMToken))
{
var result = SocketResult <string> .Create(message : "欢迎登录消息中间件！");
session.SendObjectToJsonStream(RouteCode, result);
}
}
}
catch (NotAuthenticationException)
{
var result = SocketResult <string> .Create(code : "501", message : "授权登陆失败！");
session.SendObjectToJsonStream(RouteCode, result);
}
catch (Exception ex)
{
var result = SocketResult <string> .Create(code : "600", message : string.Format("授权登陆过程中发生无法预知错误，{0}！", ex.Message));
session.SendObjectToJsonStream(RouteCode, result);
}
}
void error(SocketResult _result, string _msg)
{
Debug.LogErrorFormat("[ClientBase.error] state = {2} , result = {0} , msg = {1}", _result, _msg, State);
if (State != ClientState.Closed)
{
OnError(_result, _msg);
}
}
public bool SendMLLPNotification(string hl7msg)
{
_entity.Context.Log.Write("Begin sending HL7 notification.");
SocketResult ret = _client.SendData(hl7msg);
_entity.Context.Log.Write(string.Format("End sending HL7 notification. Result: {0}.", ret.Type.ToString()));
//SendLogMessage(hl7msg, ret);
return(ret.Type == SocketResultType.Success);
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="data">数据</param>
/// <param name="endMessage">是否末尾数据</param>
async Task IWebSocket.SendAsync(SocketResult data, bool?endMessage)
{
ArraySegment <byte> arg = new ArraySegment <byte>(
UTF8Encoding.Default.GetBytes(
JsonConvert.SerializeObject(data)
)
);
await m_socket.SendAsync(arg, WebSocketMessageType.Text, endMessage.GetValueOrDefault(true), CancellationToken.None);
}
/// <summary>
/// 传输数据
/// </summary>
/// <param name="SendType"></param>
/// <param name="Result"></param>
/// <param name="Session"></param>
/// <param name="SendPort"></param>
/// <returns></returns>
public static SocketMiddleData Middle(SendTypeEnum SendType, SocketResult Result, SocketSession Session = null, int?SendPort = null)
{
return(new SocketMiddleData()
{
SendType = SendType,
MiddleResult = Result,
Session = Session,
SendPort = SendPort
});
}
public bool SendMLLPQuery(string query, out string result)
{
_entity.Context.Log.Write("Begin sending HL7 query.");
SocketResult ret = _client.SendData(query);
_entity.Context.Log.Write(string.Format("End sending HL7 query. Result: {0}.", ret.Type.ToString()));
result = ret.ReceivedString;
//SendLogMessage(query, ret);
return(ret.Type == SocketResultType.Success);
}
private void SenderMessage()
{
Program.Context.Log.Write(LogType.Information, string.Format("Thread {0} is start...", Thread.CurrentThread.ManagedThreadId));
string strSend = _strSendMsg;
strSend = strSend.Replace("\r\n", "\r");
SocketClient client = new SocketClient();
SocketClientConfig clientCfg = new SocketClientConfig();
clientCfg.SendTimeout = Program.Context.ConfigMgr.Config.SocketConfig.SendTimeout;
clientCfg.ReceiveTimeout = Program.Context.ConfigMgr.Config.SocketConfig.ReceiveTimeout;
clientCfg.ReceiveResponseBufferSizeKB = Program.Context.ConfigMgr.Config.SocketConfig.ReceiveResponseBufferSizeKB;
clientCfg.CodePageCode = Program.Context.ConfigMgr.Config.SocketConfig.CodePageCode;
clientCfg.CodePageName = Program.Context.ConfigMgr.Config.SocketConfig.CodePageName;
clientCfg.IPAddress = _strIPAddr;
clientCfg.Port = _iPort;
//Thread.Sleep(100000);
DateTime dtBegin = DateTime.Now;
SocketResult result = client.SendData(clientCfg, strSend);
DateTime dtEnd = DateTime.Now;
TimeSpan procTime = dtEnd.Subtract(dtBegin);
if (result.Type == SocketResultType.Success)
{
Program.Context.Log.Write(string.Format("Thread {0} send HL7 message success", Thread.CurrentThread.ManagedThreadId));
if (_bDumpResponse)
{
Program.Context.Log.Write(LogType.Information, result.ReceivedString);
}
}
else
{
Program.Context.Log.Write(string.Format("Thread {0} send HL7 message failed.", Thread.CurrentThread.ManagedThreadId));
}
lock (this)
{
_currentNumber--;
}
Program.Context.Log.Write(LogType.Information, string.Format("Thread {0} is end", Thread.CurrentThread.ManagedThreadId));
Program.Context.Log.Write(LogType.Information, string.Format("-----------Thread {0} is sumary -----------------", Thread.CurrentThread.ManagedThreadId));
Program.Context.Log.Write(LogType.Information, "\tStart at " + dtBegin.ToString("yyyy-MM-dd HH:mm:ss.fffffff"));
Program.Context.Log.Write(LogType.Information, "\tEnd at " + dtEnd.ToString("yyyy-MM-dd HH:mm:ss.fffffff"));
Program.Context.Log.Write(LogType.Information, "\tProcess Time : " + procTime.TotalMilliseconds);
Program.Context.Log.Write(LogType.Information, "--------------------------------------------------------");
}
private void buttonSend_Click(object sender, EventArgs e)
{
string strIP = this.textBoxIP.Text;
int numPort = (int)this.numericUpDownPort.Value;
string strSend = this.textBoxSend.Text;
string strReceive = string.Empty;
if (this.checkBoxReplace0D.Checked)
{
strSend = strSend.Replace("\r\n", "\r"); // replace ODOA with OD
}
SocketClient client = new SocketClient();
SocketClientConfig clientCfg = new SocketClientConfig();
clientCfg.SendTimeout = Program.Context.ConfigMgr.Config.SocketConfig.SendTimeout;
clientCfg.ReceiveTimeout = Program.Context.ConfigMgr.Config.SocketConfig.ReceiveTimeout;
clientCfg.ReceiveResponseBufferSizeKB = Program.Context.ConfigMgr.Config.SocketConfig.ReceiveResponseBufferSizeKB;
clientCfg.CodePageCode = Program.Context.ConfigMgr.Config.SocketConfig.CodePageCode;
clientCfg.CodePageName = Program.Context.ConfigMgr.Config.SocketConfig.CodePageName;
clientCfg.IPAddress = strIP;
clientCfg.Port = numPort;
DateTime dtBegin = DateTime.Now;
SocketResult result = client.SendData(clientCfg, strSend);
DateTime dtEnd = DateTime.Now;
TimeSpan procTime = dtEnd.Subtract(dtBegin);
this.labelProcessingTime.Text = string.Format("in {0} ms.", procTime.TotalMilliseconds.ToString());
if (result.Type == SocketResultType.Success)
{
UpdateGUIHandler d = delegate(string content)
{
this.textBoxReceive.Text = content.Replace("\r", "\r\n");
};
this.textBoxReceive.Invoke(d, result.ReceivedString);
}
else
{
MessageBox.Show(this,
string.Format("Result: {0}\r\n\r\nInformation:{1}",
result.Type.ToString(),
result.ExceptionInfor),
this.Text,
MessageBoxButtons.OK,
MessageBoxIcon.Warning);
}
}
/// <summary>
/// 向所有客户端发送数据
/// </summary>
/// <param name="data">数据</param>
/// <param name="endMessage">是否末尾数据</param>
async Task IWebSocket.SendAllAsync(SocketResult data, bool?endMessage)
{
foreach (var item in m_socket_list)
{
if (item.Socket.State == WebSocketState.Open)
{
await item.SendAsync(data, endMessage.GetValueOrDefault(true));
}
else
{
m_socket_list.Remove(item);
}
}
}
/// <summary>
/// 发送字节流
/// </summary>
/// <param name="remoteEndPoint">udp远程地址，如果为null表示tcp发送</param>
/// <param name="buffer">字节流</param>
/// <param name="match">响应匹配函数，不使用匹配标识不等待响应</param>
/// <param name="action">成功响应后的异步回调，默认为null，表示同步等待响应</param>
/// <param name="receiveBuffer">同步等待响应后得到的响应字节流，默认为null</param>
/// <param name="timeout">等待响应时间，默认为3秒</param>
/// <returns>发送结果</returns>
public SocketResult Send(IPEndPoint remoteEndPoint, List <byte> buffer, Func <ReceivedEventArgs, bool> match = null, Action <ReceivedEventArgs> action = null, List <byte> receiveBuffer = null, int timeout = 3000)
{
if (match == null)
{
return(SendCore(remoteEndPoint, buffer));
}
else
{
long timeStamp = TimeStampConvert.ToUtcTimeStamp();
if (action == null)
{
AutoResetEvent resetEvent = new AutoResetEvent(false);
lock (_lockObj)
{
_responseItems.AddLast(new ResponseItem
{
Match = match,
Action = null,
ReceiveBuffer = receiveBuffer,
ResetEvent = resetEvent,
TimeStamp = timeStamp + timeout
});
}
SocketResult result = SendCore(remoteEndPoint, buffer);
if (result == SocketResult.Success)
{
result = resetEvent.WaitOne(timeout) ? SocketResult.Success : SocketResult.Timeout;
}
return(result);
}
else
{
lock (_lockObj)
{
_responseItems.AddLast(new ResponseItem
{
Match = match,
Action = action,
ReceiveBuffer = receiveBuffer,
ResetEvent = null,
TimeStamp = timeStamp + timeout
});
}
return(SendCore(remoteEndPoint, buffer));
}
}
}
/// <summary>
/// 接收数据
/// </summary>
/// <returns></returns>
async Task <SocketResult> IWebSocket.ReceiveAsync()
{
byte[] buffer = new byte[2048];
var data = await m_socket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
UTF8Encoding.Default.GetString(buffer);
int count = 0;
for (; count < buffer.Length; count++)
{
if (buffer[count] == '\0')
{
break;
}
}
string rcv_data = UTF8Encoding.Default.GetString(buffer, 0, count);
//return JObject.Parse(rcv_data);
JObject json = JObject.Parse(rcv_data);
SocketResult res = new SocketResult(json["target"].ToString(), json["method"].ToString(), json["data"]);
return(res);
}
public HitbtcApiResult <int> SubscribeTicker(string symbol, Action <SocketData <TickerData> > onUpdate)
{
SocketResult SocketResult = null;
HitbtcApiResult <int> ApiResult = new HitbtcApiResult <int>();
int streamId = WebSocketList.Any() ? WebSocketList.Keys.Max() + 1 : 1;
WebSocket WebSocket = new WebSocket(this.SocketUri);
ConfigSecurity(WebSocket);
WebSocket.Opened += new EventHandler((sender, e) =>
{
Dictionary <string, object> send = new Dictionary <string, object>();
{
send.Add("method", "subscribeTicker");
send.Add("params", new Dictionary <string, string>()
{
{ "symbol", symbol }
});
send.Add("id", streamId);
};
WebSocket.Send(JsonConvert.SerializeObject(send));
});
WebSocket.MessageReceived += new EventHandler <MessageReceivedEventArgs>((sender, e) =>
{
if (SocketResult == null)
{
SocketResult = JsonConvert.DeserializeObject <SocketResult>(e.Message);
if (!SocketResult.Status)
{
OnError(sender, SocketResult.Error);
}
}
else
{
SocketData <TickerData> SocketData = JsonConvert.DeserializeObject <JObject>(e.Message).ToObject <SocketData <TickerData> >();
if (SocketData.Data != null)
{
onUpdate(SocketData);
}
}
});
ErrorMessage error = null;
WebSocket.Error += new EventHandler <ErrorEventArgs>((sender, e) =>
{
error = new ErrorMessage()
{
Message = e.Exception.Message
};
OnError(sender, error);
});
WebSocket.Closed += new EventHandler((sender, e) =>
{
WebSocket.Dispose();
if (error == null)
{
OnClose(sender, e);
}
});
WebSocket.Open();
WebSocketList.Add(streamId, WebSocket);
ApiResult.Data = streamId;
return(ApiResult);
}
private void _timer_Elapsed(object sender, ElapsedEventArgs e)
{
_timer.Stop();
Program.Log.Write("# Timer tick begin.", XIMClientHelper.ModuleName);
int index = 0;
foreach (XIMOutboundMessage msg in Program.ConfigMgt.Config.Messages)
{
try
{
index++;
List <XIMWrapper> resultList = null;
string strPrefix = "(" + index.ToString() + ") ";
Program.Log.Write(strPrefix + "Begin processing message (" + msg.GWEventType.ToString() + ") to (" + msg.HL7EventType.ToString() + ").", XIMClientHelper.ModuleName);
#region Data Processing
DataSet dataSet = _service.RequestData(msg.Rule, null);
if (dataSet == null)
{
Program.Log.Write(LogType.Warning, "Query data from GC Gateway database failed.");
}
else
{
List <DataSet> splitedDataSet = XIMClientHelper.SplitDataSet(dataSet);
if (splitedDataSet == null || splitedDataSet.Count < 1)
{
Program.Log.Write(LogType.Warning, "No record found in GC Gateway database query result.");
}
else
{
Program.Log.Write(strPrefix + "Query data from GC Gateway database succeeded (Record count:" + splitedDataSet.Count.ToString() + ").");
XMLTransformer transformer = XMLTransformer.CreateFromMessage(msg);
if (transformer == null)
{
Program.Log.Write(LogType.Warning, "Cannot find mapping XSL file for current message (XSL File:" + msg.XSLFileName + ").");
}
else
{
resultList = XIMClientHelper.Transform(transformer, splitedDataSet);
if (resultList == null || resultList.Count < 1)
{
Program.Log.Write(LogType.Warning, "Transform from DataSet xml to XIM xml failed (XSL File:" + msg.XSLFileName + ").");
}
else
{
Program.Log.Write(strPrefix + "Transform from DataSet xml to XIM xml succeeded (Document count:" + resultList.Count.ToString() + ").");
if (resultList.Count > 1 && Program.ConfigMgt.Config.EnableDataMerging)
{
int pkIndex = Program.ConfigMgt.Config.DataMergingPKIndex;
resultList = XIMClientHelper.MergeProcedureStep(resultList, pkIndex);
if (resultList == null || resultList.Count < 1)
{
Program.Log.Write(LogType.Warning, "SPS merging failed (PK Index:" + pkIndex.ToString() + ").");
}
else
{
Program.Log.Write(strPrefix + "SPS merging succeeded (PK Index:" + pkIndex.ToString() + ") (Document count:" + resultList.Count.ToString() + ").");
}
}
else
{
Program.Log.Write(strPrefix + "Skip SPS merging.");
}
}
}
}
}
#endregion
#region Data Sending
if (resultList == null || resultList.Count < 1)
{
Program.Log.Write(LogType.Warning, "No availiable XIM document, skip data sending.");
}
else
{
int ximIndex = 1;
Program.Log.Write(strPrefix + "Sending XIM document...");
foreach (XIMWrapper xim in resultList)
{
string ximLogIndex = "(" + (ximIndex++).ToString() + "/" + resultList.Count.ToString() + ")";
bool result = false;
if (Program.ConfigMgt.Config.OutboundToFile)
{
result = !XIMClientHelper.SaveToFile(Program.ConfigMgt.Config, xim.XIMDocument);
}
else
{
SocketResult res = SocketHelper.SendData(Program.ConfigMgt.Config.SocketConfig, xim.XIMDocument);
result = (res == null || res.Type != SocketResultType.Success);
}
if (result)
{
Program.Log.Write(LogType.Warning, "Send XIM document failed. " + ximLogIndex);
}
else
{
Program.Log.Write(strPrefix, "Send XIM document succeeded. " + ximLogIndex);
if (_service.DischargeData(xim.GUIDList.ToArray()))
{
Program.Log.Write(strPrefix, "Discharge data succeeded. " + ximLogIndex);
}
else
{
Program.Log.Write(LogType.Warning, "Discharge data failed. " + ximLogIndex);
}
}
}
Program.Log.Write(strPrefix + "Send XIM document completed.");
}
#endregion
Program.Log.Write(strPrefix + "End processing message.", XIMClientHelper.ModuleName);
}
catch (Exception err)
{
Program.Log.Write(err);
}
}
Program.Log.Write("# Timer tick end.", XIMClientHelper.ModuleName);
_timer.Start();
}
private bool SendMessages(IClient cln)
{
if (cln == null)
{
return(false);
}
if (this.listViewMessage.Items.Count < 1)
{
MessageBox.Show(this,
"There are no HL7 message files in the list. Please click \"Reload Files\" to load the list first.",
this.Text,
MessageBoxButtons.OK,
MessageBoxIcon.Information);
return(false);
}
string folder = this.textBoxPath.Text.Trim();
string ackFolder = Path.Combine(folder, "ack");
try
{
if (!Directory.Exists(ackFolder))
{
Directory.CreateDirectory(ackFolder);
}
foreach (ListViewItem i in this.listViewMessage.Items)
{
string fn = i.Text;
string f = i.Tag as string;
string msg = "";
using (StreamReader sr = File.OpenText(f))
{
msg = sr.ReadToEnd();
}
msg = msg.Replace("\r\n", "\r");
DateTime dtBegin = DateTime.Now;
SocketResult result = cln.SendData(msg);
DateTime dtEnd = DateTime.Now;
if (result.Type == SocketResultType.Success)
{
string ackfn = fn + ".ack.txt";
string ackf = Path.Combine(ackFolder, ackfn);
using (StreamWriter sw = File.CreateText(ackf))
{
sw.Write(result.ReceivedString);
}
i.SubItems[1].Text = ackfn;
}
else
{
i.SubItems[1].Text = result.Type.ToString() + ":" + result.ExceptionInfor;
break;
}
TimeSpan procTime = dtEnd.Subtract(dtBegin);
i.SubItems[2].Text = procTime.TotalMilliseconds.ToString();
i.SubItems[3].Text = dtBegin.ToString(LogHelper.DateTimeFomat);
i.SubItems[4].Text = dtEnd.ToString(LogHelper.DateTimeFomat);
Application.DoEvents();
}
return(true);
}
catch (Exception err)
{
Program.Context.Log.Write(err);
MessageBox.Show(this,
"Error when sending HL7 message. \r\n\r\n" + err.Message,
this.Text,
MessageBoxButtons.OK,
MessageBoxIcon.Warning);
return(false);
}
}
public HuobiApiResult <int> SubscribeTicker(string symbol, Action <SocketData <TickerData> > onUpdate)
{
PingPong pong;
SocketResult SocketResult = null;
HuobiApiResult <int> ApiResult = new HuobiApiResult <int>();
int streamId = WebSocketList.Any() ? WebSocketList.Keys.Max() + 1 : 1;
WebSocket WebSocket = new WebSocket(this.SocketUrl, sslProtocols: SslProtocols.Tls12 | SslProtocols.Tls11 | SslProtocols.Tls);
ConfigSecurity(WebSocket);
WebSocket.Opened += new EventHandler((sender, e) =>
{
Dictionary <string, object> send = new Dictionary <string, object>();
{
send.Add("sub", string.Format("market.{0}.depth.step0", symbol));
send.Add("id", streamId);
};
WebSocket.Send(JsonConvert.SerializeObject(send));
});
WebSocket.DataReceived += new EventHandler <DataReceivedEventArgs>((sender, e) =>
{
string result = ConvertGZIPtoJSON(e.Data);
using (pong = JsonConvert.DeserializeObject <PingPong>(result))
{
if (!pong.pong.Equals(0))
{
WebSocket.Send(JsonConvert.SerializeObject(new Dictionary <string, long>()
{
{ "pong", pong.pong }
}));
}
else
{
if (SocketResult == null)
{
SocketResult = JsonConvert.DeserializeObject <SocketResult>(result);
if (SocketResult.Status.Equals("error"))
{
SocketResult.Error = JsonConvert.DeserializeObject <ErrorMessage>(result);
OnError(sender, SocketResult.Error);
}
}
else
{
try
{
var data = JsonConvert.DeserializeObject <JObject>(result);
SocketData <TickerData> SocketData = data.ToObject <SocketData <TickerData> >();
if (SocketData.Method != null)
{
SocketData.Data = data.SelectToken("tick").ToObject <TickerData>();
onUpdate(SocketData);
}
}
catch (Exception ex)
{
OnError(sender, new ErrorMessage()
{
Message = ex.Message
});
}
}
}
}
});
ErrorMessage error = null;
WebSocket.Error += new EventHandler <SuperSocket.ClientEngine.ErrorEventArgs>((sender, e) =>
{
error = new ErrorMessage()
{
Message = e.Exception.Message
};
OnError(sender, error);
});
WebSocket.Closed += new EventHandler((sender, e) =>
{
WebSocket.Dispose();
if (error == null)
{
OnClose(sender, e);
}
});
WebSocket.Open();
WebSocketList.Add(streamId, WebSocket);
ApiResult.Data = streamId;
return(ApiResult);
}
protected virtual void OnError(SocketResult _result, string _msg)
{
State = ClientState.Disconnected;
disconnect();
}
internal void Loop()
{
try
{
// ReSharper disable once TooWideLocalVariableScope
byte[] data;
// ReSharper disable once TooWideLocalVariableScope
SocketResult <SocketClient> result;
// ReSharper disable once TooWideLocalVariableScope
int length;
while (loopFlag)
{
try
{
data = new byte[1024];
length = -1;
length = socket.Receive(data);
if (length < 1)
{
continue;
}
byte[] tmp = new byte[length];
Buffer.BlockCopy(data, 0, tmp, 0, length);
result = null;
//this.RemoteEndPoint = socket.RemoteEndPoint;
result = new SocketResult <SocketClient>()
{
Socket = this, Bytes = tmp, OnData = OnData
};
Thread processThread = new Thread(ProcessData <SocketClient>)
{
IsBackground = true
};
processThread.Start(result);
}
catch (SocketException ex)
{
Console.WriteLine(ex.Message);
if (ex.SocketErrorCode == SocketError.ConnectionReset || ex.SocketErrorCode == SocketError.ConnectionAborted)
{
//Console.WriteLine($"Server {socket.RemoteEndPoint} offline.");
socket.Shutdown(SocketShutdown.Both);
socket.Close();
break;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
continue;
}
Thread.Sleep(10);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
this.status = SocketStatus.Stop;
}
