C# IByteBuffer.ReadBytes方法代码示例

        static IByteBuffer ApplyCompression(IByteBuffer buffer, CompressionMode compressionMode)
        {
            try
            {
                using (var outputStream = new MemoryStream())
                {
                    using (var gzipStream = new GZipStream(outputStream, compressionMode, true))
                    {
                        buffer.ReadBytes(gzipStream, buffer.ReadableBytes);
                    }

                    Contract.Assert(outputStream.Length <= int.MaxValue);

                    return Unpooled.WrappedBuffer(outputStream.GetBuffer(), 0, (int)outputStream.Length);
                }
            }
            finally
            {
                ReferenceCountUtil.Release(buffer);
            }
        }

 /// <summary>
 /// Read the given amount of bytes into a new {@link ByteBuf} that is allocated from the {@link ByteBufAllocator}.
 /// </summary>
 public static IByteBuffer ReadBytes(IByteBufferAllocator alloc, IByteBuffer buffer, int length)
 {
     bool release = true;
     IByteBuffer dst = alloc.Buffer(length);
     try
     {
         buffer.ReadBytes(dst);
         release = false;
         return dst;
     }
     finally
     {
         if (release)
         {
             dst.Release();
         }
     }
 }

            public void AcceptBytes(IByteBuffer input)
            {
                TaskCompletionSource<int> tcs = this.readCompletionSource;
                if (tcs == null)
                {
                    // there is no pending read operation - keep for future
                    this.pendingReadBuffer = input;
                    return;
                }

                ArraySegment<byte> sslBuffer = this.sslOwnedBuffer;

                Contract.Assert(sslBuffer.Array != null);

                int readableBytes = input.ReadableBytes;
                int length = Math.Min(sslBuffer.Count, readableBytes);
                input.ReadBytes(sslBuffer.Array, sslBuffer.Offset, length);
                tcs.TrySetResult(length);
                if (length < readableBytes)
                {
                    // set buffer for consecutive read to use
                    this.pendingReadBuffer = input;
                }

                AsyncCallback callback = this.readCallback;
                if (callback != null)
                {
                    callback(tcs.Task);
                }
            }

 /// <summary>
 /// Writes bytes.
 /// </summary>
 /// <param name="source">The bytes (in the form of an IByteBuffer).</param>
 /// <exception cref="System.ObjectDisposedException">ByteArrayBuffer</exception>
 /// <exception cref="System.InvalidOperationException">Write operations are not allowed for read only buffers.</exception>
 public void WriteBytes(IByteBuffer source)
 {
     ThrowIfDisposed();
     EnsureIsWritable();
     var count = source.Length;
     EnsureSpaceAvailable(count);
     var savedPosition = source.Position;
     source.Position = 0;
     source.ReadBytes(_bytes, _sliceOffset + _position, count);
     _position += count;
     if (_length < _position)
     {
         _length = _position;
     }
     source.Position = savedPosition;
 }

        /// <summary>
        /// Writes bytes.
        /// </summary>
        /// <param name="source">The bytes (in the form of an IByteBuffer).</param>
        /// <exception cref="System.ObjectDisposedException">MultiChunkBuffer</exception>
        /// <exception cref="System.InvalidOperationException">The MultiChunkBuffer is read only.</exception>
        public void WriteBytes(IByteBuffer source)
        {
            ThrowIfDisposed();
            EnsureIsWritable();
            EnsureSpaceAvailable(source.Length);

            var savedPosition = source.Position;
            source.Position = 0;

            var chunkIndex = (_sliceOffset + _position) / _chunkSize;
            var chunkOffset = (_sliceOffset + _position) % _chunkSize;
            var remaining = source.Length;
            while (remaining > 0)
            {
                var chunkRemaining = _chunkSize - chunkOffset;
                var bytesToCopy = (remaining < chunkRemaining) ? remaining : chunkRemaining;
                source.ReadBytes(_chunks[chunkIndex].Bytes, chunkOffset, bytesToCopy);
                chunkIndex += 1;
                chunkOffset = 0;
                remaining -= bytesToCopy;
                _position += bytesToCopy;
            }
            if (_length < _position)
            {
                _length = _position;
            }

            source.Position = savedPosition;
        }

        /// <summary>
        /// Reads the string from the byte buffer until null terminator.
        /// </summary>
        /// <param name="input">The input.</param>
        /// <returns>System.String.</returns>
        private static string ReadString(IByteBuffer input)
        {
            // Scan buffer for end of string null terminator
            for (var index = input.ReaderIndex; index < input.WriterIndex; index++)
            {
                if (input.GetByte(index) != 0xFF) continue;

                var bytes = XorArray(input.ReadBytes(index - input.ReaderIndex).ToArray());
                return Encoding.ASCII.GetString(bytes);
            }

            return string.Empty;
        }

        /// <summary>
        /// Reads the packet body.
        /// </summary>
        /// <param name="input">The input.</param>
        /// <param name="size">The size.</param>
        /// <param name="version">The packet version.</param>
        /// <returns>System.Byte[].</returns>
        private static byte[] ReadPacketBody(IByteBuffer input, int size, byte version)
        {
            var body = XorArray(input.ReadBytes(size).ToArray());

            if (version == 2)
                body = ZLibInflate(body);

            return body;
        }