Esempio n. 1
0
        private async Task ProcessRead(Stream s)
        {
            readBuffer.WriteTimeout = Timeout.Infinite;
            var buf = new byte[64 * 1024];
            var cts = closedCancelSource;

            try {
                var len = await s.ReadAsync(buf, 0, buf.Length, cts.Token).ConfigureAwait(false);

                while (len > 0)
                {
                    await readBuffer.WriteAsync(buf, 0, len, cts.Token).ConfigureAwait(false);

                    len = await s.ReadAsync(buf, 0, buf.Length, cts.Token).ConfigureAwait(false);
                }
                socket.Shutdown(SocketShutdown.Receive);
            }
            catch (OperationCanceledException) {
            }
            catch (IOException) {
                if (!cts.IsCancellationRequested)
                {
                    throw;
                }
            }
            catch (ObjectDisposedException) {
                if (!cts.IsCancellationRequested)
                {
                    throw;
                }
            }
            finally {
                readBuffer.CloseWrite();
            }
        }
Esempio n. 2
0
        public override async Task WriteAsync(byte[] buf, int offset, int length, CancellationToken cancel_token)
        {
            if (closedCancelSource.IsCancellationRequested)
            {
                throw new ObjectDisposedException(GetType().Name);
            }
            CheckWriteException();
            await writeBuffer.WriteAsync(buf, offset, length, cancel_token).ConfigureAwait(false);

            CheckWriteException();
            if (!closedCancelSource.IsCancellationRequested && !cancel_token.IsCancellationRequested)
            {
                writeBytesCounter.Add(length);
            }
        }
Esempio n. 3
0
        private async Task ProcessRead(Stream s)
        {
            readBuffer.WriteTimeout = Timeout.Infinite;
            var buf          = new byte[64 * 1024];
            var ct           = closedCancelSource.Token;
            var canceledTask = new TaskCompletionSource <int>();

            try {
                using (ct.Register(() => canceledTask.SetCanceled())) {
                    var completed = await Task.WhenAny(s.ReadAsync(buf, 0, buf.Length, ct), canceledTask.Task).ConfigureAwait(false);

                    var len = await completed.ConfigureAwait(false);

                    while (len > 0)
                    {
                        await readBuffer.WriteAsync(buf, 0, len, ct).ConfigureAwait(false);

                        completed = await Task.WhenAny(s.ReadAsync(buf, 0, buf.Length, ct), canceledTask.Task).ConfigureAwait(false);

                        len = await completed.ConfigureAwait(false);
                    }
                }
                socket.Shutdown(SocketShutdown.Receive);
            }
            catch (OperationCanceledException) {
                socket.Shutdown(SocketShutdown.Receive);
            }
            catch (IOException) {
                if (!ct.IsCancellationRequested)
                {
                    throw;
                }
            }
            catch (ObjectDisposedException) {
                if (!ct.IsCancellationRequested)
                {
                    throw;
                }
            }
            finally {
                readBuffer.CloseWrite();
            }
        }