Exemple #1
0
        /// <summary>
        /// Implements Stream.WriteAsync
        /// </summary>
        /// <exception cref="DisconnectedException">catched a SocketException</exception>
        /// <exception cref="OutputStreamException">current mode is KnownLength, and position is out of range</exception>
        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            try {
                if (count == 0)
                {
                    return;
                }
                haveWrote += count;
WRITE:
                if (CurrentMode == Mode.Buffering)
                {
                    if (haveWrote <= BufferSize)
                    {
                        if (this.bufferHandle == null)
                        {
                            this.bufferHandle = bufferPool.Get();
                        }
                        this.buffer.Write(buffer, offset, count);
                    }
                    else
                    {
                        if (needKeepAlive)
                        {
                            await SwitchToChunkedModeAsync().CAF();
                        }
                        else
                        {
                            await SwitchToNoKeepAliveModeAsync().CAF();
                        }
                        goto WRITE;
                    }
                }
                else if (CurrentMode == Mode.Chunked)
                {
                    await writeChunkSizeAsync(baseStream, count).CAF();

                    await baseStream.WriteAsync(buffer, offset, count, cancellationToken).CAF();
                    await writeBytesToStreamAsync(baseStream, CRLF).CAF();
                }
                else if (CurrentMode == Mode.KnownLength)
                {
                    if (haveWrote > lengthToWrite)
                    {
                        throw new OutputStreamException("position > content-length");
                    }
                    await baseStream.WriteAsync(buffer, offset, count, cancellationToken).CAF();
                }
                else if (CurrentMode == Mode.NoKeepAlive)
                {
                    await baseStream.WriteAsync(buffer, offset, count, cancellationToken).CAF();
                }
            } catch (IOException e) when(e.InnerException is SocketException)
            {
                throw new DisconnectedException(e.InnerException.Message);
            } catch (SocketException se) {
                throw new DisconnectedException(se.Message);
            }
            Actived?.Invoke(this);
        }
Exemple #2
0
        private async Task writeBufferToBaseStreamAndClearBufferAsync()
        {
            if (buffer != null)
            {
                await baseStream.WriteAsync(buffer.GetBuffer(), 0, (int)buffer.Length).CAF();

                bufferHandle.Dispose();
                bufferHandle = null;
            }
        }
Exemple #3
0
 protected override void Dispose(bool disposing)
 {
     if (disposing)
     {
     }
     if (bufferHandle != null)
     {
         bufferHandle.Dispose();
         bufferHandle = null;
     }
     base.Dispose(disposing);
 }
Exemple #4
0
 /// <summary>
 /// Clear buffer.
 /// </summary>
 /// <exception cref="OutputStreamException">Current mode is not Buffering</exception>
 public void ClearBuffer()
 {
     if (CurrentMode != Mode.Buffering)
     {
         throw new OutputStreamException("current mode is not buffering");
     }
     if (bufferHandle != null)
     {
         bufferHandle.Dispose();
         bufferHandle = null;
     }
     haveWrote = 0;
 }
Exemple #5
0
        private void _write(byte[] buffer, int offset, int count)
        {
            if (count == 0)
            {
                return;
            }
            haveWrote += count;
WRITE:
            if (CurrentMode == Mode.Buffering)
            {
                if (haveWrote <= BufferSize)
                {
                    if (this.bufferHandle == null)
                    {
                        this.bufferHandle = bufferPool.Get();
                    }
                    this.buffer.Write(buffer, offset, count);
                }
                else
                {
                    if (needKeepAlive)
                    {
                        SwitchToChunkedMode();
                    }
                    else
                    {
                        SwitchToNoKeepAliveMode();
                    }
                    goto WRITE;
                }
            }
            else if (CurrentMode == Mode.Chunked)
            {
                writeChunkSize(baseStream, count);
                baseStream.Write(buffer, offset, count);
                writeBytesToStream(baseStream, CRLF);
            }
            else if (CurrentMode == Mode.KnownLength)
            {
                if (haveWrote > lengthToWrite)
                {
                    throw new OutputStreamException("position > content-length");
                }
                baseStream.Write(buffer, offset, count);
            }
            else if (CurrentMode == Mode.NoKeepAlive)
            {
                baseStream.Write(buffer, offset, count);
            }
        }