public void Init (Socket socket, AsyncCallback callback, object state, SocketOperation operation)
{
base.Init (callback, state);
this.socket = socket;
this.handle = socket != null ? socket.Handle : IntPtr.Zero;
this.operation = operation;
DelayedException = null;
EndPoint = null;
Buffer = null;
Offset = 0;
Size = 0;
SockFlags = SocketFlags.None;
AcceptSocket = null;
Addresses = null;
Port = 0;
Buffers = null;
ReuseSocket = false;
CurrentAddress = 0;
AcceptedSocket = null;
Total = 0;
error = 0;
EndCalled = 0;
}
static HandleResult OnError(TcpClient sender, SocketOperation enOperation, int errorCode)
{
// 出错了
AddMsg(string.Format(" > [{0},OnError] -> OP:{1},CODE:{2}", sender.ConnectionId, enOperation, errorCode));
// 通知界面,只处理了连接错误,也没进行是不是连接错误的判断,所以有错误就会设置界面
// 生产环境请自己控制
//this.Invoke(new SetAppStateDelegate(SetAppState), AppState.Stoped);
return HandleResult.Ok;
}
private HandleResult OnClose(IClient sender, SocketOperation socketOperation, int errorCode)
{
appState = AppState.Stoped;
SetControlState();
if (errorCode == 0)
{
AddLog($"服务器连接关闭！");
}
else
{
AddLog($"服务器连接异常关闭，错误代码:{errorCode}");
}
return(HandleResult.Ok);
}
//当触发了OnClose事件时，表示连接已经被关闭，并且OnClose事件只会被触发一次
//通过errorCode参数判断是正常关闭还是异常关闭，0表示正常关闭
private HandleResult client_OnClose(TcpClient sender, SocketOperation enOperation, int errorCode)
{
appState = AppState.Stoped;
SetControlState();
if (errorCode == 0)
{
ShowMSG("连接已关闭");
}
else
{
ShowMSG(string.Format("连接异常关闭：{0}，{1}", client.ErrorMessage, client.ErrorCode));
}
return(HandleResult.Ok);
}
private HandleResult ServerClose(IServer sender, IntPtr connId, SocketOperation socketOperation, int errorCode)
{
var extra = sender.GetExtra <TcpPortForwardingExtra>(connId);
if (extra != null)
{
sender.RemoveExtra(connId);
if (extra.ReleaseType == TcpPortForwardingReleaseType.None)
{
extra.ReleaseType = TcpPortForwardingReleaseType.Server;
extra.Agent.Disconnect(extra.AgentConnId);
}
}
return(OnServerClose?.Invoke(sender, connId, socketOperation, errorCode) ?? HandleResult.Ok);
}
public void Complete()
{
if (operation != SocketOperation.Receive && socket.CleanedUp)
{
DelayedException = new ObjectDisposedException(socket.GetType().ToString());
}
IsCompleted = true;
/* It is possible that this.socket is modified by this.Init which has been called by the callback. This
* would lead to inconsistency, as we would for example not release the correct socket.ReadSem or
* socket.WriteSem.
* For example, this can happen with AcceptAsync followed by a ReceiveAsync on the same
* SocketAsyncEventArgs */
Socket completedSocket = socket;
SocketOperation completedOperation = operation;
AsyncCallback callback = AsyncCallback;
if (callback != null)
{
ThreadPool.UnsafeQueueUserWorkItem(_ => callback(this), null);
}
/* Warning: any field on the current SocketAsyncResult might have changed, as the callback might have
* called this.Init */
switch (completedOperation)
{
case SocketOperation.Receive:
case SocketOperation.ReceiveFrom:
case SocketOperation.ReceiveGeneric:
case SocketOperation.Accept:
completedSocket.ReadSem.Release();
break;
case SocketOperation.Send:
case SocketOperation.SendTo:
case SocketOperation.SendGeneric:
completedSocket.WriteSem.Release();
break;
}
// IMPORTANT: 'callback', if any is scheduled from unmanaged code
}
HandleResult OnClose(IServer sender, IntPtr connId, SocketOperation enOperation, int errorCode)
{
if (errorCode == 0)
{
AddMsg(string.Format(" > [{0},OnClose]", connId));
}
else
{
AddMsg(string.Format(" > [{0},OnError] -> OP:{1},CODE:{2}", connId, enOperation, errorCode));
}
if (extra.Remove(connId) == false)
{
AddMsg(string.Format(" > [{0},OnClose] -> SetConnectionExtra({0}, null) fail", connId));
}
return(HandleResult.Ok);
}
HandleResult Service_OnClose(TcpServer sender, IntPtr connId, SocketOperation enOperation, int errorCode)
{
if (!this.deviceList.Dictionary.ContainsKey(connId))
{
return(HandleResult.Ignore);
}
var deviceInfo = this.deviceList.Dictionary[connId];
this.client.SendMessage(new ClientChangedMessage()
{
ChangedType = ClientChangedType.Remove,
UserID = deviceInfo.UserID,
WindowNumber = deviceInfo.WindowNumber
});
this.deviceList.Remove(connId);
this.deviceList.Changed = true;
return(HandleResult.Ignore);
}
protected HandleResult OnClose(TcpClient sender, SocketOperation enOperation, int errorCode)
{
HandleResult result;
if (errorCode == 0)
{
// 连接关闭了
//AddMsg(string.Format(" > [{0},OnClose]", sender.ConnectionId));
result = HandleResult.Ok;
}
else
{
result = HandleResult.Error;
}
Status = ClientStatus.Stopped;
Console.WriteLine("掉线了");
return(result);
}
HandleResult OnClose(IClient sender, SocketOperation enOperation, int errorCode)
{
if (errorCode == 0)
{
// 连接关闭了
AddMsg(string.Format(" > [{0},OnClose]", client.ConnectionId));
}
else
{
// 出错了
AddMsg(string.Format(" > [{0},OnError] -> OP:{1},CODE:{2}", client.ConnectionId, enOperation, errorCode));
}
// 通知界面,只处理了连接错误,也没进行是不是连接错误的判断,所以有错误就会设置界面
// 生产环境请自己控制
this.Invoke(new SetAppStateDelegate(SetAppState), AppState.Stoped);
return(HandleResult.Ok);
}
HandleResult OnClose(IntPtr connId, SocketOperation enOperation, int errorCode)
{
if (errorCode == 0)
{
AddMsg(string.Format(" > [关闭客户端ID：{0}]", connId));
}
else
{
AddMsg(string.Format(" > [客户端ID：{0},错误] -> OP:{1},CODE:{2}", connId, enOperation, errorCode));
}
// 获取附加数据
ClientInfo clientInfo = extra.Get(connId);
htCI.Remove(clientInfo.ConnId);
if (extra.Remove(connId) == false)
{
AddMsg(string.Format(" > [关闭客户端ID：{0}] -> SetConnectionExtra({0}, null) fail", connId));
}
else
{
//刷新datagridview数据
DataTable dt = new DataTable();
dt.Columns.Add("connid");
dt.Columns.Add("IP");
dt.Columns.Add("prot");
ClientInfo ci = new ClientInfo();
foreach (var item in htCI.Values)
{
ci = (ClientInfo)item;
DataRow dr = dt.NewRow();
dr["connid"] = ci.ConnId.ToString();
dr["IP"] = ci.IpAddress.ToString();
dr["prot"] = ci.Port.ToString();
dt.Rows.Add(dr);
}
fnUpdateGridView(dt);
}
return(HandleResult.Ok);
}
private HandleResult ClosePool(IntPtr connId, SocketOperation enOperation, int errorCode)
{
try
{
ClientInfo clientInfo = _server.GetExtra(connId);
string.Format(" > [{0},OnAccept] -> PASS({1}:{2})", connId, clientInfo.IpAddress, clientInfo.Port);
if (errorCode == 0)
{
WriteDeviceLog.WriteLog("Log\\" + _name + "\\Close客户端",
string.Format(" > [{0},OnClose] -> On({1}:{2})", connId, clientInfo.IpAddress, clientInfo.Port),
Guid.NewGuid().ToString());
}
else
{
WriteDeviceLog.WriteLog("Log\\" + _name + "\\Close客户端",
string.Format(" > [{0},OnError] -> OP:{1},CODE:{2} -> On({3}:{4})", connId, enOperation,
errorCode, clientInfo.IpAddress, clientInfo.Port), Guid.NewGuid().ToString());
}
if (_server.RemoveExtra(connId) == false)
{
WriteDeviceLog.WriteLog("Log\\" + _name + "\\Close客户端",
string.Format(" > [{0},OnClose] -> SetConnectionExtra({0}, null) fail -> On({1}:{2})", connId,
clientInfo.IpAddress, clientInfo.Port), Guid.NewGuid().ToString());
}
//连接断开删除客户端对象
string dicConnIdValue;
DicConnId.TryRemove(connId.ToString(), out dicConnIdValue);
SpreadModel value = null;
SpreadObject.TryRemove(connId.ToString(), out value);
//服务信息
InitServiceInfo(true);
return(HandleResult.Ok);
}
catch (Exception ex)
{
WriteDeviceLog.WriteLog("Log\\" + _name + "\\Close客户端", ex.ToString(), Guid.NewGuid().ToString());
return(HandleResult.Error);
}
finally
{
//InitMonitorService.AutoResetEvent.Set();
}
}
HandleResult OnClose(IntPtr connId, SocketOperation enOperation, int errorCode)
{
if (errorCode == 0)
{
AddMsg(string.Format(" > [{0},OnClose]", connId));
}
else
{
AddMsg(string.Format(" > [{0},OnError] -> OP:{1},CODE:{2}", connId, enOperation, errorCode));
}
// return HPSocketSdk.HandleResult.Ok;
if (server.SetConnectionExtra(connId, null) == false)
{
AddMsg(string.Format(" > [{0},OnClose] -> SetConnectionExtra({0}, null) fail", connId));
}
return(HandleResult.Ok);
}
// ReSharper disable once InconsistentNaming
private HandleResult OnClose(IServer sender, IntPtr connId, SocketOperation socketOperation, int errorCode)
{
var client = sender.GetExtra <ClientInfo <IntPtr> >(connId);
if (client != null)
{
sender.RemoveExtra(connId);
// 释放在OnAccept方法里申请的内存
if (client.PacketData != IntPtr.Zero)
{
Marshal.FreeHGlobal(client.PacketData);
}
return(HandleResult.Error);
}
AddLog($"OnClose({connId}), socket operation: {socketOperation}, error code: {errorCode}");
return(HandleResult.Ok);
}
HandleResult server_OnClose(IntPtr connId, SocketOperation enOperation, int errorCode)
{
if (OnMessage != null)
{
if (errorCode == 0)
{
OnMessage(string.Format(" > [{0},OnClose {1}------port:{2}]", connId, enOperation.ToString(), server.Port));
}
else
{
OnMessage(string.Format(" > [{0},OnError] -> OP:{1},CODE:{2} ------port:{3}", connId, enOperation, errorCode, server.Port));
}
if (extra.Remove(connId) == false)
{
OnMessage(string.Format(" > [{0},OnClose] -> SetConnectionExtra({0}, null) fail ------port:{1}", connId, server.Port));
}
return(HandleResult.Ok);
}
throw new Exception("端口为" + server.Port + "的服务器close失败");
}
HandleResult OnClose(TcpServer sender, IntPtr connId, SocketOperation enOperation, int errorCode)
{
if (errorCode == 0)
{
// 客户离开了
AddMsg(string.Format(" > [{0},OnClose]", connId));
}
else
{
// 客户出错了
AddMsg(string.Format(" > [{0},OnError] -> OP:{1},CODE:{2}", connId, enOperation, errorCode));
}
// return HPSocketSdk.HandleResult.Ok;
// 释放附加数据
if (server.RemoveExtra(connId) == false)
{
AddMsg(string.Format(" > [{0},OnClose] -> SetConnectionExtra({0}, null) fail", connId));
}
return(HandleResult.Ok);
}
private void AssertCounter(SocketOperation operation, Func<MockServerSocket4, long> delegatingRetriever, Func<PerformanceCounter> counterRetriever, int expectedCount)
{
MockServerSocket4 mockServerSocket = new MockServerSocket4();
IServerSocket4 serverSocket = new MonitoredServerSocket4(mockServerSocket);
FileSession().WithEnvironment(
delegate
{
IList<ISocket4> clients = new List<ISocket4>();
for (int i = 0; i < ClientCount; i++)
{
clients.Add(serverSocket.Accept());
}
for (int i = 0; i < clients.Count; i++)
{
operation(clients[i], i);
}
});
Assert.AreEqual(expectedCount, delegatingRetriever(mockServerSocket));
Assert.AreEqual(expectedCount, counterRetriever().RawValue);
}
private HandleResult AgentClose(IAgent sender, IntPtr connId, SocketOperation socketOperation, int errorCode)
{
var extra = sender.GetExtra <TcpPortForwardingExtra>(connId);
if (extra == null)
{
if (sender.GetConnectionExtra(connId, out var serverConnId) && serverConnId != IntPtr.Zero)
{
_server.Disconnect(serverConnId);
}
}
else
{
sender.RemoveExtra(connId);
if (extra.ReleaseType == TcpPortForwardingReleaseType.None)
{
extra.ReleaseType = TcpPortForwardingReleaseType.Agent;
extra.Server.Disconnect(extra.ServerConnId);
}
}
return(OnAgentClose?.Invoke(sender, connId, socketOperation, errorCode) ?? HandleResult.Ok);
}
private void AssertCounter(SocketOperation operation, Func <MockServerSocket4, long> delegatingRetriever, Func <PerformanceCounter> counterRetriever, int expectedCount)
{
MockServerSocket4 mockServerSocket = new MockServerSocket4();
IServerSocket4 serverSocket = new MonitoredServerSocket4(mockServerSocket);
FileSession().WithEnvironment(
delegate
{
IList <ISocket4> clients = new List <ISocket4>();
for (int i = 0; i < ClientCount; i++)
{
clients.Add(serverSocket.Accept());
}
for (int i = 0; i < clients.Count; i++)
{
operation(clients[i], i);
}
});
Assert.AreEqual(expectedCount, delegatingRetriever(mockServerSocket));
Assert.AreEqual(expectedCount, counterRetriever().RawValue);
}
public void Init(Socket socket, object state, AsyncCallback callback, SocketOperation operation, SocketAsyncWorker worker)
{
this.socket = socket;
this.is_blocking = socket != null ? socket.is_blocking : true;
this.handle = socket != null ? socket.Handle : IntPtr.Zero;
this.state = state;
this.callback = callback;
this.operation = operation;
if (wait_handle != null)
{
((ManualResetEvent)wait_handle).Reset();
}
delayed_exception = null;
EndPoint = null;
Buffer = null;
Offset = 0;
Size = 0;
SockFlags = SocketFlags.None;
AcceptSocket = null;
Addresses = null;
Port = 0;
Buffers = null;
ReuseSocket = false;
accept_socket = null;
total = 0;
completed_synchronously = false;
completed = false;
is_blocking = false;
error = 0;
async_result = null;
EndCalled = 0;
Worker = worker;
}
HandleResult OnClose(IntPtr connId, SocketOperation enOperation, int errorCode)
{
--m_curPlayerCount;
// 日志
{
PlayerData playerData = GameUtil.getPlayerDataByConnId(connId);
if (playerData != null)
{
RoomData room = GameUtil.getRoomByUid(playerData.m_uid);
if (room != null)
{
// 游戏在线统计
Request_OnlineStatistics.doRequest(playerData.m_uid, room.getRoomId(), room.m_gameRoomType, playerData.m_isAI, (int)Request_OnlineStatistics.OnlineStatisticsType.OnlineStatisticsType_exit);
LogUtil.getInstance().writeRoomLog(room, "与客户端断开:" + connId);
}
else
{
LogUtil.getInstance().addDebugLog("与客户端断开:" + connId);
}
}
else
{
LogUtil.getInstance().addDebugLog("与客户端断开:" + connId);
}
}
//Thread thread = new Thread(hasPlayerExit);
//thread.Start(connId);
Task t = new Task(() => { hasPlayerExit(connId); });
t.Start();
return(HandleResult.Ok);
}
public void Init (Socket sock, object state, AsyncCallback callback, SocketOperation operation)
{
this.Sock = sock;
if (sock != null) {
this.blocking = sock.blocking;
this.handle = sock.socket;
} else {
this.blocking = true;
this.handle = IntPtr.Zero;
}
this.state = state;
this.callback = callback;
this.operation = operation;
SockFlags = SocketFlags.None;
if (waithandle != null)
((ManualResetEvent) waithandle).Reset ();
delayedException = null;
EndPoint = null;
Buffer = null;
Offset = 0;
Size = 0;
SockFlags = 0;
AcceptSocket = null;
Addresses = null;
Port = 0;
Buffers = null;
ReuseSocket = false;
acc_socket = null;
total = 0;
completed_sync = false;
completed = false;
blocking = false;
error = 0;
ares = null;
EndCalled = 0;
}
SocketAsyncCall GetDelegate (Worker worker, SocketOperation op)
{
switch (op) {
case SocketOperation.ReceiveGeneric:
goto case SocketOperation.Receive;
case SocketOperation.Receive:
return new SocketAsyncCall (worker.Receive);
case SocketOperation.ReceiveFrom:
return new SocketAsyncCall (worker.ReceiveFrom);
case SocketOperation.SendGeneric:
goto case SocketOperation.Send;
case SocketOperation.Send:
return new SocketAsyncCall (worker.Send);
case SocketOperation.SendTo:
return new SocketAsyncCall (worker.SendTo);
default:
return null; // never happens
}
}
HandleResult OnClose(IntPtr connId, SocketOperation enOperation, int errorCode)
{
if(errorCode == 0)
// 客户离开了
AddMsg(string.Format(" > [{0},OnClose]", connId));
else
// 客户出错了
AddMsg(string.Format(" > [{0},OnError] -> OP:{1},CODE:{2}", connId, enOperation, errorCode));
// return HPSocketSdk.HandleResult.Ok;
// 释放附加数据
if (server.SetConnectionExtra(connId, null) == false)
{
AddMsg(string.Format(" > [{0},OnClose] -> SetConnectionExtra({0}, null) fail", connId));
}
return HandleResult.Ok;
}
public SocketAsyncResult (Socket socket, object state, AsyncCallback callback, SocketOperation operation)
{
Init (socket, state, callback, operation, new SocketAsyncWorker (this));
}
HandleResult OnError(TcpClient sender, SocketOperation enOperation, int errorCode)
{
// 出错了
return HandleResult.Ok;
}
public SocketAsyncResult (Socket socket, AsyncCallback callback, object state, SocketOperation operation)
: base (callback, state)
{
this.socket = socket;
this.operation = operation;
}
SocketAsyncOperation SocketOperationToSocketAsyncOperation (SocketOperation op)
{
switch (op) {
case SocketOperation.Connect:
return SocketAsyncOperation.Connect;
case SocketOperation.Accept:
return SocketAsyncOperation.Accept;
case SocketOperation.Disconnect:
return SocketAsyncOperation.Disconnect;
case SocketOperation.Receive:
case SocketOperation.ReceiveGeneric:
return SocketAsyncOperation.Receive;
case SocketOperation.ReceiveFrom:
return SocketAsyncOperation.ReceiveFrom;
case SocketOperation.Send:
case SocketOperation.SendGeneric:
return SocketAsyncOperation.Send;
case SocketOperation.SendTo:
return SocketAsyncOperation.SendTo;
default:
throw new NotImplementedException (String.Format ("Operation {0} is not implemented", op));
}
}
HandleResult OnError(IntPtr dwConnId, SocketOperation enOperation, int iErrorCode)
{
// 出错了
return HandleResult.Ok;
}
HandleResult OnError(IntPtr connId, SocketOperation enOperation, int errorCode)
{
// 客户出错了
AddMsg(string.Format(" > [{0},OnError] -> OP:{1},CODE:{2}", connId, enOperation, errorCode));
Calculate();
return HandleResult.Ok;
}
HandleResult OnError(uint dwConnID, SocketOperation enOperation, int iErrorCode)
{
// 出错了
return HandleResult.Ok;
}
HandleResult OnError(IntPtr connId, SocketOperation enOperation, int errorCode)
{
// 客户出错了
Output.LogDefault(string.Format(" > [{0},OnError] -> OP:{1},CODE:{2}", connId, enOperation, errorCode));
// return HPSocketSdk.HandleResult.Ok;
// 因为要释放附加数据,所以直接返回OnClose()了
return OnClose(connId);
}
//当触发了OnClose事件时，表示连接已经被关闭，并且OnClose事件只会被触发一次
//通过errorCode参数判断是正常关闭还是异常关闭，0表示正常关闭
private HandleResult server_OnClose(IServer sender, IntPtr connId, SocketOperation enOperation, int errorCode)
{
Svc.UpdateConnStatus((uint)connId, false);
return(HandleResult.Ok);
}
/// <summary>
/// 出错了
/// </summary>
/// <param name="connId"></param>
/// <param name="enOperation"></param>
/// <param name="errorCode"></param>
/// <returns></returns>
protected virtual HandleResult OnServerClose(IntPtr connId, SocketOperation enOperation, int errorCode)
{
if (errorCode == 0)
AddMsg(string.Format(" > [{0},OnServerClose]", connId));
else
AddMsg(string.Format(" > [{0},OnServerError] -> OP:{1},CODE:{2}", connId, enOperation, errorCode));
// return HPSocketSdk.HandleResult.Ok;
// 获取附加数据
IntPtr extraPtr = IntPtr.Zero;
if (server.GetConnectionExtra(connId, ref extraPtr) == false)
{
return HandleResult.Error;
}
// extra 就是accept里传入的附加数据了
ConnExtraData extra = (ConnExtraData)Marshal.PtrToStructure(extraPtr, typeof(ConnExtraData));
if (extra.FreeType == 0)
{
// 由client(N)断开连接,释放agent数据
agent.Disconnect(extra.ConnIdForClient);
agent.SetConnectionExtra(extra.ConnIdForClient, null);
}
server.SetConnectionExtra(connId, null);
return HandleResult.Ok;
}
public SocketAsyncResult(Socket socket, AsyncCallback callback, object state, SocketOperation operation)
: base(callback, state)
{
this.socket = socket;
this.operation = operation;
}
/// <summary>
/// 出错了
/// </summary>
/// <param name="connId"></param>
/// <param name="enOperation"></param>
/// <param name="errorCode"></param>
/// <returns></returns>
protected virtual HandleResult OnAgentClose(IntPtr connId, SocketOperation enOperation, int errorCode)
{
if(errorCode == 0)
AddMsg(string.Format(" > [{0},OnAgentClose]", connId));
else
AddMsg(string.Format(" > [{0},OnAgentError] -> OP:{1},CODE:{2}", connId, enOperation, errorCode));
// return HPSocketSdk.HandleResult.Ok;
// 获取附加数据
IntPtr extraPtr = IntPtr.Zero;
if (agent.GetConnectionExtra(connId, ref extraPtr) == false)
{
return HandleResult.Error;
}
ConnExtraData extra = (ConnExtraData)Marshal.PtrToStructure(extraPtr, typeof(ConnExtraData));
agent.SetConnectionExtra(connId, null);
if (extra.FreeType == 0)
{
// 由Target断开连接,释放server连接
extra.FreeType = 1;
server.SetConnectionExtra(extra.ConnIdForServer, extra);
extra.Server.Disconnect(extra.ConnIdForServer);
}
return HandleResult.Ok;
}
/// <summary>
/// 出错了
/// </summary>
/// <param name="dwConnID"></param>
/// <param name="enOperation"></param>
/// <param name="iErrorCode"></param>
/// <returns></returns>
protected virtual HandleResult OnError(uint dwConnID, SocketOperation enOperation, int iErrorCode)
{
return HandleResult.Ok;
}
HandleResult OnClose(IntPtr connId, SocketOperation enOperation, int errorCode)
{
if(errorCode == 0)
AddMsg(string.Format(" > [{0},OnClose]", connId));
else
AddMsg(string.Format(" > [{0},OnError] -> OP:{1},CODE:{2}", connId, enOperation, errorCode));
Calculate();
return HandleResult.Ok;
}
/* This is called when reusing a SocketAsyncEventArgs */
public void Init (Socket sock, SocketAsyncEventArgs args, SocketOperation op)
{
result.Init (sock, args, SocketAsyncEventArgs.Dispatcher, op);
result.Worker = this;
SocketAsyncOperation async_op;
// Notes;
// -SocketOperation.AcceptReceive not used in SocketAsyncEventArgs
// -SendPackets and ReceiveMessageFrom are not implemented yet
if (op == Socket.SocketOperation.Connect)
async_op = SocketAsyncOperation.Connect;
else if (op == Socket.SocketOperation.Accept)
async_op = SocketAsyncOperation.Accept;
else if (op == Socket.SocketOperation.Disconnect)
async_op = SocketAsyncOperation.Disconnect;
else if (op == Socket.SocketOperation.Receive || op == Socket.SocketOperation.ReceiveGeneric)
async_op = SocketAsyncOperation.Receive;
else if (op == Socket.SocketOperation.ReceiveFrom)
async_op = SocketAsyncOperation.ReceiveFrom;
/*
else if (op == Socket.SocketOperation.ReceiveMessageFrom)
async_op = SocketAsyncOperation.ReceiveMessageFrom;
*/
else if (op == Socket.SocketOperation.Send || op == Socket.SocketOperation.SendGeneric)
async_op = SocketAsyncOperation.Send;
/*
else if (op == Socket.SocketOperation.SendPackets)
async_op = SocketAsyncOperation.SendPackets;
*/
else if (op == Socket.SocketOperation.SendTo)
async_op = SocketAsyncOperation.SendTo;
else
throw new NotImplementedException (String.Format ("Operation {0} is not implemented", op));
args.SetLastOperation (async_op);
args.SocketError = SocketError.Success;
args.BytesTransferred = 0;
}
/// <summary>
/// 出错了
/// </summary>
/// <param name="connId"></param>
/// <param name="enOperation"></param>
/// <param name="errorCode"></param>
/// <returns></returns>
protected virtual HandleResult OnServerError(IntPtr connId, SocketOperation enOperation, int errorCode)
{
AddMsg(string.Format(" > [{0},OnServerError] -> OP:{1},CODE:{2}", connId, enOperation, errorCode));
// return HPSocketSdk.HandleResult.Ok;
// 因为要释放附加数据,所以直接返回OnServerClose()了
return OnServerClose(connId);
}
// ReSharper disable once InconsistentNaming
private HandleResult OnClose(IClient sender, SocketOperation socketOperation, int errorCode)
{
AddLog($"OnClose(), socket operation: {socketOperation}, error code: {errorCode}");
return(HandleResult.Ok);
}
HandleResult OnError(uint dwConnID, SocketOperation enOperation, int iErrorCode)
{
// 出错了
return(HandleResult.Ok);
}
HandleResult OnError(uint dwConnID, SocketOperation enOperation, int iErrorCode)
{
// 出错了
AddMsg(string.Format(" > [{0},OnError] -> OP:{1},CODE:{2}", dwConnID, enOperation, iErrorCode));
// 通知界面,只处理了连接错误,也没进行是不是连接错误的判断,所以有错误就会设置界面
// 生产环境请自己控制
this.Invoke(new SetAppStateDelegate(SetAppState), AppState.Stoped);
return HandleResult.Ok;
}
private static HandleResult Client_OnClose(TcpClient sender, SocketOperation enOperation, int errorCode)
{
return(HandleResult.Ok);
}
public void Init (Socket socket, object state, AsyncCallback callback, SocketOperation operation, SocketAsyncWorker worker)
{
this.socket = socket;
this.is_blocking = socket != null ? socket.is_blocking : true;
this.handle = socket != null ? socket.Handle : IntPtr.Zero;
this.state = state;
this.callback = callback;
this.operation = operation;
if (wait_handle != null)
((ManualResetEvent) wait_handle).Reset ();
delayed_exception = null;
EndPoint = null;
Buffer = null;
Offset = 0;
Size = 0;
SockFlags = SocketFlags.None;
AcceptSocket = null;
Addresses = null;
Port = 0;
Buffers = null;
ReuseSocket = false;
accept_socket = null;
total = 0;
completed_synchronously = false;
completed = false;
is_blocking = false;
error = 0;
async_result = null;
EndCalled = 0;
Worker = worker;
}
public RequestContext(SocketOperation operation, ByteBuf data)
{
Operation = operation;
Data = data;
}
/// <summary>
/// 出错了
/// </summary>
/// <param name="dwConnId"></param>
/// <param name="enOperation"></param>
/// <param name="iErrorCode"></param>
/// <returns></returns>
protected virtual HandleResult OnError(IntPtr dwConnId, SocketOperation enOperation, int iErrorCode)
{
return(HandleResult.Ok);
}
public SocketAsyncResult (Socket socket, AsyncCallback callback, object state, SocketOperation operation)
: base (callback, state)
{
this.socket = socket;
this.handle = socket != null ? socket.Handle : IntPtr.Zero;
this.operation = operation;
}
public SocketAsyncResult (Socket sock, object state, AsyncCallback callback, SocketOperation operation)
{
this.Sock = sock;
this.blocking = sock.blocking;
this.handle = sock.socket;
this.state = state;
this.callback = callback;
this.operation = operation;
SockFlags = SocketFlags.None;
}
public RequestContext(SocketOperation operation, ByteBuf data)
{
Operation = operation;
Data = data;
}
/* This is called when reusing a SocketAsyncEventArgs */
public void Init (Socket sock, object state, AsyncCallback callback, SocketOperation op)
{
result.Init (sock, state, callback, op);
SocketAsyncOperation async_op;
// Notes;
// -SocketOperation.AcceptReceive not used in SocketAsyncEventArgs
// -SendPackets and ReceiveMessageFrom are not implemented yet
if (op == Socket.SocketOperation.Connect)
async_op = SocketAsyncOperation.Connect;
#if !MOONLIGHT
else if (op == Socket.SocketOperation.Accept)
async_op = SocketAsyncOperation.Accept;
else if (op == Socket.SocketOperation.Disconnect)
async_op = SocketAsyncOperation.Disconnect;
#endif
else if (op == Socket.SocketOperation.Receive || op == Socket.SocketOperation.ReceiveGeneric)
async_op = SocketAsyncOperation.Receive;
#if !MOONLIGHT
else if (op == Socket.SocketOperation.ReceiveFrom)
async_op = SocketAsyncOperation.ReceiveFrom;
#endif
/*
else if (op == Socket.SocketOperation.ReceiveMessageFrom)
async_op = SocketAsyncOperation.ReceiveMessageFrom;
*/
else if (op == Socket.SocketOperation.Send || op == Socket.SocketOperation.SendGeneric)
async_op = SocketAsyncOperation.Send;
#if !MOONLIGHT
/*
else if (op == Socket.SocketOperation.SendPackets)
async_op = SocketAsyncOperation.SendPackets;
*/
else if (op == Socket.SocketOperation.SendTo)
async_op = SocketAsyncOperation.SendTo;
#endif
else
throw new NotImplementedException (String.Format ("Operation {0} is not implemented", op));
args.SetLastOperation (async_op);
args.SocketError = SocketError.Success;
}
/* This is called when reusing a SocketAsyncEventArgs */
public void Init (Socket sock, SocketAsyncEventArgs args, SocketOperation op)
{
result.Init (sock, args, SocketAsyncEventArgs.Dispatcher, op, this);
SocketAsyncOperation async_op;
// Notes;
// -SocketOperation.AcceptReceive not used in SocketAsyncEventArgs
// -SendPackets and ReceiveMessageFrom are not implemented yet
switch (op) {
case SocketOperation.Connect:
async_op = SocketAsyncOperation.Connect;
break;
case SocketOperation.Accept:
async_op = SocketAsyncOperation.Accept;
break;
case SocketOperation.Disconnect:
async_op = SocketAsyncOperation.Disconnect;
break;
case SocketOperation.Receive:
case SocketOperation.ReceiveGeneric:
async_op = SocketAsyncOperation.Receive;
break;
case SocketOperation.ReceiveFrom:
async_op = SocketAsyncOperation.ReceiveFrom;
break;
// case SocketOperation.ReceiveMessageFrom:
// async_op = SocketAsyncOperation.ReceiveMessageFrom;
// break;
case SocketOperation.Send:
case SocketOperation.SendGeneric:
async_op = SocketAsyncOperation.Send;
break;
// case SocketOperation.SendPackets:
// async_op = SocketAsyncOperation.SendPackets;
// break;
case SocketOperation.SendTo:
async_op = SocketAsyncOperation.SendTo;
break;
default:
throw new NotImplementedException (String.Format ("Operation {0} is not implemented", op));
}
args.SetLastOperation (async_op);
args.SocketError = SocketError.Success;
args.BytesTransferred = 0;
}
private HandleResult SslClient_OnClose(IClient sender, SocketOperation socketOperation, int errorCode)
{
DataReceiveAdapter.OnClose(ConnectionId);
return(HandleResult.Ok);
}
public SocketAsyncResult (Socket sock, object state, AsyncCallback callback, SocketOperation operation)
{
this.Sock = sock;
this.blocking = sock.blocking;
this.handle = sock.socket;
this.state = state;
this.callback = callback;
GC.KeepAlive (this.callback);
this.operation = operation;
SockFlags = SocketFlags.None;
Worker = new Worker (this);
}
void InitSocketAsyncEventArgs (SocketAsyncEventArgs e, AsyncCallback callback, object state, SocketOperation operation)
{
e.socket_async_result.Init (this, callback, state, operation);
e.current_socket = this;
e.SetLastOperation (SocketOperationToSocketAsyncOperation (operation));
e.SocketError = SocketError.Success;
e.BytesTransferred = 0;
}
HandleResult OnError(uint dwConnID, SocketOperation enOperation, int iErrorCode)
{
// 客户出错了
AddMsg(string.Format(" > [{0},OnError] -> OP:{1},CODE:{2}", dwConnID, enOperation, iErrorCode));
// return HPSocketSdk.HandleResult.Ok;
// 因为要释放附加数据,所以直接返回OnClose()了
return OnClose(dwConnID);
}
// ReSharper disable once InconsistentNaming
private HandleResult OnClose(IServer sender, IntPtr connId, SocketOperation socketOperation, int errorCode)
{
AddLog($"OnClose({connId}), socket operation: {socketOperation}, error code: {errorCode}");
return(HandleResult.Ok);
}
HandleResult client_OnClose(TcpClient sender, SocketOperation enOperation, int errorCode)
{
WriteLog("授权信息已失效，请重新授权!");
this.isAccess = false;
return(HandleResult.Ignore);
}
HandleResult Service_OnClose(TcpServer server, IntPtr connId, SocketOperation enOperation, int errorCode)
{
this.RemoveExtra(connId);
return(HandleResult.Ok);
}
private HandleResult TcpServer_OnClose(IServer sender, IntPtr connId, SocketOperation socketOperation, int errorCode)
{
DataReceiveAdapter.OnClose(connId);
return(HandleResult.Ok);
}
