Jane Doe
Posted on Sep 10, 2025 • 2 replies

How to optimize Azure Blob storage for large file uploads?

I'm building an application that needs to upload files larger than 5 GB to Azure Blob storage. The current approach uses single-part uploads, which is quite slow and sometimes fails due to network interruptions. I heard about block blobs and parallel uploads, but I'm not sure how to implement them efficiently in .NET.

Could anyone share best practices, code snippets, or reference architecture diagrams for handling large file uploads with high reliability?

John Smith
Sep 10, 2025 at 14:32

You can use the TransferManager from the Azure.Storage.DataMovement library. It handles parallel block uploads automatically and provides retry logic.

var client = new BlobServiceClient(connectionString);
var blob = client.GetBlobContainerClient("uploads")
                 .GetBlobClient("largefile.bin");

await new TransferManager().UploadAsync(
    sourcePath: @"C:\files\largefile.bin",
    destinationBlob: blob,
    options: new TransferOptions { MaximumConcurrency = 8 });

Make sure to set MaximumConcurrency based on the network bandwidth. Also, enable the TransferManager progress handler to provide UI feedback.

Alice Liu
Sep 11, 2025 at 09:15

Another option is to use the BlockBlobClient directly and manually upload blocks in parallel. This gives you finer control over block sizes and retry policies.

var blockBlob = new BlockBlobClient(connectionString, "uploads", "largefile.bin");
var blockSize = 100 * 1024 * 1024; // 100 MB
var blockIds = new List();

using (var file = File.OpenRead(@"C:\files\largefile.bin"))
{
    long offset = 0;
    int blockNum = 0;
    while (offset < file.Length)
    {
        var blockId = Convert.ToBase64String(Encoding.UTF8.GetBytes($"block-{blockNum:D5}"));
        blockIds.Add(blockId);
        var buffer = new byte[Math.Min(blockSize, file.Length - offset)];
        file.Seek(offset, SeekOrigin.Begin);
        file.Read(buffer, 0, buffer.Length);
        await blockBlob.StageBlockAsync(blockId, new MemoryStream(buffer));
        offset += buffer.Length;
        blockNum++;
    }
}
await blockBlob.CommitBlockListAsync(blockIds);

Remember to handle transient failures with exponential back‑off.

Add a reply