Confusing different behaviour between Azure, Memory, Disk & Zip modules. about fluentstorage HOT 4 OPEN

    public sealed class BlobContainerClient
    {
        private const string _dummyFileName = ".empty";
        private readonly IBlobStorage _storage;

        public BlobContainerClient(IBlobStorage storage, string name)
        {
            _storage = storage;
            Name = name;
        }

        public string Name { get; }

        internal IBlobStorage Storage => _storage;

        public async Task<bool> ExistsAsync()
        {
            if (_storage is IHierarchicalBlobStorage || _storage is global::FluentStorage.Azure.Blobs.IAzureBlobStorage)
            {
                var blob = await Storage.GetBlobAsync(Name);
                if (blob == null)
                {
                    return false;
                }
                return blob.IsFolder && blob.FullPath == $"/{Name}";
            }
            else
            {
                var blob = await Storage.GetBlobAsync($"{Name}/{_dummyFileName}");
                if (blob == null)
                {
                    return false;
                }
                return blob.FullPath == $"/{Name}/{_dummyFileName}";
            }
        }

        public async Task DeleteIfExistsAsync()
        {
            if (await ExistsAsync())
            {
                await Storage.DeleteAsync(Name);
            }
        }

        /*
         * todo: need to be careful as fluentstorage assumes '.empty' by default but doesn't expose that as a constant
         * so it *could* change, and theoretically if code doesn't use the abstractions here, it could theoretically
         * choose to create a new folder and write the .empty file or not write it at all, so we'd be without the ability
         * to check for a folder / container's existence.
         */
        public async Task CreateAsync()
        {
            await Storage.CreateFolderAsync(Name, dummyFileName: _dummyFileName);
        }
    }

    public sealed class BlobClient
    {
        private readonly BlobContainerClient _containerClient;
        private readonly string _path;

        public BlobClient(BlobContainerClient containerClient, string path)
        {
            if (path.StartsWith(containerClient.Name, StringComparison.OrdinalIgnoreCase))
            {
                throw new ArgumentException("Path starts with the container name", nameof(path));
            }

            _containerClient = containerClient;
            _path = path;
        }

        internal BlobContainerClient ContainerClient => _containerClient;

        public async Task<bool> ExistsAsync()
        {
            return await _containerClient.Storage.ExistsAsync($"{_containerClient.Name}/{_path}", CancellationToken.None);
        }

        public async Task DownloadToAsync(Stream stream)
        {
            await _containerClient.Storage.ReadToStreamAsync($"{_containerClient.Name}/{_path}", stream);
        }

        public async Task UploadAsync(BinaryData data, CancellationToken? cancellationToken = null)
        {
            using var stream = data.ToStream();
            await _containerClient.Storage.WriteAsync($"{_containerClient.Name}/{_path}", stream, cancellationToken:cancellationToken ?? CancellationToken.None);
        }

        public async Task DeleteIfExistsAsync()
        {
            if (await _containerClient.Storage.ExistsAsync($"{_containerClient.Name}/{_path}"))
            {
                await _containerClient.Storage.DeleteAsync($"{_containerClient.Name}/{_path}");
            }
        }

        public string Name => _path;
    }

    public static class BlobStorageExtensions
    {
        public static BlobContainerClient GetBlobContainerClient(this IBlobStorage storage, string container)
        {
            return new BlobContainerClient(storage, container);
        }

        public static BlobClient GetBlobClient(this BlobContainerClient containerClient, string blobPath)
        {
            return new BlobClient(containerClient, blobPath);
        }

        public static async Task DeleteAllContainersAsync(this IBlobStorage storage)
        {
            var containers = await storage.ListAsync(new ListOptions { Recurse = false });

            foreach(var container in containers)
            {
                await storage.GetBlobContainerClient(container.Name).DeleteIfExistsAsync();
            }
        }

        public static bool IsStorageForZipArchive(this IBlobStorage storage)
        {
            /*
             * This isn't ideal, but in some circumstances we need to know if the zip storage handler
             * is being used.
             * 
             * Mostly when using the background queue processor or interacting with it via a worker pool
             * or in parallel.
             * 
             * The underlying types are private in the FluentStorage library, so we have to resort
             * to inspecting the type name.
             * 
             * Checking whether it contains 'zip' just to add a bit of resiliency in case the type name changes.
             */
            return storage.GetType().Name.Contains("zip", StringComparison.OrdinalIgnoreCase);
        }

        // todo: may need to add some special handling in here because azure containers in real environments
        // suffer from a timing issue during drop and re-create.
        public static async Task RecreateContainer(this IBlobStorage storage, string container)
        {
            var containerClient = storage.GetBlobContainerClient(container);
            await containerClient.DeleteIfExistsAsync();
            await containerClient.CreateAsync();
        }
    }