TemporaryFile Class

[TonyValenti]

It would be super useful if .NET had a built in TemporaryFile class. A wrapper around a regular file that is deleted when the class (and all open streams) are disposed of.

I use the code below, which I know isn't great, but I wanted to share it in case anyone wants to use it as a starting place.

using MC.Clio;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace System.IO {

    interface ITemporaryFileInternals {
        DateTimeOffset? LastAccessTime { get; set; }
        DateTimeOffset? LastReadTime { get; set; }
        DateTimeOffset? LastWriteTime { get; set; }

        bool IsDirty { get; set; }
    }


    public static class TemporaryFileDefaults {
        public const string File_Path_Default = null;
        public const string File_Name_Default = null;
        public const string FileName_Format_Default = "{0}";
        public const bool DeleteOnDispose_Default = true;
        public const bool LockFile_Default = true;
        public const bool CreateImmediately_Default = true;
    }


    [DebuggerDisplay(System.Diagnostics.Debugger2.DebuggerDisplay)]
    public class TemporaryFile : IDisposable, ITemporaryFileInternals {

        protected virtual string GetDebuggerDisplay() {
                return $@"{FileName}";
        }

        DateTimeOffset? ITemporaryFileInternals.LastReadTime {
            get {
                return this.LastReadTime;
            }
            set {
                this.LastReadTime = value;
            }
        }

        DateTimeOffset? ITemporaryFileInternals.LastWriteTime {
            get {
                return this.LastWriteTime;
            }
            set {
                this.LastWriteTime = value;
            }
        }

        DateTimeOffset? ITemporaryFileInternals.LastAccessTime {
            get {
                return this.LastAccessTime;
            }
            set {
                this.LastAccessTime = value;
            }
        }

        bool ITemporaryFileInternals.IsDirty {
            get {
                return this.IsDirty;
            }
            set {
                this.IsDirty = value;
            }
        }


        public static string TemporaryFileName(string Suffix) {
            return TemporaryFileName() + Suffix;
        }

        public static string TemporaryFileName() {
            var ret = SpecialFolder2.TempFolder.Path(Guid.NewGuid().ToString());

            System.Diagnostics.Debugger2.Instance.WriteLineTempFile($@"[TEMPORARY_FILE]:  NEW - {ret}");

            return ret;
        }

        public DateTimeOffset CreationTime { get; private set; }
        public DateTimeOffset? LastAccessTime { get; private set; }
        public DateTimeOffset? LastReadTime { get; private set; }
        public DateTimeOffset? LastWriteTime { get; private set; }

        public long? FileSize {
            get {
                var ret = default(long?);
                try {
                    if (System.IO.File.Exists(FileName)) {
                        var Info = new FileInfo(FileName);
                        ret = Info.Length;
                    }

                } catch (Exception ex) {
                    ex.Ignore();
                }


                return ret;
            }
        }


        private DateTimeOffset? StorageTimeGet(Func<string, DateTimeOffset?> Method) {
            var ret = default(DateTimeOffset?);
            try {
                if (System.IO.File.Exists(FileName)) {
                    ret = Method(FileName);
                }
            } catch { }

            return ret;
        }

        private void StorageTimeSet(DateTimeOffset? value, Action<String, DateTime> Method) {
            if (value == null) {
                return;
            }

            try {
                if (System.IO.File.Exists(FileName)) {
                    Method(FileName, value.Value.UtcDateTime);
                }
            } catch { }
        }


        public DateTimeOffset? StorageCreationTime {
            get => StorageTimeGet(x => System.IO.Directory.GetCreationTimeUtc(x));
            set => StorageTimeSet(value, (x, y) => System.IO.Directory.SetCreationTimeUtc(x, y));
        }

        public DateTimeOffset? StorageLastAccessTime {
            get => StorageTimeGet(x => System.IO.Directory.GetLastAccessTimeUtc(x));
            set => StorageTimeSet(value, (x, y) => System.IO.Directory.SetLastAccessTimeUtc(x, y));
        }

        public DateTimeOffset? StorageLastWriteTime {
            get => StorageTimeGet(x => System.IO.Directory.GetLastWriteTimeUtc(x));
            set => StorageTimeSet(value, (x, y) => System.IO.Directory.SetLastWriteTimeUtc(x, y));
        }


        public bool IsDirty { get; set; }


        public string FileName { get; private set; }
        private bool DeleteOnDispose { get; set; }


        private void Constructor1(string File_Path, string File_Name, string File_Name_Format, bool DeleteOnDispose, bool LockFile, bool CreateImmediately) {

            File_Name = File_Name.IsNotNullOrEmpty() ? File_Name : Guid.NewGuid().ToString();
            File_Name = String.Format(File_Name_Format, File_Name);

            File_Path = File_Path.IsNotNullOrEmpty() 
                ? File_Path 
                : SpecialFolder2.TempFolder.Path()
                ;

            var FullPath = System.IO.Path.Combine(File_Path, File_Name);

            this.FileName = FullPath;
            this.DeleteOnDispose = DeleteOnDispose;

            if (CreateImmediately || LockFile) {

                //Don't do anything.  All we need to do is ensure the file is created.
                //We open a write stream to ensure the file is created
                //Then while that is open, if necessary, we create our lock file.
                //It s done this way so that we never unlock the file.

                this.LockStream = this.OpenLock();
                if (!LockFile) {
                    this.LockStream.Dispose();
                    this.LockStream = null;
                }
            }

        }

        private void Constructor2(bool LockFile) {
            this.CreationTime = DateTimeOffset.UtcNow;
            this.IsDirty = false;

            
        }

        public TemporaryFile(
            string File_Path = TemporaryFileDefaults.File_Path_Default, 
            string File_Name = TemporaryFileDefaults.File_Name_Default, 
            string File_Name_Format = TemporaryFileDefaults.FileName_Format_Default, 
            bool DeleteOnDispose = TemporaryFileDefaults.DeleteOnDispose_Default, 
            bool LockFile = TemporaryFileDefaults.LockFile_Default, 
            bool CreateImmediately = TemporaryFileDefaults.CreateImmediately_Default
            
            ) {
            Constructor1(File_Path, File_Name, File_Name_Format, DeleteOnDispose, LockFile, CreateImmediately);
            Constructor2(LockFile);
        }


        public TemporaryFile CopyFrom(ByteArray_Utf8String_Stream Source) {
            using (var Dest = this.OpenWrite()) {
                Source.Converted.CopyTo(Dest);
                Source.Converted.Close();
            }

            return this;
        }

        private TemporaryFileStream LockStream;


        ~TemporaryFile() {
            Dispose(false);
        }

        public IEnumerable<TemporaryFileStream> ActiveStreams() {
            foreach (var item in Instances) {
                yield return item.Value;
            }
        }

        private ConcurrentDictionary<TemporaryFileStream, TemporaryFileStream> Instances = new ConcurrentDictionary<TemporaryFileStream, TemporaryFileStream>();

        private TemporaryFileStream AddStream(TemporaryFileStream S) {
            var ret = S;

            Instances[S] = S;

            return ret;
        }

        private void RemoveStream(TemporaryFileStream S) {
            Instances.TryRemove(S, out var discard);
        }

        private void OnClose(TemporaryFileStream S) {
            RemoveStream(S);
        }


        private FileShare GetShare(FileShare Preferred) {
            var ret = this.LockStream == null
                ? Preferred
                : FileShare.ReadWrite
                ;

            return ret;
        }

        private TemporaryFileStream OpenLock() {
            return AddStream(new TemporaryFileStream(this, OnClose, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite));
        }

        public TemporaryFileStream OpenRead() {
            return AddStream(new TemporaryFileStream(this, OnClose, FileMode.Open, FileAccess.Read, GetShare(FileShare.Read)));
        }

        public TemporaryFileStream OpenWrite() {
            return AddStream(new TemporaryFileStream(this, OnClose, FileMode.OpenOrCreate, FileAccess.Write, GetShare(FileShare.None)));
        }

        public TemporaryFileStream Open(FileMode mode) {
            return AddStream(new TemporaryFileStream(this, OnClose, mode, (mode == FileMode.Append ? FileAccess.Write : FileAccess.ReadWrite), GetShare(FileShare.None)));
        }

        public TemporaryFileStream Open(FileMode mode, FileAccess access) {
            return AddStream(new TemporaryFileStream(this, OnClose, mode, access, GetShare(FileShare.None)));
        }

        public TemporaryFileStream Open(FileMode mode, FileAccess access, FileShare share) {
            return AddStream(new TemporaryFileStream(this, OnClose, mode, access, share));
        }

        public byte[] ReadAllBytes() {
            return System.IO.File.ReadAllBytes(FileName);
        }


        private bool AlreadyDisposed = false;
        public void Dispose() {
            Dispose(true);
            GC.SuppressFinalize(this);
        }


        private void Dispose(bool Disposing) {
            if (AlreadyDisposed) {
                return;
            }

            FreeManaged();
            FreeUnmanaged();

            AlreadyDisposed = true;
        }

        private void FreeManaged() {
        }

        private void FreeUnmanaged() {

            var ToRemove = Instances.ToList();
            foreach (var item in ToRemove) {
                try {
                    item.Key.Dispose();
                } catch { }
            }

            try {
                if (DeleteOnDispose) {
                    System.IO.File.Delete(FileName);
                }
            } catch { }
        }

    }



    public class TemporaryFileStream : System.IO.FileStream {
        public TemporaryFile TemporaryFile { get; private set; }
        private ITemporaryFileInternals TemporaryFileInternals { get; set; }

        private Action<TemporaryFileStream> OnClose;

        internal TemporaryFileStream(TemporaryFile Manager, Action<TemporaryFileStream> OnClose, FileMode FileMode, FileAccess FileAccess, FileShare FileShare) : base(Manager.FileName, FileMode, FileAccess, FileShare) {
            this.TemporaryFile = Manager;
            this.TemporaryFileInternals = Manager;
            this.OnClose = OnClose;

            TemporaryFileInternals.LastAccessTime = DateTimeOffset.UtcNow;
        }


        public override void Write(byte[] array, int offset, int count) {
            TemporaryFileInternals.IsDirty = true;
            TemporaryFileInternals.LastWriteTime = DateTimeOffset.UtcNow;
            base.Write(array, offset, count);
        }

        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) {
            TemporaryFileInternals.IsDirty = true;
            TemporaryFileInternals.LastWriteTime = DateTimeOffset.UtcNow;
            return base.WriteAsync(buffer, offset, count, cancellationToken);
        }

        public override void WriteByte(byte value) {
            TemporaryFileInternals.IsDirty = true;
            TemporaryFileInternals.LastWriteTime = DateTimeOffset.UtcNow;
            base.WriteByte(value);
        }

        public override IAsyncResult BeginWrite(byte[] array, int offset, int numBytes, AsyncCallback userCallback, object stateObject) {
            TemporaryFileInternals.IsDirty = true;
            TemporaryFileInternals.LastWriteTime = DateTimeOffset.UtcNow;
            return base.BeginWrite(array, offset, numBytes, userCallback, stateObject);
        }

        public override void EndWrite(IAsyncResult asyncResult) {
            TemporaryFileInternals.IsDirty = true;
            TemporaryFileInternals.LastWriteTime = DateTimeOffset.UtcNow;
            base.EndWrite(asyncResult);
        }


        public override IAsyncResult BeginRead(byte[] array, int offset, int numBytes, AsyncCallback userCallback, object stateObject) {
            TemporaryFileInternals.LastReadTime = DateTimeOffset.UtcNow;
            return base.BeginRead(array, offset, numBytes, userCallback, stateObject);
        }

        public override int Read(byte[] array, int offset, int count) {
            TemporaryFileInternals.LastReadTime = DateTimeOffset.UtcNow;
            return base.Read(array, offset, count);
        }

        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) {
            TemporaryFileInternals.LastReadTime = DateTimeOffset.UtcNow;
            return base.ReadAsync(buffer, offset, count, cancellationToken);
        }

        public override int ReadByte() {
            TemporaryFileInternals.LastReadTime = DateTimeOffset.UtcNow;
            return base.ReadByte();
        }

        public override int EndRead(IAsyncResult asyncResult) {
            TemporaryFileInternals.LastReadTime = DateTimeOffset.UtcNow;
            return base.EndRead(asyncResult);
        }

        protected override void Dispose(bool disposing) {
            base.Dispose(disposing);

            if (disposing) {
                this.TemporaryFile = null;
                this.OnClose(this);
            }


        }
    }


    public static class TemporaryFileExtensions {
        public static FileInfo Information(this TemporaryFile This) {
            return new System.IO.FileInfo(This.FileName);
        }
    }


    public static class TemporaryFileStreamExtensions {


        public static List<TemporaryFile> CacheToTempFile(this IEnumerable<Stream> This) {
            var ret = new List<TemporaryFile>();

            foreach (var item in This) {
                ret.Add(item.CacheToTempFile());
            }

            return ret;
        }

        public static TemporaryFile CacheToTempFile(this Stream This) {
            var ret = new TemporaryFile().CopyFrom(This);
            return ret;
        }

        public static TemporaryFile CacheToTempFile(this byte[] This) {
            var ret = new TemporaryFile().CopyFrom(This);
            return ret;
        }

        private const long CacheToTempFileOrMemoryStream_Limit = 1024 * 1024 * 10;
        static Stream CacheToTempFileOrMemoryStream(this Stream This) {
            return CacheToTempFileOrMemoryStream(This, x => x.Length);
        }

        static Stream CacheToTempFileOrMemoryStream(this Stream This, Func<Stream, long> GetLength) {
            var ret = default(Stream);

            var Length = GetLength(This);

            if (Length > CacheToTempFileOrMemoryStream_Limit) {
                var TempFile = new TemporaryFile().CopyFrom(This);
                ret = TempFile.OpenRead();
            } else {
                var MS = Length > 0 
                    ? new MemoryStream((int)Length)
                    : new MemoryStream()
                    ;

                This.CopyTo(MS);
                This.Close();

                MS.Position = 0;
                ret = MS;
            }

            return ret;
        }

        public static async Task<Stream> CacheToTempFileOrMemoryStream(this HttpContent This) {
            var Stream = await This.ReadAsStreamAsync()
                .DefaultAwait()
                ;

            return CacheToTempFileOrMemoryStream(Stream, x => This.Headers.ContentLength ?? 0);

        }

    }

}

[Symbai]

Have you seen #2048 ?!