TemporaryStream.cs

using System;
using System.IO;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
 
namespace Waher.Runtime.Temporary
{
    public class TemporaryStream : Stream
    {
        private static int defaultThreasholdBytes = 1024 * 1024;
 
        public static int DefaultThreasholdBytes
        {
            get => defaultThreasholdBytes;
            set
            {
                if (value <= 0)
                    throw new ArgumentOutOfRangeException("Must be positive.", nameof(DefaultThreasholdBytes));
 
                defaultThreasholdBytes = value;
            }
        }
 
        private readonly int thresholdBytes;
        private Stream stream;
        private bool checkSize;
 
        public TemporaryStream()
            : this(DefaultThreasholdBytes)
        {
        }
 
        public TemporaryStream(int ThresholdBytes)
        {
            this.thresholdBytes = ThresholdBytes;
            this.stream = new MemoryStream();
            this.checkSize = true;
        }
 
        public override long Position
        {
            get => this.stream.Position;
            set => this.stream.Position = value;
        }
 
        public override long Length => this.stream.Length;
 
        public override bool CanWrite => this.stream.CanWrite;
 
        public override bool CanTimeout => this.stream.CanTimeout;
 
        public override bool CanSeek => this.stream.CanSeek;
 
        public override bool CanRead => this.stream.CanRead;
 
        public override int ReadTimeout
        {
            get => this.stream.ReadTimeout;
            set => this.stream.ReadTimeout = value;
        }
 
        public override int WriteTimeout
        {
            get => this.stream.WriteTimeout;
            set => this.stream.WriteTimeout = value;
        }
 
        public override async Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
        {
            if (this.checkSize && this.stream.Position + bufferSize > this.thresholdBytes)
                await this.SwitchToFileAsync(cancellationToken);
 
            await this.stream.CopyToAsync(destination, bufferSize, cancellationToken);
        }
 
        private async Task SwitchToFileAsync(CancellationToken cancellationToken)
        {
            TemporaryFile File = new TemporaryFile();
            try
            {
                long Pos = this.stream.Position;
                this.stream.Position = 0;
                await this.stream.CopyToAsync(File, 81920, cancellationToken);
 
                File.Position = Pos;
                this.stream.Dispose();
                this.stream = File;
                File = null;
 
                this.checkSize = false;
            }
            catch (Exception ex)
            {
                File?.Dispose();
                ExceptionDispatchInfo.Capture(ex).Throw();
            }
        }
 
        private void SwitchToFile()
        {
            TemporaryFile File = new TemporaryFile();
            try
            {
                long Pos = this.stream.Position;
                this.stream.Position = 0;
                this.stream.CopyTo(File);
 
                File.Position = Pos;
                this.stream.Dispose();
                this.stream = File;
                File = null;
 
                this.checkSize = false;
            }
            catch (Exception ex)
            {
                File?.Dispose();
                ExceptionDispatchInfo.Capture(ex).Throw();
            }
        }
 
        public override void Flush()
        {
            this.stream.Flush();
        }
 
        public override Task FlushAsync(CancellationToken cancellationToken)
        {
            return this.stream.FlushAsync(cancellationToken);
        }
 
        public override int Read(byte[] buffer, int offset, int count)
        {
            return this.stream.Read(buffer, offset, count);
        }
 
        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            return this.stream.ReadAsync(buffer, offset, count, cancellationToken);
        }
 
        public override int ReadByte()
        {
            return this.stream.ReadByte();
        }
 
        public override long Seek(long offset, SeekOrigin origin)
        {
            return this.stream.Seek(offset, origin);
        }
 
        public override void SetLength(long value)
        {
            if (this.checkSize && value > this.thresholdBytes)
                this.SwitchToFile();
 
            this.stream.SetLength(value);
        }
 
        public override void Write(byte[] buffer, int offset, int count)
        {
            if (this.checkSize && this.stream.Position + count > this.thresholdBytes)
                this.SwitchToFile();
 
            this.stream.Write(buffer, offset, count);
        }
 
        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            if (this.checkSize && this.stream.Position + count > this.thresholdBytes)
                await this.SwitchToFileAsync(cancellationToken);
 
            await this.stream.WriteAsync(buffer, offset, count, cancellationToken);
        }
 
        public override void WriteByte(byte value)
        {
            if (this.checkSize && this.stream.Position + 1 > this.thresholdBytes)
                this.SwitchToFile();
 
            this.stream.WriteByte(value);
        }
 
        protected override void Dispose(bool disposing)
        {
            this.stream?.Dispose();
            this.stream = null;
        }
    }
}