Ladda upp en blob med .NET

• .NET
• Java
• JavaScript
• TypeScript
• Python

Den här artikeln visar hur du laddar upp en blob med hjälp av Azure Storage-klientbiblioteket för .NET. Du kan ladda upp data till en blockblob från en filsökväg, en ström, ett binärt objekt eller en textsträng. Du kan också öppna en blobström och skriva till den eller ladda upp stora blobar i block.

Förutsättningar

• Den här artikeln förutsätter att du redan har konfigurerat ett projekt för att arbeta med Azure Blob Storage-klientbiblioteket för .NET. Mer information om hur du konfigurerar projektet, inklusive paketinstallation, tillägg using av direktiv och skapande av ett auktoriserat klientobjekt finns i Kom igång med Azure Blob Storage och .NET.
• Auktoriseringsmekanismen måste ha behörighet att utföra en uppladdningsåtgärd. Mer information finns i auktoriseringsvägledningen för följande REST API-åtgärder:
  • Placera blob
  • Placera block

Ladda upp data till en blockblob

Du kan använda någon av följande metoder för att ladda upp data till en blockblob:

• Överför
• UploadAsync

När du använder dessa uppladdningsmetoder kan klientbiblioteket anropa antingen Put Blob eller en serie Put Block-anrop följt av Placera blockeringslista. Det här beteendet beror på objektets övergripande storlek och hur dataöverföringsalternativen anges.

Om du vill öppna en dataström i Blob Storage och skriva till dataströmmen använder du någon av följande metoder:

• OpenWrite
• OpenWriteAsync

Ladda upp en blockblob från en lokal filsökväg

I följande exempel laddas en blockblob upp från en lokal filsökväg:

public static async Task UploadFromFileAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    await blobClient.UploadAsync(localFilePath, true);
}

Ladda upp en blockblob från en dataström

I följande exempel laddas en blockblob upp genom att ett Stream-objekt skapas och dataströmmen laddas upp.

public static async Task UploadFromStreamAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    FileStream fileStream = File.OpenRead(localFilePath);
    await blobClient.UploadAsync(fileStream, true);
    fileStream.Close();
}

Ladda upp en blockblob från ett BinaryData-objekt

I följande exempel laddas en blockblob upp från ett BinaryData-objekt .

public static async Task UploadFromBinaryDataAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    FileStream fileStream = File.OpenRead(localFilePath);
    BinaryReader reader = new BinaryReader(fileStream);

    byte[] buffer = new byte[fileStream.Length];
    reader.Read(buffer, 0, buffer.Length);
    BinaryData binaryData = new BinaryData(buffer);

    await blobClient.UploadAsync(binaryData, true);

    fileStream.Close();
}

Ladda upp en blockblob från en sträng

I följande exempel laddas en blockblob upp från en sträng:

public static async Task UploadFromStringAsync(
    BlobContainerClient containerClient,
    string blobName)
{
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    string blobContents = "Sample blob data";

    await blobClient.UploadAsync(BinaryData.FromString(blobContents), overwrite: true);
}

Ladda upp till en dataström i Blob Storage

Du kan öppna en dataström i Blob Storage och skriva till den. I följande exempel skapas en zip-fil i Blob Storage och filer skrivs till den. I stället för att skapa en zip-fil i det lokala minnet finns bara en fil i taget i minnet.

public static async Task UploadToStreamAsync(
    BlobContainerClient containerClient,
    string localDirectoryPath)
{
    string zipFileName = Path.GetFileName(
        Path.GetDirectoryName(localDirectoryPath)) + ".zip";

    BlockBlobClient blockBlobClient = containerClient.GetBlockBlobClient(zipFileName);

    using (Stream stream = await blockBlobClient.OpenWriteAsync(true))
    {
        using (ZipArchive zip = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: false))
        {
            foreach (var fileName in Directory.EnumerateFiles(localDirectoryPath))
            {
                using (var fileStream = File.OpenRead(fileName))
                {
                    var entry = zip.CreateEntry(
                        Path.GetFileName(fileName), CompressionLevel.Optimal);
                    using (var innerFile = entry.Open())
                    {
                        await fileStream.CopyToAsync(innerFile);
                    }
                }
            }
        }
    }
}

Ladda upp en blockblob med konfigurationsalternativ

Du kan definiera konfigurationsalternativ för klientbibliotek när du laddar upp en blob. Dessa alternativ kan justeras för att förbättra prestanda, förbättra tillförlitligheten och optimera kostnaderna. Följande kodexempel visar hur du använder BlobUploadOptions för att definiera konfigurationsalternativ när du anropar en uppladdningsmetod.

Ange alternativ för dataöverföring vid uppladdning

Du kan konfigurera värdena i StorageTransferOptions för att förbättra prestanda för dataöverföringsåtgärder. Följande kodexempel visar hur du anger värden för StorageTransferOptions och inkluderar alternativen som en del av en BlobUploadOptions instans. Värdena i det här exemplet är inte avsedda att vara en rekommendation. Om du vill justera dessa värden korrekt måste du ta hänsyn till appens specifika behov.

public static async Task UploadWithTransferOptionsAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    var transferOptions = new StorageTransferOptions
    {
        // Set the maximum number of parallel transfer workers
        MaximumConcurrency = 2,

        // Set the initial transfer length to 8 MiB
        InitialTransferSize = 8 * 1024 * 1024,

        // Set the maximum length of a transfer to 4 MiB
        MaximumTransferSize = 4 * 1024 * 1024
    };

    var uploadOptions = new BlobUploadOptions()
    {
        TransferOptions = transferOptions
    };

    FileStream fileStream = File.OpenRead(localFilePath);
    await blobClient.UploadAsync(fileStream, uploadOptions);
    fileStream.Close();
}

Mer information om hur du justerar dataöverföringsalternativ finns i Prestandajustering för uppladdningar och nedladdningar med .NET.

Ange alternativ för överföringsverifiering vid uppladdning

Du kan ange alternativ för överföringsverifiering för att säkerställa att data överförs korrekt och inte har manipulerats under överföringen. Alternativ för överföringsverifiering kan definieras på klientnivå med hjälp av BlobClientOptions, som tillämpar valideringsalternativ på alla metoder som anropas från en BlobClient-instans .

Du kan också åsidosätta alternativ för överföringsverifiering på metodnivå med Hjälp av BlobUploadOptions. Följande kodexempel visar hur du skapar ett BlobUploadOptions objekt och anger en algoritm för att generera en kontrollsumma. Kontrollsumman används sedan av tjänsten för att verifiera dataintegriteten för det uppladdade innehållet.

public static async Task UploadWithChecksumAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    var validationOptions = new UploadTransferValidationOptions
    {
        ChecksumAlgorithm = StorageChecksumAlgorithm.Auto
    };

    var uploadOptions = new BlobUploadOptions()
    {
        TransferValidation = validationOptions
    };

    FileStream fileStream = File.OpenRead(localFilePath);
    await blobClient.UploadAsync(fileStream, uploadOptions);
    fileStream.Close();
}

I följande tabell visas de tillgängliga alternativen för kontrollsummaalgoritmen, enligt definitionen i StorageChecksumAlgorithm:

Name	Värde	Beskrivning
Automatisk	0	Rekommenderas. Tillåter att biblioteket väljer en algoritm. Olika biblioteksversioner kan välja olika algoritmer.
Ingen	1	Ingen vald algoritm. Beräkna inte eller begär inte kontrollsummor.
MD5	2	Standard-MD5-hashalgoritm.
StorageCrc64	3	Anpassad 64-bitars CRC för Azure Storage.

Anteckning

Om kontrollsumman som anges i begäran inte matchar kontrollsumman som beräknas av tjänsten misslyckas uppladdningen. Det går inte att utföra åtgärden igen när du använder en standardprincip för återförsök. I .NET genereras en RequestFailedException med statuskod 400 och felkoden Md5Mismatch eller Crc64Mismatch, beroende på vilken algoritm som används.

Ladda upp med indextaggar

Blobindextaggar kategoriserar data i ditt lagringskonto med hjälp av nyckel/värde-taggattribut. Dessa taggar indexeras och exponeras automatiskt som ett sökbart flerdimensionellt index för att enkelt hitta data. Du kan lägga till taggar i en BlobUploadOptions-instans och skicka instansen UploadAsync till metoden .

I följande exempel laddas en blockblob upp med indextaggar:

public static async Task UploadBlobWithTagsAsync(
    BlobContainerClient containerClient,
    string blobName)
{
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    string blobContents = "Sample blob data";

    BlobUploadOptions options = new BlobUploadOptions();
    options.Tags = new Dictionary<string, string>
    {
        { "Sealed", "false" },
        { "Content", "image" },
        { "Date", "2020-04-20" }
    };

    await blobClient.UploadAsync(BinaryData.FromString(blobContents), options);
}

Ange en blobs åtkomstnivå vid uppladdning

Du kan ange åtkomstnivån för en blob vid uppladdning med hjälp av klassen BlobUploadOptions . Följande kodexempel visar hur du anger åtkomstnivå när du laddar upp en blob:

public static async Task UploadWithAccessTierAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlockBlobClient blockBlobClient = containerClient.GetBlockBlobClient(fileName);

    var uploadOptions = new BlobUploadOptions()
    {
        AccessTier = AccessTier.Cool
    };

    FileStream fileStream = File.OpenRead(localFilePath);
    await blockBlobClient.UploadAsync(fileStream, uploadOptions);
    fileStream.Close();
}

Det går bara att ange åtkomstnivå för blockblobar. Du kan ange åtkomstnivån för en blockblob till Hot, Cool, Coldeller Archive. Om du vill ange åtkomstnivån till Coldmåste du använda en lägsta klientbiblioteksversion på 12.15.0.

Mer information om åtkomstnivåer finns i Översikt över åtkomstnivåer.

Ladda upp en blockblob genom mellanlagringsblock och incheckning

Du kan ha större kontroll över hur du delar upp uppladdningar i block genom att mellanlagring av enskilda datablock manuellt. När alla block som utgör en blob mellanlagras kan du checka in dem i Blob Storage. Du kan använda den här metoden för att förbättra prestanda genom att ladda upp block parallellt.

public static async Task UploadBlocksAsync(
    BlobContainerClient blobContainerClient,
    string localFilePath,
    int blockSize)
{
    string fileName = Path.GetFileName(localFilePath);
    BlockBlobClient blobClient = blobContainerClient.GetBlockBlobClient(fileName);

    FileStream fileStream = File.OpenRead(localFilePath);
    ArrayList blockIDArrayList = new ArrayList();
    byte[] buffer;

    var bytesLeft = (fileStream.Length - fileStream.Position);

    while (bytesLeft > 0)
    {
        if (bytesLeft >= blockSize)
        {
            buffer = new byte[blockSize];
            await fileStream.ReadAsync(buffer, 0, blockSize);
        }
        else
        {
            buffer = new byte[bytesLeft];
            await fileStream.ReadAsync(buffer, 0, Convert.ToInt32(bytesLeft));
            bytesLeft = (fileStream.Length - fileStream.Position);
        }

        using (var stream = new MemoryStream(buffer))
        {
            string blockID = Convert.ToBase64String(
                Encoding.UTF8.GetBytes(Guid.NewGuid().ToString()));

            blockIDArrayList.Add(blockID);
            await blobClient.StageBlockAsync(blockID, stream);
        }
        bytesLeft = (fileStream.Length - fileStream.Position);
    }

    string[] blockIDArray = (string[])blockIDArrayList.ToArray(typeof(string));

    await blobClient.CommitBlockListAsync(blockIDArray);
}

Resurser

Mer information om hur du laddar upp blobar med hjälp av Azure Blob Storage-klientbiblioteket för .NET finns i följande resurser.

REST API-åtgärder

Azure SDK för .NET innehåller bibliotek som bygger på Azure REST API, så att du kan interagera med REST API-åtgärder via välbekanta .NET-paradigm. Klientbiblioteksmetoderna för att ladda upp blobar använder följande REST API-åtgärder:

• Placera blob (REST API)
• Placera block (REST API)

Kodexempel

• Visa kodexempel från den här artikeln (GitHub)

Se även

• Prestandajustering för uppladdningar och nedladdningar.
• Hantera och hitta Azure Blob-data med blobindextaggar
• Använda blobindextaggar för att hantera och hitta data på Azure Blob Storage