HttpBaseStream.cs

Go to the documentation of this file.

using System.IO;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
 
namespace System.Net.Http;
 
internal abstract class HttpBaseStream : Stream
{
    public sealed override bool CanSeek => false;
 
    public sealed override long Length
    {
        get
        {
            throw new NotSupportedException();
        }
    }
 
    public sealed override long Position
    {
        get
        {
            throw new NotSupportedException();
        }
        set
        {
            throw new NotSupportedException();
        }
    }
 
    public sealed override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
    {
        return System.Threading.Tasks.TaskToApm.Begin(ReadAsync(buffer, offset, count, default(CancellationToken)), callback, state);
    }
 
    public sealed override int EndRead(IAsyncResult asyncResult)
    {
        return System.Threading.Tasks.TaskToApm.End<int>(asyncResult);
    }
 
    public sealed override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
    {
        return System.Threading.Tasks.TaskToApm.Begin(WriteAsync(buffer, offset, count, default(CancellationToken)), callback, state);
    }
 
    public sealed override void EndWrite(IAsyncResult asyncResult)
    {
        System.Threading.Tasks.TaskToApm.End(asyncResult);
    }
 
    public sealed override long Seek(long offset, SeekOrigin origin)
    {
        throw new NotSupportedException();
    }
 
    public sealed override void SetLength(long value)
    {
        throw new NotSupportedException();
    }
 
    public sealed override int ReadByte()
    {
        byte reference = 0;
        if (Read(MemoryMarshal.CreateSpan(ref reference, 1)) != 1)
        {
            return -1;
        }
        return reference;
    }
 
    public sealed override int Read(byte[] buffer, int offset, int count)
    {
        Stream.ValidateBufferArguments(buffer, offset, count);
        return Read(buffer.AsSpan(offset, count));
    }
 
    public sealed override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
    {
        Stream.ValidateBufferArguments(buffer, offset, count);
        return ReadAsync(new Memory<byte>(buffer, offset, count), cancellationToken).AsTask();
    }
 
    public override void Write(byte[] buffer, int offset, int count)
    {
        WriteAsync(buffer, offset, count, CancellationToken.None).GetAwaiter().GetResult();
    }
 
    public sealed override void WriteByte(byte value)
    {
        Write(MemoryMarshal.CreateReadOnlySpan(ref value, 1));
    }
 
    public sealed override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
    {
        Stream.ValidateBufferArguments(buffer, offset, count);
        return WriteAsync(new ReadOnlyMemory<byte>(buffer, offset, count), cancellationToken).AsTask();
    }
 
    public override void Flush()
    {
        FlushAsync(default(CancellationToken)).GetAwaiter().GetResult();
    }
 
    public override Task FlushAsync(CancellationToken cancellationToken)
    {
        return NopAsync(cancellationToken);
    }
 
    protected static Task NopAsync(CancellationToken cancellationToken)
    {
        if (!cancellationToken.IsCancellationRequested)
        {
            return Task.CompletedTask;
        }
        return Task.FromCanceled(cancellationToken);
    }
 
    public abstract override int Read(Span<byte> buffer);
 
    public abstract override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken);
 
    public abstract override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken);
}