/// <summary> /// Dequeuer. Read the receive queue and raise the receive event for each message /// </summary> /// <param name="stateObj">The received message</param> protected virtual void ReceiveDequeuer() { while (!this.flagShutdown) { ReceiveMessageStateObject message = null; try { message = receiveQueue.Take(this.cancellationToken.Token); } catch (OperationCanceledException ex) { Trace.WriteLine("A cancel operation was request. A shutdown will be done."); this.flagShutdown = true; } if (flagShutdown) { break; } if (message != null) { //Trace.WriteLine(string.Format("Remove Message {0} Client {1} from the receive queue and raise event", message.Message.MessageUID, message.Message.ClientUID)); message.Handler.RaiseReceiveMessageEvent(message); } } }
/// <summary> /// Dequeuer. Read the receive queue and raise the receive event for each message /// </summary> /// <param name="stateObj">The received message</param> protected virtual void ReceiveDequeuer() { while (!this.flagShutdown) { ReceiveMessageStateObject message = null; try { message = receiveQueue.Take(this.cancellationToken.Token); } catch (OperationCanceledException ex) { Trace.WriteLine("A cancel operation was request. A shutdown will be done."); this.flagShutdown = true; } if (flagShutdown) { OnCloseConnection(this); break; } if (message != null) { message.Handler.RaiseReceiveMessageEvent(message); } } }
/// <summary> /// Raise a received message event. This method is running in the same thread of the caller. /// </summary> /// <param name="stateObj">The receive message state object</param> protected void RaiseReceiveMessageEvent(object stateObj) { if (receiveMessageEvent != null) { ReceiveMessageStateObject rcvObj = (ReceiveMessageStateObject)stateObj; receiveMessageEvent(rcvObj.Handler, rcvObj.Message); } }
/// <summary> /// Handle a received message. A received message event is raise but in a new thread in order to not block the main thread. /// Override this method to change the behavior. /// </summary> /// <param name="rcvObj">The received object</param> protected virtual void OnReceiveMessage(ReceiveMessageStateObject rcvObj) { if (this.receiveQueue != null) { this.receiveQueue.Add(rcvObj); return; } ThreadPool.QueueUserWorkItem(new WaitCallback(rcvObj.Handler.RaiseReceiveMessageEvent), rcvObj); }
/// <summary> /// Handle a received message. A received message event is raise but in a new thread in order to not block the main thread. /// Override this method to change the behavior. /// </summary> /// <param name="rcvObj">The received object</param> protected virtual void OnReceiveMessage(ReceiveMessageStateObject rcvObj) { if (this.receiveQueue != null) { //Trace.WriteLine(string.Format("Add Message {0} from Client {1} in the receive queue", rcvObj.Message.MessageUID, rcvObj.Message.ClientUID)); this.receiveQueue.Add(rcvObj); return; } ThreadPool.QueueUserWorkItem(new WaitCallback(rcvObj.Handler.RaiseReceiveMessageEvent), rcvObj); }
/// <summary> /// Callback for asynchronous receiving. /// </summary> /// <param name="ar">The socket state object for receiving data</param> private static void ProcessReceive(SocketAsyncEventArgs e) { AbstractAsyncTcpSocketClientHandler handler = (AbstractAsyncTcpSocketClientHandler)e.UserToken; try { while (true) { //Trace.WriteLine(string.Format("Receive {0} bytes", e.BytesTransferred)); if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success) { int read = e.BytesTransferred; // Fire event for incoming message handler.OnReceivingMessage(handler); while (true) { AbstractMessage message = AbstractMessage.TryReadMessage(handler.GetMessageInstance(), handler.stateObject, read); // Fire event for received message if (message != null) { ReceiveMessageStateObject rcvObj = new ReceiveMessageStateObject() { Handler = handler, Message = message }; handler.OnReceiveMessage(rcvObj); } if (handler.stateObject.pendingBuffer == null) { break; } read = 0; } bool flagPending = ((TcpSocketAsync)handler.socket).ReceiveAsync(e); if (flagPending) { break; } } else { Trace.WriteLine(string.Format("SocketError {0}.", e.SocketError)); handler.Close(); break; } } } catch (MessageException mex) { // Invalid message Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", mex)); handler.Close(); } catch (SocketException sex) { if (sex.SocketErrorCode == SocketError.ConnectionReset || sex.SocketErrorCode == SocketError.ConnectionAborted) { Trace.WriteLine(string.Format("Socket error for disconnection {0} : {1} : {2}. Client will be disconnected", sex.ErrorCode, sex.SocketErrorCode, sex.Message)); handler.stateObject.message = null; handler.stateObject.pendingBuffer = null; handler.Close(); } else { Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", sex)); handler.stateObject.message = null; handler.stateObject.pendingBuffer = null; handler.Close(); } } catch (Exception ex) { Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", ex)); handler.stateObject.message = null; handler.stateObject.pendingBuffer = null; handler.Close(); } }
/// <summary> /// Callback for asynchronous receiving. /// </summary> /// <param name="ar">The socket state object for receiving data</param> protected static void ReadCallback(IAsyncResult ar) { SocketStateObject state = (SocketStateObject)ar.AsyncState; AbstractTcpSocketClientHandler handler = state.workHandler; try { // Read data from the client socket. int read = handler.EndReceive(ar); Trace.WriteLine(string.Format("Receive {0} bytes", read)); // Data was read from the client socket. if (read > 0) { // Fire event for incoming message handler.OnReceivingMessage(handler); while (true) { AbstractMessage message = AbstractMessage.TryReadMessage(handler.GetMessageInstance(), state, read); // Fire event for received message if (message != null) { ReceiveMessageStateObject rcvObj = new ReceiveMessageStateObject() { Handler = handler, Message = message }; handler.OnReceiveMessage(rcvObj); } if (state.pendingBuffer == null) { break; } read = 0; } handler.socket.BeginReceive(state, new AsyncCallback(ReadCallback)); } else { handler.Close(); } } catch (MessageException mex) { // Invalid message Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", mex)); state.message = null; state.pendingBuffer = null; handler.Close(); } catch (SocketException sex) { if (sex.SocketErrorCode == SocketError.ConnectionReset || sex.SocketErrorCode == SocketError.ConnectionAborted) { Trace.WriteLine(string.Format("Socket error for disconnection {0} : {1} : {2}. Client will be disconnected", sex.ErrorCode, sex.SocketErrorCode, sex.Message)); state.message = null; state.pendingBuffer = null; handler.Close(); } else { Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", sex)); state.message = null; state.pendingBuffer = null; handler.Close(); } } catch (Exception ex) { Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", ex)); state.message = null; state.pendingBuffer = null; handler.Close(); } }
/// <summary> /// Handle a received message. A received message event is raise but in a new thread in order to not block the main thread. /// Override this method to change the behavior. /// </summary> /// <param name="rcvObj">The received object</param> protected virtual void OnReceiveMessage(ReceiveMessageStateObject rcvObj) { if (this.receiveQueue != null) { Trace.WriteLine(string.Format("Add Message {0} from Client {1} in the receive queue", rcvObj.Message.MessageUID, rcvObj.Message.ClientUID)); this.receiveQueue.Add(rcvObj); return; } ThreadPool.QueueUserWorkItem(new WaitCallback(rcvObj.Handler.RaiseReceiveMessageEvent), rcvObj); }
/// <summary> /// Callback for asynchronous receiving. /// </summary> /// <param name="ar">The socket state object for receiving data</param> private static void ProcessReceive(SocketAsyncEventArgs e) { AbstractAsyncTcpSocketClientHandler handler = (AbstractAsyncTcpSocketClientHandler)e.UserToken; try { while (true) { Trace.WriteLine(string.Format("Receive {0} bytes", e.BytesTransferred)); if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success) { int read = e.BytesTransferred; // Fire event for incoming message handler.OnReceivingMessage(handler); while (true) { AbstractMessage message = AbstractMessage.TryReadMessage(handler.GetMessageInstance(), handler.stateObject, read); // Fire event for received message if (message != null) { ReceiveMessageStateObject rcvObj = new ReceiveMessageStateObject() { Handler = handler, Message = message }; handler.OnReceiveMessage(rcvObj); } if (handler.stateObject.pendingBuffer == null) { break; } read = 0; } bool flagPending = ((TcpSocketAsync)handler.socket).ReceiveAsync(e); if (flagPending) { break; } } else { Trace.WriteLine(string.Format("SocketError {0}.", e.SocketError)); handler.Close(); break; } } } catch (MessageException mex) { // Invalid message Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", mex)); handler.Close(); } catch (SocketException sex) { if (sex.SocketErrorCode == SocketError.ConnectionReset || sex.SocketErrorCode == SocketError.ConnectionAborted) { Trace.WriteLine(string.Format("Socket error for disconnection {0} : {1} : {2}. Client will be disconnected", sex.ErrorCode, sex.SocketErrorCode, sex.Message)); handler.stateObject.message = null; handler.stateObject.pendingBuffer = null; handler.Close(); } else { Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", sex)); handler.stateObject.message = null; handler.stateObject.pendingBuffer = null; handler.Close(); } } catch (Exception ex) { Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", ex)); handler.stateObject.message = null; handler.stateObject.pendingBuffer = null; handler.Close(); } }