Blobs weergeven met .NET

Dit artikel laat zien hoe je blobs kunt vermelden met behulp van de Azure Storage clientbibliotheek voor .NET.

Vereisten

• Azure-abonnement: u kunt een gratis abonnement nemen
• Azure Storage-account: maak een opslagaccount
• Nieuwste .NET SDK voor uw besturingssysteem. Zorg ervoor dat u de SDK en niet de runtime ophaalt.

Uw omgeving instellen

Als u geen bestaand project hebt, ziet u in deze sectie hoe u een project instelt voor gebruik met de Azure Blob Storage-clientbibliotheek voor .NET. De stappen omvatten pakketinstallatie, het toevoegen van using instructies en het maken van een geautoriseerd clientobject. Zie Aan de slag met Azure Blob Storage en .NET voor meer informatie.

Pakketten installeren

Installeer vanuit uw projectmap pakketten voor de Azure Blob Storage- en Azure Identity-clientbibliotheken met behulp van de dotnet add package opdracht. Het Azure.Identity-pakket is nodig voor verbindingen zonder wachtwoord met Azure-services.

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

Voeg using-richtlijnen toe

Voeg deze using instructies toe aan het begin van het codebestand:

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

Voor sommige codevoorbeelden in dit artikel zijn mogelijk aanvullende using instructies vereist.

Een clientobject maken

Als u een app wilt verbinden met Blob Storage, maakt u een exemplaar van BlobServiceClient. In het volgende voorbeeld ziet u hoe u een clientobject maakt met behulp van DefaultAzureCredential autorisatie:

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

    return client;
}

U kunt een serviceclient registreren voor afhankelijkheidsinjectie in een .NET-app.

U kunt ook clientobjecten maken voor specifieke containers of blobs. Zie Clientobjecten maken en beheren die interactie hebben met gegevensbronnen voor meer informatie over het maken en beheren van clientobjecten.

Autorisatie

Het autorisatiemechanisme moet over de benodigde machtigingen beschikken om een blob weer te geven. Voor autorisatie met Microsoft Entra ID (aanbevolen) heb je de ingebouwde rol Storage Blob Data Reader of hoger in Azure RBAC nodig. Zie de autorisatierichtlijnen voor List Blobs (REST API) voor meer informatie.

Over opties voor het weergeven van blobs

Wanneer u blobs uit uw code opgeeft, kunt u een aantal opties opgeven om te beheren hoe resultaten worden geretourneerd vanuit Azure Storage. U kunt het aantal resultaten opgeven dat moet worden geretourneerd in elke set resultaten en vervolgens de volgende sets ophalen. U kunt een voorvoegsel opgeven om blobs te retourneren waarvan de namen beginnen met dat teken of die tekenreeks. Je kunt blobs in een vlakke opsommingsstructuur of hiërarchisch weergeven. Een hiërarchische lijst geeft blobs weer alsof ze in mappen zijn georganiseerd.

Als u de blobs in een opslagaccount wilt weergeven, roept u een van de volgende methoden aan:

• BlobContainerClient.GetBlobs
• BlobContainerClient.GetBlobsAsync
• BlobContainerClient.GetBlobsByHierarchy
• BlobContainerClient.GetBlobsByHierarchyAsync

Beheren hoeveel resultaten worden geretourneerd

Standaard retourneert een vermeldingsbewerking maximaal 5000 resultaten tegelijk, maar u kunt het aantal resultaten opgeven dat elke vermeldingsbewerking moet retourneren. De voorbeelden in dit artikel laten zien hoe u resultaten op pagina's kunt retourneren. Zie Paginering met de Azure SDK voor .NET voor meer informatie over pagineringsconcepten.

Resultaten filteren met een voorvoegsel

Als u de lijst met blobs wilt filteren, geeft u een tekenreeks op voor de prefix parameter. De tekenreeks voor het voorvoegsel kan een of meer tekens bevatten. Azure Storage retourneert vervolgens alleen de blobs waarvan de namen beginnen met dat voorvoegsel.

Metagegevens retourneren

U kunt blobmetagegevens met de resultaten retourneren door de metagegevenswaarde voor de opsomming BlobTraits op te geven.

Vlakke lijst versus hiërarchische lijst

Blobs in Azure Storage zijn ingedeeld in een plat paradigma in plaats van een hiërarchisch paradigma (zoals een klassiek bestandssysteem). U kunt blobs echter in virtuele mappen ordenen om een mapstructuur na te bootsen. Een virtuele map maakt deel uit van de naam van de blob en wordt aangegeven door het scheidingsteken.

Als u blobs wilt ordenen in virtuele mappen, gebruikt u een scheidingsteken in de blobnaam. Het standaard scheidingsteken is een schuine streep (/), maar u kunt elk teken als scheidingsteken gebruiken.

Als u de naam van uw blobs opgeeft met behulp van een scheidingsteken, kunt u ervoor kiezen om blobs hiërarchisch weer te geven. Voor een hiërarchische lijstbewerking retourneert Azure Storage alle virtuele mappen en blobs die zich onder het bovenliggende object bevinden. U kunt de vermeldingsbewerking recursief aanroepen om de hiërarchie te doorlopen, vergelijkbaar met de manier waarop u een klassiek bestandssysteem programmatisch zou doorlopen.

Een eenvoudige lijst gebruiken

Standaard geeft een lijstbewerking blobs terug in een platte lijst. In een platte overzicht worden blobs niet geordend op virtuele map.

Het volgende voorbeeld geeft een lijst van de blobs in de opgegeven container door gebruik te maken van een vlakke lijst, met een optionele segmentgrootte opgegeven, en schrijft de blobnaam naar een consolevenster.

private static async Task ListBlobsFlatListing(BlobContainerClient blobContainerClient, 
                                               int? segmentSize)
{
    try
    {
        // Call the listing operation and return pages of the specified size.
        var resultSegment = blobContainerClient.GetBlobsAsync()
            .AsPages(default, segmentSize);

        // Enumerate the blobs returned for each page.
        await foreach (Page<BlobItem> blobPage in resultSegment)
        {
            foreach (BlobItem blobItem in blobPage.Values)
            {
                Console.WriteLine("Blob name: {0}", blobItem.Name);
            }

            Console.WriteLine();
        }
    }
    catch (RequestFailedException e)
    {
        Console.WriteLine(e.Message);
        Console.ReadLine();
        throw;
    }
}

De voorbeelduitvoer is vergelijkbaar met:

Blob name: FolderA/blob1.txt
Blob name: FolderA/blob2.txt
Blob name: FolderA/blob3.txt
Blob name: FolderA/FolderB/blob1.txt
Blob name: FolderA/FolderB/blob2.txt
Blob name: FolderA/FolderB/blob3.txt
Blob name: FolderA/FolderB/FolderC/blob1.txt
Blob name: FolderA/FolderB/FolderC/blob2.txt
Blob name: FolderA/FolderB/FolderC/blob3.txt

Een hiërarchische vermelding gebruiken

Wanneer u een vermeldingsbewerking hiërarchisch aanroept, retourneert Azure Storage de virtuele mappen en blobs op het eerste niveau van de hiërarchie.

Om blobs hiërarchisch te vermelden, roep de BlobContainerClient.GetBlobsByHierarchy of de BlobContainerClient.GetBlobsByHierarchyAsync methode aan.

Het volgende voorbeeld geeft de blobs in de opgegeven container weer door gebruik te maken van een hiërarchische lijst, met een optionele segmentgrootte opgegeven, en schrijft de blobnaam naar het consolevenster.

private static async Task ListBlobsHierarchicalListing(BlobContainerClient container, 
                                                       string prefix, 
                                                       int? segmentSize)
{
    try
    {
        // Call the listing operation and return pages of the specified size.
        var resultSegment = container.GetBlobsByHierarchyAsync(prefix:prefix, delimiter:"/")
            .AsPages(default, segmentSize);

        // Enumerate the blobs returned for each page.
        await foreach (Page<BlobHierarchyItem> blobPage in resultSegment)
        {
            // A hierarchical listing may return both virtual directories and blobs.
            foreach (BlobHierarchyItem blobhierarchyItem in blobPage.Values)
            {
                if (blobhierarchyItem.IsPrefix)
                {
                    // Write out the prefix of the virtual directory.
                    Console.WriteLine("Virtual directory prefix: {0}", blobhierarchyItem.Prefix);

                    // Call recursively with the prefix to traverse the virtual directory.
                    await ListBlobsHierarchicalListing(container, blobhierarchyItem.Prefix, null);
                }
                else
                {
                    // Write out the name of the blob.
                    Console.WriteLine("Blob name: {0}", blobhierarchyItem.Blob.Name);
                }
            }

            Console.WriteLine();
        }
    }
    catch (RequestFailedException e)
    {
        Console.WriteLine(e.Message);
        Console.ReadLine();
        throw;
    }
}

De voorbeelduitvoer is vergelijkbaar met:

Virtual directory prefix: FolderA/
Blob name: FolderA/blob1.txt
Blob name: FolderA/blob2.txt
Blob name: FolderA/blob3.txt

Virtual directory prefix: FolderA/FolderB/
Blob name: FolderA/FolderB/blob1.txt
Blob name: FolderA/FolderB/blob2.txt
Blob name: FolderA/FolderB/blob3.txt

Virtual directory prefix: FolderA/FolderB/FolderC/
Blob name: FolderA/FolderB/FolderC/blob1.txt
Blob name: FolderA/FolderB/FolderC/blob2.txt
Blob name: FolderA/FolderB/FolderC/blob3.txt

Blobversies of momentopnamen weergeven

Als u blobversies of momentopnamen wilt weergeven, geeft u de parameter BlobStates op met het veld Versie of Momentopname . De dienst geeft versies en snapshots terug van oudste tot nieuwste.

In het volgende codevoorbeeld ziet u hoe u blobversies kunt vermelden.

private static void ListBlobVersions(BlobContainerClient blobContainerClient, 
                                           string blobName)
{
    try
    {
        // Call the listing operation, specifying that blob versions are returned.
        // Use the blob name as the prefix. 
        var blobVersions = blobContainerClient.GetBlobs
            (BlobTraits.None, BlobStates.Version, prefix: blobName)
            .OrderByDescending(version => version.VersionId).Where(blob => blob.Name == blobName);

        // Construct the URI for each blob version.
        foreach (var version in blobVersions)
        {
            BlobUriBuilder blobUriBuilder = new BlobUriBuilder(blobContainerClient.Uri)
            {
                BlobName = version.Name,
                VersionId = version.VersionId
            };

            if ((bool)version.IsLatestVersion.GetValueOrDefault())
            {
                Console.WriteLine("Current version: {0}", blobUriBuilder);
            }
            else
            {
                Console.WriteLine("Previous version: {0}", blobUriBuilder);
            }
        }
    }
    catch (RequestFailedException e)
    {
        Console.WriteLine(e.Message);
        Console.ReadLine();
        throw;
    }
}

Blobs weergeven in Apache Arrow-formaat (preview)

Deze mogelijkheid is gebouwd op de bestaande List Blobs API. In plaats van de standaard XML gebruikt het het compacte, kolomvormige Apache Arrow-formaat als responsformaat op de wire. Je schakelt het in door één optie in te stellen op de containerlijst-aanroep. De .NET SDK decodeert Apache Arrow achter de schermen en geeft nog steeds dezelfde BlobItem objecten terug. Deze aanpak verbetert de doorvoersnelheid van lijsten en vermindert de client-side CPU bij het opsommen van grote containers. Het behoudt het responscontract waarop applicaties vertrouwen.

Om Apache Arrow-geformatteerde resultaten op te vragen, zet u de eigenschap ResponseFormat van GetBlobsOptions op StorageResponseFormat.Arrow en geef vervolgens de opties door aan de BlobContainerClient.GetBlobs overload die accepteert GetBlobsOptions. Bij het gebruik van Apache Arrow-uitvoer kun je ook de StartFrom en EndBefore eigenschappen instellen om het bereik van teruggestuurde paden te regelen.

Het volgende voorbeeld geeft de blobs in een container weer en vraagt de resultaten op in Apache Arrow-formaat:

using Azure.Storage;
using Azure.Storage.Blobs.Models;

GetBlobsOptions options = new GetBlobsOptions
{
    Prefix = "FolderA/",
    ResponseFormat = StorageResponseFormat.Arrow
};

foreach (BlobItem blobItem in containerClient.GetBlobs(options))
{
    Console.WriteLine("Blob name: " + blobItem.Name);
}

Hulpmiddelen

Voor meer informatie over hoe je blobs kunt vermelden met behulp van de Azure Blob Storage clientbibliotheek voor .NET, zie de volgende bronnen.

REST API-bewerkingen

De Azure SDK voor .NET bevat bibliotheken die voortbouwen op de Azure REST API. Door gebruik te maken van deze bibliotheken kun je interactie hebben met REST API-operaties via bekende .NET-paradigma's. De clientbibliotheekmethoden voor het weergeven van blobs gebruiken de volgende REST API-bewerking:

• Blobs weergeven (REST API)

Hulpmiddelen voor clientbibliotheken

• Referentiedocumentatie voor clientbibliotheek
• Broncode van clientbibliotheek
• Pakket (NuGet)

Zie ook

• Blob-resources inventariseren
• Blob-versiebeheer

Gerelateerde inhoud

• Dit artikel maakt deel uit van de ontwikkelaarshandleiding voor Blob Storage voor .NET. Zie de volledige lijst met artikelen over ontwikkelaarshandleidingen in Uw .NET-app bouwen voor meer informatie.