Snabbstart: Azure Blob Storage klientbibliotek v12 för .NET

Kom igång med Azure Blob Storage-klientbiblioteket v12 för .NET. Azure Blob Storage är Microsofts objektlagringslösning för molnet. Följ stegen för att installera paketet och prova exempelkoden för grundläggande uppgifter. Blob Storage är optimerad för lagring av enorma mängder ostrukturerade data.

Använd Azure Blob Storage-klientbiblioteket v12 för .NET för att:

  • Skapa en container
  • Ladda upp en blob till Azure Storage
  • Lista alla blobar i en container
  • Ladda ned bloben till din lokala dator
  • Ta bort en container

Ytterligare resurser:

Anteckning

Funktionerna som beskrivs i den här artikeln är också tillgängliga för konton som har en hierarkisk namnrymd. Om du vill granska begränsningar kan du läsa artikeln om blobblagringsfunktioner Azure Data Lake Storage Gen2 artikeln.

Förutsättningar

Inrätta

Det här avsnittet går igenom hur du förbereder ett projekt för att arbeta Azure Blob Storage klientbiblioteket v12 för .NET.

Skapa projektet

Skapa ett .NET Core-program med namnet BlobQuickstartV12.

  1. I ett konsolfönster (till exempel cmd, PowerShell eller Bash) använder du kommandot för att skapa en ny konsolapp med namnet dotnet new BlobQuickstartV12. Det här kommandot skapar ett enkelt "Hello World" C#-projekt med en enda källfil: Program.cs.

    dotnet new console -n BlobQuickstartV12
    
  2. Växla till den nyligen skapade BlobQuickstartV12-katalogen.

    cd BlobQuickstartV12
    
  3. Skapa en annan katalog med namnet data på sidan av katalogen BlobQuickstartV12. Det är här som blobdatafilerna skapas och lagras.

    mkdir data
    

Installera paketet

När du fortfarande är i programkatalogen installerar du Azure Blob Storage för .NET-paketet med hjälp av dotnet add package kommandot .

dotnet add package Azure.Storage.Blobs

Konfigurera appramverket

Från projektkatalogen:

  1. Öppna filen Program.cs i redigeringsprogrammet.

  2. Ta bort Console.WriteLine("Hello World!"); -instruktionen.

  3. Lägg using till direktiv.

  4. Uppdatera Main metoddeklarationen för att stödja asynkronisering.

    Här är koden:

    using Azure.Storage.Blobs;
    using Azure.Storage.Blobs.Models;
    using System;
    using System.IO;
    using System.Threading.Tasks;
    
    namespace BlobQuickstartV12
    {
        class Program
        {
            static async Task Main()
            {
            }
        }
    }
    

Kopiera dina autentiseringsuppgifter från Azure-portalen

När exempelprogrammet gör en begäran till Azure Storage måste det auktoriserats. Om du vill auktorisera en begäran lägger du till autentiseringsuppgifterna för ditt lagringskonto i programmet som en anslutningssträng. Visa autentiseringsuppgifterna för lagringskontot genom att följa dessa steg:

  1. Logga in på Azure-portalen.

  2. Leta rätt på ditt lagringskonto.

  3. I avsnittet Säkerhet + nätverk i översikten för lagringskontot väljer du Åtkomstnycklar. Här kan du visa åtkomstnycklarna för kontot och den fullständiga anslutningssträngen för varje nyckel.

  4. Sök efter värdet för Anslutningssträng under key1 och kopiera anslutningssträngen genom att välja Kopiera. Du lägger till strängvärdet för anslutningen till en miljövariabel i nästa steg.

    Skärmbild som visar hur man kopierar en anslutningssträng från Azure-portalen

Konfigurera anslutningssträngen för lagring

När du har kopierat anslutningssträngen ska du skriva den till en ny miljövariabel på den lokala dator där programmet körs. Konfigurera miljövariabeln genom att öppna ett konsolfönster och följa anvisningarna för ditt operativsystem. Ersätt <yourconnectionstring> med din faktiska anslutningssträng.

Windows

setx AZURE_STORAGE_CONNECTION_STRING "<yourconnectionstring>"

När du har lagt till miljövariabeln i Windows måste du starta en ny instans av kommandofönstret.

Linux

export AZURE_STORAGE_CONNECTION_STRING="<yourconnectionstring>"

macOS

export AZURE_STORAGE_CONNECTION_STRING="<yourconnectionstring>"

Starta om program

När du har lagt till miljövariabeln startar du om alla program som körs och behöver läsa miljövariabeln. Du kan till exempel starta om utvecklingsmiljön eller redigeringsredigeraren innan du fortsätter.

Objektmodell

Azure Blob Storage är optimerad för att lagra enorma mängder ostrukturerade data. Ostrukturerade data är data som inte följer en viss datamodell eller definition, till exempel text eller binära data. I blobblagringen finns tre typer av resurser:

  • Lagringskontot
  • En container på lagringskontot
  • En blob i containern

Följande diagram visar relationen mellan de här resurserna.

Diagram över blobblagringens arkitektur

Använd följande .NET-klasser för att interagera med dessa resurser:

  • BlobServiceClient:Med BlobServiceClient klassen kan du ändra Azure Storage och blobcontainrar.
  • BlobContainerClient:Med BlobContainerClient klassen kan du ändra Azure Storage och deras blobar.
  • BlobClient:Med BlobClient klassen kan du ändra Azure Storage blobar.
  • BlobDownloadInfo:Klassen BlobDownloadInfo representerar de egenskaper och innehåll som returneras när en blob laddas ned.

Kodexempel

De här exempelkodfragmenten visar hur du utför följande med Azure Blob Storage klientbibliotek för .NET:

Hämta anslutningssträngen

Koden nedan hämtar anslutningssträngen för lagringskontot från miljövariabeln som skapades i avsnittet Konfigurera lagringsanslutningssträngen.

Lägg till den här koden i Main metoden :

Console.WriteLine("Azure Blob Storage v12 - .NET quickstart sample\n");

// Retrieve the connection string for use with the application. The storage
// connection string is stored in an environment variable on the machine
// running the application called AZURE_STORAGE_CONNECTION_STRING. If the
// environment variable is created after the application is launched in a
// console or with Visual Studio, the shell or application needs to be closed
// and reloaded to take the environment variable into account.
string connectionString = Environment.GetEnvironmentVariable("AZURE_STORAGE_CONNECTION_STRING");

Skapa en container

Bestäm ett namn för den nya containern. Koden nedan lägger till ett GUID-värde i containernamnet för att säkerställa att det är unikt.

Viktigt

Containernamn måste använda gemener. Mer information om namngivning av containrar och blobar finns i Namngivning och referens av containrar, blobar och metadata.

Skapa en instans av klassen BlobServiceClient. Anropa sedan metoden CreateBlobContainerAsync för att skapa containern i ditt lagringskonto.

Lägg till den här koden i slutet av Main metoden:

// Create a BlobServiceClient object which will be used to create a container client
BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);

//Create a unique name for the container
string containerName = "quickstartblobs" + Guid.NewGuid().ToString();

// Create the container and return a container client object
BlobContainerClient containerClient = await blobServiceClient.CreateBlobContainerAsync(containerName);

Ladda upp blobar till en container

Följande kodfragment:

  1. Skapar en textfil i den lokala datakatalogen.
  2. Hämtar en referens till ett BlobClient-objekt genom att anropa metoden GetBlobClient i containern från avsnittet Skapa en container.
  3. Laddar upp den lokala textfilen till bloben genom att anropa metoden UploadAsync. Den här metoden skapar bloben om den inte redan finns, och skriver över den om den finns.

Lägg till den här koden i slutet av Main metoden:

// Create a local file in the ./data/ directory for uploading and downloading
string localPath = "./data/";
string fileName = "quickstart" + Guid.NewGuid().ToString() + ".txt";
string localFilePath = Path.Combine(localPath, fileName);

// Write text to the file
await File.WriteAllTextAsync(localFilePath, "Hello, World!");

// Get a reference to a blob
BlobClient blobClient = containerClient.GetBlobClient(fileName);

Console.WriteLine("Uploading to Blob storage as blob:\n\t {0}\n", blobClient.Uri);

// Open the file and upload its data
using FileStream uploadFileStream = File.OpenRead(localFilePath);
await blobClient.UploadAsync(uploadFileStream, true);
uploadFileStream.Close();

Visa blobar i en container

Visa en lista över blobarna i containern genom att anropa metoden GetBlobsAsync. I det här fallet har endast en blob lagts till i containern, så liståtgärden returnerar bara den enda bloben.

Lägg till den här koden i slutet av Main metoden:

Console.WriteLine("Listing blobs...");

// List all blobs in the container
await foreach (BlobItem blobItem in containerClient.GetBlobsAsync())
{
    Console.WriteLine("\t" + blobItem.Name);
}

Ladda ned blobbar

Ladda ned bloben som du skapade tidigare genom att anropa downloadAsync-metoden. Exempelkoden lägger till suffixet "DOWNLOADED" i filnamnet så att du kan se båda filerna i det lokala filsystemet.

Lägg till den här koden i slutet av Main metoden:

// Download the blob to a local file
// Append the string "DOWNLOADED" before the .txt extension 
// so you can compare the files in the data directory
string downloadFilePath = localFilePath.Replace(".txt", "DOWNLOADED.txt");

Console.WriteLine("\nDownloading blob to\n\t{0}\n", downloadFilePath);

// Download the blob's contents and save it to a file
BlobDownloadInfo download = await blobClient.DownloadAsync();

using (FileStream downloadFileStream = File.OpenWrite(downloadFilePath))
{
    await download.Content.CopyToAsync(downloadFileStream);
    downloadFileStream.Close();
}

Ta bort en container

Följande kod rensar de resurser som appen skapade genom att ta bort hela containern med hjälp av DeleteAsync. Den tar även bort de lokala filer som skapats av appen.

Appen pausar för användarindata genom att Console.ReadLine anropa innan den tar bort bloben, containern och lokala filer. Det här är en bra chans att kontrollera att resurserna faktiskt har skapats korrekt, innan de tas bort.

Lägg till den här koden i slutet av Main metoden:

// Clean up
Console.Write("Press any key to begin clean up");
Console.ReadLine();

Console.WriteLine("Deleting blob container...");
await containerClient.DeleteAsync();

Console.WriteLine("Deleting the local source and downloaded files...");
File.Delete(localFilePath);
File.Delete(downloadFilePath);

Console.WriteLine("Done");

Kör koden

Den här appen skapar en testfil i din lokala datamapp och laddar upp den till Blob Storage. Exemplet visar sedan blobarna i containern och laddar ned filen med ett nytt namn så att du kan jämföra de gamla och nya filerna.

Gå till programkatalogen och skapa och kör sedan programmet.

dotnet build
dotnet run

Appens utdata liknar följande exempel:

Azure Blob Storage v12 - .NET quickstart sample

Uploading to Blob storage as blob:
         https://mystorageacct.blob.core.windows.net/quickstartblobs60c70d78-8d93-43ae-954d-8322058cfd64/quickstart2fe6c5b4-7918-46cb-96f4-8c4c5cb2fd31.txt

Listing blobs...
        quickstart2fe6c5b4-7918-46cb-96f4-8c4c5cb2fd31.txt

Downloading blob to
        ./data/quickstart2fe6c5b4-7918-46cb-96f4-8c4c5cb2fd31DOWNLOADED.txt

Press any key to begin clean up
Deleting blob container...
Deleting the local source and downloaded files...
Done

Kontrollera datamappen för de två filerna innan du påbörjar rensningsprocessen. Du kan öppna dem och se att de är identiska.

När du har verifierat filerna trycker du på Retur för att ta bort testfilerna och avsluta demonstrationen.

Nästa steg

I den här snabbstarten har du lärt dig att ladda upp, ladda ned och lista blobar med hjälp av .NET.

Om du vill se Blob Storage-exempelappar fortsätter du till: