/// <summary> /// When a message is received on the specified UDP Multicast address/port. /// </summary> /// <remarks> /// Assumed to be not running under a thread safe context. As long as we don's access /// the socket referenced in the <see cref="MessageRequest"/> class we should be ok. /// <para></para> /// The buffer element is fine to access as it is created per call, regardless of which /// thread context has entered the ProcessMessage() method. /// </remarks> /// <param name="receivedByteCount"> /// The number of bytes available to read. /// </param> /// <param name="state"> /// The buffer state. /// </param> private void OnMessageReceived(int receivedByteCount, MessageRequest state) { if (receivedByteCount > 0) { try { state.Execute(); } catch (Exception ex) { m_Logger.Error("Exception detected handling message.", ex); } } }
/// <summary> /// When a message is received on the specified UDP Multicast address/port. /// </summary> /// <remarks> /// Assumed to run under a thread-safe context. /// </remarks> /// <param name="receivedByteCount"> /// The number of bytes available to read. /// </param> /// <param name="state"> /// The buffer state. /// </param> private void OnMessageReceived(int receivedByteCount, MessageRequest state) { if (receivedByteCount > 0) { // Copy message buffer and send it the message handler. var message = new byte[receivedByteCount]; Array.Copy(state.Buffer, message, receivedByteCount); m_MessageHandler.HandleMessage(ref message); } }
/// <summary> /// Checks to see if there is any data on the socket to process. /// </summary> /// <remarks> /// Will not block indefinitely while waiting for data or throwing /// an exception if a timeout was specified on the read. /// </remarks> public void ProcessMessage() { MessageRequest messageRequest = null; int bytesRead = 0; var logger = new ConsoleLogger(); lock (m_SyncLock) { //logger.LogFreeMemory(); if (!m_IsOpen) Open(); if (m_IsOpen) { logger.LogFreeMemory(); messageRequest = new MessageRequest(m_MessageHandler, BufferSizeInBytes); try { bool hasPayload = m_Client.Poll(PeekTimeoutInMilliseconds, SelectMode.SelectRead); if (hasPayload) { bytesRead = m_Client.Receive(messageRequest.Buffer, 0, messageRequest.Buffer.Length, SocketFlags.None); } } catch (Exception ex) { m_Logger.Error("Exception occurred receiving data from UDP socket.", ex); Close(); } } } if (bytesRead > 0) { OnMessageReceived(bytesRead, messageRequest); } if (messageRequest != null) { messageRequest.Dispose(); } //logger.LogFreeMemory(); }
/// <summary> /// Checks to see if there is any data on the socket to process. /// </summary> /// <remarks> /// Will not block indefinitely while waiting for data or throwing /// an exception if a timeout was specified on the read. /// </remarks> public void ListenForMessage() { lock (m_SyncLock) { bool hasPayload = m_Socket.Poll(PeekTimeoutInMilliseconds, SelectMode.SelectRead); if (hasPayload) { var state = new MessageRequest(m_MessageHandler, BufferSizeInBytes); EndPoint remoteendpoint = new IPEndPoint(IPAddress.Parse(m_HostName), m_Port); int bytesRead = m_Socket.ReceiveFrom(state.Buffer, 0, state.Buffer.Length, SocketFlags.None, ref remoteendpoint); this.OnMessageReceived(bytesRead, state); } } }