예제 #1
0
        public AsyncCompletionResult BeginRead(int offset, int size, TimeSpan timeout, Action <object> callback, object state)
        {
            ConnectionUtilities.ValidateBufferBounds(AsyncReadBufferSize, offset, size);
            readCallback = callback;

            try
            {
                SetReadTimeout(timeout);
                Task <int> localTask = stream.ReadAsync(AsyncReadBuffer, offset, size);

                if (!localTask.IsCompleted)
                {
                    localTask.ContinueWith(onRead, state);
                    return(AsyncCompletionResult.Queued);
                }

                bytesRead = localTask.GetAwaiter().GetResult();
            }
            catch (IOException ioException)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ConvertIOException(ioException));
            }

            return(AsyncCompletionResult.Completed);
        }
예제 #2
0
        public override int Read(byte[] buffer, int offset, int size, TimeSpan timeout)
        {
            ConnectionUtilities.ValidateBufferBounds(buffer, offset, size);

            if (preReadCount > 0)
            {
                int bytesToCopy = Math.Min(size, preReadCount);
                Buffer.BlockCopy(base.Connection.AsyncReadBuffer, preReadOffset, buffer, offset, bytesToCopy);
                preReadOffset += bytesToCopy;
                preReadCount  -= bytesToCopy;
                return(bytesToCopy);
            }

            return(base.Read(buffer, offset, size, timeout));
        }
예제 #3
0
        public override AsyncCompletionResult BeginRead(int offset, int size, TimeSpan timeout, Action <object> callback, object state)
        {
            ConnectionUtilities.ValidateBufferBounds(AsyncReadBufferSize, offset, size);

            if (preReadCount > 0)
            {
                int bytesToCopy = Math.Min(size, preReadCount);
                if (preReadData == null)
                {
                    if (offset != preReadOffset)
                    {
                        preReadData = Fx.AllocateByteArray(preReadCount);
                        Buffer.BlockCopy(base.Connection.AsyncReadBuffer, preReadOffset, preReadData, 0, preReadCount);
                        preReadOffset = 0;
                        Buffer.BlockCopy(preReadData, 0, base.Connection.AsyncReadBuffer, offset, bytesToCopy);
                        preReadOffset += bytesToCopy;
                        preReadCount  -= bytesToCopy;
                        asyncBytesRead = bytesToCopy;
                        return(AsyncCompletionResult.Completed);
                    }

                    // Requested offset and preReadOffset are the same so no copy needed
                    preReadOffset += bytesToCopy;
                    preReadCount  -= bytesToCopy;
                    asyncBytesRead = bytesToCopy;
                    return(AsyncCompletionResult.Completed);
                }

                Buffer.BlockCopy(preReadData, preReadOffset, AsyncReadBuffer, offset, bytesToCopy);
                preReadOffset += bytesToCopy;
                preReadCount  -= bytesToCopy;
                asyncBytesRead = bytesToCopy;
                return(AsyncCompletionResult.Completed);
            }

            return(base.BeginRead(offset, size, timeout, callback, state));
        }