Blob feltöltése .NET-tel

  • Cikk

Ez a cikk bemutatja, hogyan tölthet fel blobot a .NET-hez készült Azure Storage ügyfélkódtár használatával. A blokkblobba fájlelérési útból, streamből, bináris objektumból vagy szöveges sztringből tölthet fel adatokat. Megnyithat egy blobstreamet is, és írhat rá, vagy nagy blobokat tölthet fel blokkokban.

Előfeltételek

  • Ez a cikk feltételezi, hogy már van beállítva egy projekt, amely a .NET Azure Blob Storage ügyfélkódtárával működik. A projekt beállításáról, beleértve a csomagtelepítést, az irányelvek hozzáadását using és az engedélyezett ügyfélobjektumok létrehozását, olvassa el az Első lépések a Azure Blob Storage és a .NET használatával című témakört.
  • Az engedélyezési mechanizmusnak rendelkeznie kell a feltöltési művelet végrehajtásához szükséges engedélyekkel. További információért tekintse meg az alábbi REST API-műveletek engedélyezési útmutatóját:

Adatok feltöltése blokkblobba

Az alábbi módszerek egyikével tölthet fel adatokat egy blokkblobba:

A feltöltési módszerek használatakor az ügyfélkódtár meghívhatja a Put Blobot vagy a Put Block hívássorozatot, majd a Put Block List hívásokat. Ez a viselkedés az objektum teljes méretétől és az adatátviteli beállítások beállításától függ.

Ha megnyit egy streamet a Blob Storage-ban, és abba szeretne írni, használja az alábbi módszerek egyikét:

Blokkblob feltöltése helyi fájl elérési útjáról

Az alábbi példa egy blokkblobot tölt fel egy helyi fájl elérési útjából:

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

    await blobClient.UploadAsync(localFilePath, true);
}

Blokkblob feltöltése streamből

Az alábbi példa feltölt egy blokkblobot egy Stream-objektum létrehozásával és a stream feltöltésével.

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

Blokkblob feltöltése BinaryData objektumból

Az alábbi példa feltölt egy blokkblobot egy BinaryData objektumból.

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

Blokkblob feltöltése sztringből

Az alábbi példa egy blokkblobot tölt fel egy sztringből:

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

Feltöltés streambe a Blob Storage-ban

Megnyithat egy streamet a Blob Storage-ban, és írhat rá. Az alábbi példa létrehoz egy zip-fájlt a Blob Storage-ban, és fájlokat ír rá. Ahelyett, hogy zip-fájlt hoz létre a helyi memóriában, egyszerre csak egy fájl van a memóriában.

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

Blokkblob feltöltése konfigurációs beállításokkal

Blob feltöltésekor megadhatja az ügyfélkódtár konfigurációs beállításait. Ezek a lehetőségek a teljesítmény javítása, a megbízhatóság növelése és a költségek optimalizálása érdekében hangolhatók. Az alábbi kódpéldák bemutatják, hogyan definiálhat konfigurációs beállításokat a BlobUploadOptions használatával egy feltöltési metódus meghívásakor.

Adatátviteli beállítások megadása feltöltéskor

A StorageTransferOptions értékeit konfigurálhatja az adatátviteli műveletek teljesítményének javítása érdekében. Az alábbi példakód bemutatja, hogyan állíthat be értékeket egy példányhoz StorageTransferOptions , és hogyan foglalhatja bele a beállításokat BlobUploadOptions . Az ebben a mintában megadott értékek nem javaslatok. Az értékek megfelelő hangolásához figyelembe kell vennie az alkalmazás adott igényeit.

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

Az adatátviteli lehetőségek finomhangolásáról további információt a Feltöltések és letöltések teljesítményhangolása a .NET-tel című témakörben talál.

Átadás-ellenőrzési beállítások megadása feltöltéskor

Az átvitelérvényesítési beállítások megadásával biztosíthatja, hogy az adatok megfelelően legyenek feltöltve, és ne legyenek illetéktelenek az átvitel során. Az átadás-ellenőrzési beállítások ügyfélszinten definiálhatók a BlobClientOptions használatával, amely érvényesítési beállításokat alkalmaz a BlobClient-példányból meghívott összes metódusra.

A BlobUploadOptions használatával felülbírálhatja az átvitelérvényesítési beállításokat a metódus szintjén. Az alábbi példakód bemutatja, hogyan hozhat létre objektumot BlobUploadOptions , és hogyan adhat meg algoritmust ellenőrzőösszeg létrehozásához. Ezt követően a szolgáltatás az ellenőrzőösszeget használja a feltöltött tartalom adatintegritásának ellenőrzésére.

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

Az alábbi táblázat a StorageChecksumAlgorithm által meghatározott ellenőrzőösszeg-algoritmus elérhető lehetőségeit mutatja be:

Name Érték Leírás
Automatikus 0 Ajánlott. Lehetővé teszi, hogy a kódtár algoritmust válasszon. A kódtár különböző verziói különböző algoritmusokat választhatnak.
None 1 Nincs kijelölt algoritmus. Ne számítsa ki vagy kérje le az ellenőrzőösszegeket.
MD5 2 Standard MD5 kivonatolási algoritmus.
StorageCrc64 3 Egyéni 64 bites Azure Storage CRC.

Megjegyzés

Ha a kérelemben megadott ellenőrzőösszeg nem egyezik a szolgáltatás által kiszámított ellenőrzőösszegtel, a feltöltési művelet meghiúsul. A rendszer nem próbálkozik újra a művelettel, ha alapértelmezett újrapróbálkozási szabályzatot használ. A .NET-ben RequestFailedException a a 400-ás állapotkóddal és a vagy Crc64Mismatcha hibakóddal Md5Mismatch jelenik meg, attól függően, hogy melyik algoritmust használja.

Feltöltés indexcímkékkel

A blobindexcímkék a kulcs-érték címkeattribútumok használatával kategorizálják a tárfiókban lévő adatokat. Ezeket a címkéket a rendszer automatikusan indexeli és elérhetővé teszi kereshető többdimenziós indexként, hogy könnyen megtalálja az adatokat. Hozzáadhat címkéket egy BlobUploadOptions-példányhoz , és átadhatja a példányt a UploadAsync metódusnak.

Az alábbi példa egy indexcímkéket tartalmazó blokkblobot tölt fel:

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

Blob hozzáférési szintjének beállítása feltöltés esetén

A blobok hozzáférési szintjét feltöltéskor a BlobUploadOptions osztály használatával állíthatja be. Az alábbi példakód bemutatja, hogyan állíthatja be a hozzáférési szintet egy blob feltöltésekor:

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

A hozzáférési szint beállítása csak blokkblobok esetében engedélyezett. A blokkblobok hozzáférési szintjét beállíthatja a következőre: Hot, Cool, Coldvagy Archive. A hozzáférési szint Coldbeállításához a 12.15.0-s minimális ügyfélkódtár-verziót kell használnia.

További információ a hozzáférési szintekről: Hozzáférési szintek áttekintése.

Blokkblob feltöltése blokkok előkészítésével és véglegesítésével

Az egyes adatblokkok manuális előkészítésével nagyobb mértékben szabályozhatja a feltöltések blokkokra való felosztását. Ha a blobot alkotó összes blokkot előkészítette, véglegesítheti őket a Blob Storage-ban. Ezzel a megközelítéssel növelheti a teljesítményt blokkok párhuzamos feltöltésével.

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

Források

Ha többet szeretne megtudni a blobok .NET-hez készült Azure Blob Storage-ügyfélkódtár használatával történő feltöltéséről, tekintse meg az alábbi forrásanyagokat.

REST API-műveletek

A .NET-hez készült Azure SDK olyan kódtárakat tartalmaz, amelyek az Azure REST API-ra épülnek, lehetővé téve a REST API-műveletek használatát a jól ismert .NET-paradigmákon keresztül. A blobok feltöltésére szolgáló ügyfélkódtár-metódusok a következő REST API-műveleteket használják:

Kódminták

Lásd még