C# ISocket.Read方法代码示例

        // this is horribly inefficient right now.
        static IEnumerable<object> BufferHeadersInternal(ISocket socket)
        {
            LinkedList<ArraySegment<byte>> result = new LinkedList<ArraySegment<byte>>();

            int bufferPosition = 0, totalBytesRead = 0;
            byte[] buffer = null;

            while (true)
            {
                if (buffer == null || bufferPosition > BufferSize / 2)
                {
                    buffer = new byte[BufferSize];
                    bufferPosition = 0;
                }

                int bytesRead = 0;

                //Trace.Write("About to read header chunk.");
                var read = new ContinuationState<int>(socket.Read(buffer, bufferPosition, buffer.Length - bufferPosition));
                yield return read;

                bytesRead = read.Result;

                //Trace.Write("Read {0} bytes.", bytesRead);

                result.AddLast(new ArraySegment<byte>(buffer, bufferPosition, bytesRead));

                if (bytesRead == 0)
                    break;

                bufferPosition += bytesRead;
                totalBytesRead += bytesRead;

                // TODO: would be nice to have a state machine and only parse once. for now
                // let's just hope to catch it on the first go-round.
                var bodyDataPosition = IndexOfAfterCRLFCRLF(result);

                if (bodyDataPosition != -1)
                {
                    var last = result.Last.Value;
                    result.RemoveLast();
                    var overlapLength = totalBytesRead - bodyDataPosition;
                    result.AddLast(new ArraySegment<byte>(last.Array, last.Offset, last.Count - overlapLength));
                    result.AddLast(new ArraySegment<byte>(last.Array, last.Offset + last.Count - overlapLength, overlapLength));
                    break;
                }

                // TODO test this
                if (totalBytesRead > MaxHeaderLength)
                    throw new Exception("Request headers data exceeds max header length.");
            }

            yield return result;
        }

        public Action<byte[], int, int, Action<int>, Action<Exception>> CreateReadBody(
            ISocket socket,
            ArraySegment<byte> bodyDataReadWithHeaders)
        {
            return (buffer, offset, count, r, e) =>
                {
                    if (bodyDataReadWithHeaders.Count > 0)
                    {
                        int bytesRead;

                        bytesRead = Math.Min(bodyDataReadWithHeaders.Count, count);
                        Buffer.BlockCopy(bodyDataReadWithHeaders.Array, bodyDataReadWithHeaders.Offset, buffer, offset, bytesRead);

                        if (bytesRead < bodyDataReadWithHeaders.Count)
                            bodyDataReadWithHeaders =
                                new ArraySegment<byte>(
                                    bodyDataReadWithHeaders.Array,
                                    bodyDataReadWithHeaders.Offset + bytesRead,
                                    bodyDataReadWithHeaders.Count - bytesRead);
                        else
                            bodyDataReadWithHeaders = default(ArraySegment<byte>);

                        r(bytesRead);
                    }
                    else if (socket != null)
                    {
                        socket.Read(buffer, offset, count)(r, e);
                    }
                    else
                    {
                        r(0);
                    }
                };
        }

 private void ProxyThis(ISocket instream, ISocket outstream, AutoResetEvent readyToConnect)
 {
     Logger.Debug("Starting Proxy from " + instream + " to " + outstream);
     int read = 1;
     Closed = false;
     try
     {
         var inBuffer = new byte[_bufferSize];
         // listen for incoming connection
         if (!instream.Connected)
         {
             readyToConnect.Set();
             Logger.Debug("Listening for incoming connections");
             instream.ListenOnce();
             Logger.Debug("Connected incoming");
         }
         // connect to outgoing endpoint and start the reverse proxy
         if (!outstream.Connected)
         {
             outstream.Connect();
             Logger.Debug("Connected outgoing");
             _outRunner.Start();
             Logger.Debug("Started Reverse Proxy");
         }
         while (read > 0)
         {
             // Read from instream
             if (read > 0)
             {
                 try
                 {
                     read = instream.Read(inBuffer, _bufferSize);
     #if DEBUG
     //                            Logger.Debug("Read " + read + " bytes from " + instream);
     #endif
                 }
                 catch (Exception ex)
                 {
                     Logger.Error("Failed to read data from stream (" + instream + "), closing proxy : " + ex.Message);
                     break;
                 }
                 if (read > 0)
                 {
                     try
                     {
                         outstream.Send(inBuffer, read);
     #if DEBUG
                         //Logger.Debug("Wrote " + read + " bytes to " + outstream);
     #endif
                     }
                     catch (Exception ex)
                     {
                         Logger.Error("Failed to send data through stream (" + instream + ") , closing proxy : " + ex.Message);
                         break;
                     }
                 }
             }
             else
             {
                 Logger.Warn("Read no data from (" + instream + "), closing proxy");
             }
         }
     }
     catch (Exception ex)
     {
         Logger.Error("Thread caught exception while processing : " + ex.Message, ex);
     }
     finally
     {
         try
         {
             instream.Close();
         }
         catch (Exception ex)
         {
             Logger.Error("Caught Error closing stream (" + instream + ") : " + ex.Message, ex);
         }
         try
         {
             outstream.Close();
         }
         catch (Exception ex)
         {
             Logger.Error("Caught Error closing stream (" + outstream + ") : " + ex.Message, ex);
         }
     }
 }