示例#1
0
 public static void StartListening(Connection connection)
 {
     Message.BeginReceive(connection, new AsyncCallback(ReceiveMessage), null);
 }
示例#2
0
        /// <summary>
        /// Receives a message over a specified Duplex Channel Connection.
        /// </summary>
        /// <param name="connection">Duplex Channel Connection</param>
        /// <param name="ar">Result (for Async pattern)</param>
        /// <returns>Received message</returns>
        public static Message EndReceive(out Connection connection, IAsyncResult ar)
        {
            AsyncResult myAr = (AsyncResult)ar;

            connection = myAr.Connection;
            try
            {
                connection.LockRead();
                if (connection.Socket == null)
                {
                    throw new MessageException("Connection closed.", null, connection);
                }

                SocketError socketError;
                int         bytesRead = connection.Socket.EndReceive(myAr.InternalAsyncResult, out socketError);
                if (bytesRead == 0 || connection.Channel == null)
                {
                    throw new MessageException("Connection closed.", new SocketException((int)socketError), connection);
                }

                // read message identifier
                var reader = connection.Reader;
                if (bytesRead < SizeOfGuid)
                {
                    var rest = reader.Read(myAr.Buffer, bytesRead, SizeOfGuid - bytesRead);
                    if (rest < SizeOfGuid - bytesRead)
                    {
                        throw new MessageException("Insufficient data received. Got " + bytesRead + " bytes.", new SocketException((int)socketError), connection);
                    }
                }

                // read message header
                Message retVal = new Message();
                retVal.Guid = new Guid(myAr.Buffer);

                int          headerLength = reader.ReadInt32();
                MemoryStream headerStream = new MemoryStream(reader.ReadBytes(headerLength));
                if (headerStream.Length != headerLength)
                {
                    throw new Exception("Not enough headers read...");
                }
                retVal.Headers = TransportHeaderWrapper.Deserialize(headerStream);

                int bodyLength = reader.ReadInt32();
                if (bodyLength > 0)
                {
                    retVal.messageBodyBytes = reader.ReadBytes(bodyLength);
                    if (retVal.messageBodyBytes.Length != bodyLength)
                    {
                        throw new Exception("Not enough body read...");
                    }

                    System.Diagnostics.Debug.Assert(retVal.MessageBody.CanRead);
                }

                Message.BeginReceive(connection, myAr.Callback, myAr.AsyncState);
                return(retVal);
            }
            catch (Exception e)
            {
                throw new MessageException("Error receiving message", e, connection);
            }
            finally
            {
                connection.ReleaseRead();
            }
        }
示例#3
0
        /// <summary>
        /// Receives a message over a specified Duplex Channel Connection.
        /// </summary>
        /// <param name="connection">Duplex Channel Connection</param>
        /// <param name="ar">Result (for Async pattern)</param>
        /// <returns>Received message</returns>
        public static Message EndReceive(out Connection connection, IAsyncResult ar)
        {
            AsyncResult myAr = (AsyncResult)ar;

            connection = myAr.Connection;
            try
            {
                connection.LockRead();
                if (connection.Socket == null)
                {
                    throw new MessageException("Connection closed.", null, connection);
                }

                int bytesRead = connection.Socket.EndReceive(myAr.InternalAsyncResult);
                if (bytesRead == 16)
                {
                    Message retVal = new Message();
                    retVal.Guid = new Guid(myAr.Buffer);
                    BinaryReader reader = connection.Reader;

                    int          headerLength = reader.ReadInt32();
                    MemoryStream headerStream = new MemoryStream(reader.ReadBytes(headerLength));
                    if (headerStream.Length != headerLength)
                    {
                        throw new Exception("Not enough headers read...");
                    }
                    retVal.Headers = TransportHeaderWrapper.Deserialize(headerStream);

                    int bodyLength = reader.ReadInt32();

                    if (bodyLength > 0)
                    {
                        retVal.messageBodyBytes = reader.ReadBytes(bodyLength);
                        if (retVal.messageBodyBytes.Length != bodyLength)
                        {
                            throw new Exception("Not enough body read...");
                        }

                        System.Diagnostics.Debug.Assert(retVal.MessageBody.CanRead);
                    }

                    Message.BeginReceive(connection, myAr.Callback, myAr.AsyncState);

                    return(retVal);
                }
                else if (bytesRead == 0)
                {
                    throw new MessageException("Connection closed.", null, connection);
                }
                else
                {
                    throw new MessageException("Insufficient data received", null, connection);
                }
            }
            catch (Exception e)
            {
                throw new MessageException("Error receiving message", e, connection);
            }
            finally
            {
                connection.ReleaseRead();
            }
        }