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; }
/* 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); }