Een blob uploaden met .NET

• .NET
• Java
• JavaScript
• TypeScript
• Python

In dit artikel leest u hoe u een blob uploadt met behulp van de Azure Storage-clientbibliotheek voor .NET. U kunt gegevens uploaden naar een blok-blob vanuit een bestandspad, een stroom, een binair object of een teksttekenreeks. U kunt ook een blobstream openen en ernaar schrijven of grote blobs in blokken uploaden.

Vereisten

• In dit artikel wordt ervan uitgegaan dat u al een project hebt ingesteld om te werken met de Azure Blob Storage-clientbibliotheek voor .NET. Zie Aan de slag met Azure Blob Storage en .NET voor meer informatie over het instellen van uw project, inclusief pakketinstallatie, het toevoegen using van instructies en het maken van een geautoriseerd clientobject.
• Het autorisatiemechanisme moet machtigingen hebben om een uploadbewerking uit te voeren. Zie de autorisatierichtlijnen voor de volgende REST API-bewerkingen voor meer informatie:
  • Blob plaatsen
  • Blok plaatsen

Gegevens uploaden naar een blok-blob

U kunt een van de volgende methoden gebruiken om gegevens te uploaden naar een blok-blob:

• Uploaden
• UploadAsync

Wanneer u deze uploadmethoden gebruikt, kan de clientbibliotheek Put Blob of een reeks Put Block-aanroepen aanroepen aanroepen, gevolgd door Put Block List. Dit gedrag is afhankelijk van de totale grootte van het object en hoe de opties voor gegevensoverdracht zijn ingesteld.

Gebruik een van de volgende methoden om een stream te openen in Blob Storage en naar die stroom te schrijven:

• OpenWrite
• OpenWriteAsync

Een blok-blob uploaden vanuit een lokaal bestandspad

In het volgende voorbeeld wordt een blok-blob geüpload vanuit een lokaal bestandspad:

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

    await blobClient.UploadAsync(localFilePath, true);
}

Een blok-blob uploaden vanuit een stream

In het volgende voorbeeld wordt een blok-blob geüpload door een Stream-object te maken en de stream te uploaden.

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();
}

Een blok-blob uploaden vanuit een BinaryData-object

In het volgende voorbeeld wordt een blok-blob geüpload vanuit een BinaryData-object .

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();
}

Een blok-blob uploaden vanuit een tekenreeks

In het volgende voorbeeld wordt een blok-blob geüpload vanuit een tekenreeks:

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);
}

Uploaden naar een stream in Blob Storage

U kunt een stream openen in Blob Storage en ernaar schrijven. In het volgende voorbeeld wordt een zip-bestand gemaakt in Blob Storage en worden er bestanden naartoe geschreven. In plaats van een zip-bestand in het lokale geheugen te maken, bevindt zich slechts één bestand tegelijk in het geheugen.

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);
                    }
                }
            }
        }
    }
}

Een blok-blob uploaden met configuratieopties

U kunt configuratieopties voor de clientbibliotheek definiëren bij het uploaden van een blob. Deze opties kunnen worden afgestemd om de prestaties te verbeteren, de betrouwbaarheid te verbeteren en de kosten te optimaliseren. De volgende codevoorbeelden laten zien hoe u BlobUploadOptions gebruikt om configuratieopties te definiëren bij het aanroepen van een uploadmethode.

Opties voor gegevensoverdracht opgeven bij het uploaden

U kunt de waarden in StorageTransferOptions configureren om de prestaties voor gegevensoverdrachtbewerkingen te verbeteren. In het volgende codevoorbeeld ziet u hoe u waarden instelt voor StorageTransferOptions en de opties opneemt als onderdeel van een BlobUploadOptions exemplaar. De waarden in dit voorbeeld zijn niet bedoeld als aanbeveling. Als u deze waarden goed wilt afstemmen, moet u rekening houden met de specifieke behoeften van uw app.

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();
}

Zie Prestaties afstemmen voor uploads en downloads met .NET voor meer informatie over het afstemmen van opties voor gegevensoverdracht.

Opties voor overdrachtsvalidatie opgeven bij het uploaden

U kunt opties voor overdrachtsvalidatie opgeven om ervoor te zorgen dat gegevens correct worden geüpload en niet zijn gemanipuleerd tijdens de overdracht. Opties voor overdrachtsvalidatie kunnen worden gedefinieerd op clientniveau met behulp van BlobClientOptions, waarmee validatieopties worden toegepast op alle methoden die worden aangeroepen vanuit een BlobClient-exemplaar .

U kunt ook opties voor overdrachtsvalidatie op methodeniveau overschrijven met behulp van BlobUploadOptions. In het volgende codevoorbeeld ziet u hoe u een BlobUploadOptions object maakt en een algoritme opgeeft voor het genereren van een controlesom. De controlesom wordt vervolgens door de service gebruikt om de gegevensintegriteit van de geüploade inhoud te controleren.

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();
}

In de volgende tabel ziet u de beschikbare opties voor het controlesomalgoritme, zoals gedefinieerd door StorageChecksumAlgorithm:

Name	Waarde	Beschrijving
Automatisch	0	Aanbevolen. Hiermee kan de bibliotheek een algoritme kiezen. Verschillende bibliotheekversies kunnen verschillende algoritmen kiezen.
Geen	1	Geen geselecteerd algoritme. U hoeft geen controlesommen te berekenen of aan te vragen.
MD5	2	Standaard MD5-hash-algoritme.
StorageCrc64	3	Aangepaste 64-bits Azure Storage-CRC.

Notitie

Als de controlesom die in de aanvraag is opgegeven niet overeenkomt met de controlesom die door de service is berekend, mislukt de uploadbewerking. De bewerking wordt niet opnieuw geprobeerd wanneer u een standaardbeleid voor opnieuw proberen gebruikt. In .NET wordt een RequestFailedException gegenereerd met statuscode 400 en foutcode Md5Mismatch of Crc64Mismatch, afhankelijk van welk algoritme wordt gebruikt.

Uploaden met indextags

Blob-indextags categoriseren gegevens in uw opslagaccount met behulp van tagkenmerken voor sleutelwaarden. Deze tags worden automatisch geïndexeerd en weergegeven als een doorzoekbare multidimensionale index om eenvoudig gegevens te vinden. U kunt tags toevoegen aan een BlobUploadOptions-exemplaar en dat exemplaar doorgeven aan de UploadAsync methode.

In het volgende voorbeeld wordt een blok-blob met indextags geüpload:

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);
}

De toegangslaag van een blob instellen bij het uploaden

U kunt de toegangslaag van een blob instellen bij het uploaden met behulp van de blobUploadOptions-klasse . In het volgende codevoorbeeld ziet u hoe u de toegangslaag instelt bij het uploaden van een 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();
}

Het instellen van de toegangslaag is alleen toegestaan voor blok-blobs. U kunt de toegangslaag voor een blok-blob instellen op Hot, Cool, Coldof Archive. Als u de toegangslaag wilt instellen op Cold, moet u minimaal versie 12.15.0 van de clientbibliotheek gebruiken.

Zie Overzicht van toegangslagen voor meer informatie over toegangslagen.

Een blok-blob uploaden door blokken te faseren en door te voeren

U hebt meer controle over het verdelen van uploads in blokken door afzonderlijke gegevensblokken handmatig te faseren. Wanneer alle blokken waaruit een blob bestaat, zijn gefaseerd, kunt u ze doorvoeren in Blob Storage. U kunt deze methode gebruiken om de prestaties te verbeteren door blokken parallel te uploaden.

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);
}

Resources

Zie de volgende bronnen voor meer informatie over het uploaden van blobs met behulp van de Azure Blob Storage-clientbibliotheek voor .NET.

REST API-bewerkingen

De Azure SDK voor .NET bevat bibliotheken die zijn gebaseerd op de Azure REST API, zodat u kunt communiceren met REST API-bewerkingen via bekende .NET-paradigma's. De clientbibliotheekmethoden voor het uploaden van blobs maken gebruik van de volgende REST API-bewerkingen:

• Put Blob (REST API)
• Put Block (REST API)

Codevoorbeelden

• Codevoorbeelden uit dit artikel weergeven (GitHub)

Zie ook

• Prestaties afstemmen voor uploads en downloads.
• Azure Blob-gegevens beheren en zoeken met blob-indextags
• Blob-indextags gebruiken om gegevens op Azure Blob Storage te beheren en te zoeken