Megosztás a következőn keresztül:

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. Adatokat feltölthet egy blokkblobba egy fájl elérési útjáról, egy streamből, egy bináris objektumból vagy egy szöveges sztringből. Megnyithat egy blobstreamet, és írhat hozzá, vagy nagy blobokat tölthet fel blokkokban.

Előfeltételek

Saját környezet beállítása

Ha nem rendelkezik meglévő projekttel, ez a szakasz bemutatja, hogyan állíthat be projektet a .NET-hez készült Azure Blob Storage ügyfélkódtár használatához. A lépések közé tartozik a csomagtelepítés, az irányelvek hozzáadása using és egy engedélyezett ügyfélobjektum létrehozása. További részletekért tekintse meg az Azure Blob Storage és a .NET használatának első lépéseit.

Csomagok telepítése

A projektkönyvtárból telepítse az Azure Blob Storage- és Az Azure Identity-ügyfélkódtárak csomagjait a dotnet add package paranccsal. Az Azure.Identity-csomagra az Azure-szolgáltatásokhoz való jelszó nélküli kapcsolatokhoz van szükség.

dotnet add package Azure.Storage.Blobs
dotnet add package Azure.Identity

Irányelvek hozzáadása using

Adja hozzá ezeket az using irányelveket a kódfájl elejéhez:

using Azure.Identity;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using Azure.Storage.Blobs.Specialized;

A cikkben szereplő néhány példakód további using irányelveket igényelhet.

Ügyfélobjektum létrehozása

Ha egy alkalmazást a Blob Storage-hoz szeretne csatlakoztatni, hozzon létre egy BlobServiceClient-példányt. Az alábbi példa bemutatja, hogyan hozhat létre ügyfélobjektumot DefaultAzureCredential engedélyezés céljából:

public BlobServiceClient GetBlobServiceClient(string accountName)
{
    BlobServiceClient client = new(
        new Uri($"https://{accountName}.blob.core.windows.net"),
        new DefaultAzureCredential());

    return client;
}

A szolgáltatásügyfél regisztrálható a függőséginjektáláshoz egy .NET-alkalmazásban.

Ügyfélobjektumokat is létrehozhat adott tárolókhoz vagy blobokhoz. Az ügyfélobjektumok létrehozásáról és kezeléséről további információt az adaterőforrásokat kezelő ügyfélobjektumok létrehozása és kezelése című témakörben talál.

Engedélyezés

Az engedélyezési mechanizmusnak rendelkeznie kell a blob feltöltéséhez szükséges engedélyekkel. A Microsoft Entra-azonosítóval való engedélyezéshez (ajánlott) az Azure RBAC beépített szerepkörű Storage Blob Data Közreműködő vagy újabb szerepkörre van szüksége. További információkért tekintse meg a Put Blob (REST API) és a Put Block (REST API) engedélyezési útmutatóját.

Adatok feltöltése blokkblobba

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

A feltöltési módszerek használatakor az ügyfélkódtár meghívhatja a Put Blob vagy a Put Block hívások sorozatát, majd a Blokklista elhelyezése parancsot. 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 a streambe 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áró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 hozzá. 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 példakód bemutatja, hogyan definiálhat konfigurációs beállításokat a BlobUploadOptions használatával egy feltöltési módszer 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 StorageTransferOptions egy példányhoz, és hogyan foglalhatja bele a beállításokat BlobUploadOptions . Az ebben a mintában megadott értékek nem javaslatok. Ezeknek az értékeknek a megfelelő finomhangolá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ával kapcsolatos további információkért lásd a feltöltések és letöltések teljesítményhangolását a .NET-tel.

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

Az átviteli érvényesítési lehetőségek megadásával biztosítható, hogy az adatok feltöltése megfelelően történjen, és ne legyenek illetéktelenek az átvitel során. Az átviteli érvényesíté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 hí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 is. Az alábbi példakód bemutatja, hogyan hozhat létre objektumot BlobUploadOptions , és hogyan adhat meg algoritmust egy 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ő beállításait mutatja be:

Név szerint É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.
Egyik sem 0 Nincs kijelölt algoritmus. Ne számítsa ki vagy kérje az ellenőrzőösszegeket.
MD5 2 Standard MD5 kivonatoló algoritmus.
StorageCrc64 3 Egyéni Azure Storage 64 bites CRC.

Feljegyzés

Ha a kérelemben megadott ellenőrzőösszeg nem felel meg a szolgáltatás által kiszámított ellenőrzőösszegnek, a feltöltési művelet meghiúsul. A művelet nem lesz újrapróbálkozott alapértelmezett újrapróbálkozási szabályzat használatakor. A .NET-ben a rendszer a RequestFailedException 400-ás állapotkóddal és hibakóddal Md5Mismatch vagy Crc64Mismatch– attól függően, hogy melyik algoritmust használja – dobja ki.

Feltöltés indexcímkékkel

A blobindexcímkék kulcs-érték címkeattribútumok használatával kategorizálják a tárfiók adatait. Ezek a címkék automatikusan indexelhetők, és kereshető többdimenziós indexként jelennek meg az adatok egyszerű keresése érdekében. Címkéket adhat hozzá 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ésre

A blobok hozzáférési szintjét a BlobUploadOptions osztály használatával állíthatja be feltöltéskor. 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én engedélyezett. A blokkblobok Hothozzáférési szintjét a következőre állíthatja be: , Coolvagy ArchiveCold. 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.

A hozzáférési szintekről további információt az Access-szintek áttekintésében talál.

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. Amikor a blobokat 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 erőforrásokat.

Kódminták

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 ismerős .NET-paradigmákon keresztül. A blobok feltöltéséhez használt ügyfélkódtár-metódusok a következő REST API-műveleteket használják:

  • Blob elhelyezése (REST API)
  • Blokk elhelyezése (REST API)

Lásd még

Kapcsolódó tartalom