Why does my gzip-compressed CSV from Azure Blob Storage appear corrupted and have a mismatched file size when downloaded?

Gzip file uploaded to Azure Blob Storage, when downloaded to Windows machine does not open and the file size is not same

The error may be MemoryStream has not been properly flushed or reset before uploading or GZip stream is not properly finalized.

I used the sample code to upload a .gz file with 3 to 4 kib size in my environment.

Code:

CSHARPCopied
namespace BlobUploadExample
{
    public class Program
    {
        public static async Task Main(string[] args)
        {
            var blobServiceClient = new BlobServiceClient("connection string");
            var uploader = new BlobUploader(blobServiceClient);

            var data = GenerateLargeDataset(500); 

            await uploader.SaveAsync(
                data,
                "<container name>",
                "sample.gz",
                CancellationToken.None);

            Console.WriteLine("Upload complete.");
        }

        private static List<MyData> GenerateLargeDataset(int recordCount)
        {
            var data = new List<MyData>();
            var random = new Random();

            for (int i = 0; i < recordCount; i++)
            {
                data.Add(new MyData
                {
                    Date = DateTime.UtcNow.AddDays(-random.Next(0, 365)),
                    Name = $"Record-{i:D5}",
                    Value = random.Next(1, 1000)
                });
            }

            return data;
        }
    }

    public class BlobUploader
    {
        private readonly BlobServiceClient _blobServiceClient;

        public BlobUploader(BlobServiceClient blobServiceClient)
        {
            _blobServiceClient = blobServiceClient;
        }

        public async Task SaveAsync(
            IEnumerable<MyData> data,
            string containerName,
            string blobName,
            CancellationToken cancellationToken)
        {
            using var ms = new MemoryStream();

            var containerClient = _blobServiceClient.GetBlobContainerClient(containerName);
            await containerClient.CreateIfNotExistsAsync();

            var blobClient = containerClient.GetBlobClient(blobName);

            // Compress and write CSV data to the memory stream
            await using (var compress = new GZipStream(ms, CompressionMode.Compress, leaveOpen: true))
            await using (var writer = new StreamWriter(compress, Encoding.UTF8))
            await using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture, leaveOpen: true))
            {
                csv.Context.RegisterClassMap<MyDataMap>();

                await csv.WriteRecordsAsync(data, cancellationToken);

                await writer.FlushAsync(cancellationToken);
                compress.Flush();
            }

            await ms.FlushAsync(cancellationToken);
            ms.Position = 0;

            var blobHttpHeader = new BlobHttpHeaders
            {
                ContentType = "application/gzip",
                ContentEncoding = "gzip",
            };

            var metaData = new Dictionary<string, string>
            {
                { "date", DateTime.UtcNow.ToString(CultureInfo.InvariantCulture) }
            };

            // Upload the file to Blob Storage
            await blobClient.UploadAsync(
                ms,
                new BlobUploadOptions
                {
                    HttpHeaders = blobHttpHeader,
                    Metadata = metaData
                },
                cancellationToken);
        }
    }

    public class MyData
    {
        public DateTime Date { get; set; }
        public string Name { get; set; }
        public int Value { get; set; }
    }

    public class MyDataMap : ClassMap<MyData>
    {
        public MyDataMap()
        {
            Map(m => m.Date).Name("Date");
            Map(m => m.Name).Name("Name");
            Map(m => m.Value).Name("Value");
        }
    }
}

Output:

BASHCopied
Upload complete.

Portal:

I verified .gz file by downloading into my local environment.