Lab 3: Access containers by using the .NET SDK

Task 1: Create .NET project

On the Start screen, select the Visual Studio Code tile.
On the File menu, select Open Folder, browse to $HOME\training-az204\Labs\03\Starter\BlobManager, and then select Select Folder.
In the Visual Studio Code window, on the Menu Bar, select Terminal and then select New Terminal.
In the terminal, run the following command to create a new .NET project named BlobManager in the current folder:
```
dotnet new console --framework net6.0 --name BlobManager --output .
```
Note: The dotnet new command will create a new console project in a folder with the same name as the project.
In the terninal, run the following command to import version 12.12.0 of Azure.Storage.Blobs from NuGet:
```
dotnet add package Azure.Storage.Blobs --version 12.12.0
```
Note: The dotnet add package command will add the Azure.Storage.Blobs package from NuGet. For more information, refer to Azure.Storage.Blobs.
In the terminal, run the following command to build the .NET web application:
```
dotnet build
```
Select Kill Terminal or the Recycle Bin icon to close the currently open terminal and any associated processes.

Task 2: Modify the Program class to access Storage

On the Explorer pane of the Visual Studio Code window, open the Program.cs file.
On the code editor tab for the Program.cs file, delete all the code in the existing file.
Add the following line of code to import the Azure.Storage, Azure.Storage.Blobs, and Azure.Storage.Blobs.Models namespaces from the Azure.Storage.Blobs package imported from NuGet:
```
using Azure.Storage;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
```
Add the following lines of code to add using directives for the built-in namespaces that will be used in this file:
```
using System;
using System.Threading.Tasks;
```
Enter the following code to create a new Program class:
```
public class Program
{
}
```
In the Program class, enter the following line of code to create a new string constant named blobServiceEndpoint:
```
private const string blobServiceEndpoint = "";
```
Update the blobServiceEndpoint string constant by setting its value to the Primary Blob Service Endpoint of the storage account that you recorded previously in this lab.
In the Program class, enter the following line of code to create a new string constant named storageAccountName:
```
private const string storageAccountName = "";
```
Update the storageAccountName string constant by setting its value to the Storage account name of the storage account that you recorded previously in this lab.
In the Program class, enter the following line of code to create a new string constant named storageAccountKey:
```
private const string storageAccountKey = "";
```
Update the storageAccountKey string constant by setting its value to the Key of the storage account that you recorded previously in this lab.
In the Program class, enter the following code to create a new asynchronous Main method:
```
public static async Task Main(string[] args)
{
}
```

Review the Program.cs file, which should now include:

using Azure.Storage;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using System;
using System.Threading.Tasks;    
public class Program
{
    private const string blobServiceEndpoint = "<primary-blob-service-endpoint>";
    private const string storageAccountName = "<storage-account-name>";
    private const string storageAccountKey = "<key>";    
    public static async Task Main(string[] args)
    {
    }
}

Task 3: Connect to the Azure Storage blob service endpoint

In the Main method, add the following line of code to create a new instance of the StorageSharedKeyCredential class by using the storageAccountName and storageAccountKey constants as constructor parameters:
```
StorageSharedKeyCredential accountCredentials = new StorageSharedKeyCredential(storageAccountName, storageAccountKey);
```
In the Main method, add the following line of code to create a new instance of the BlobServiceClient class by using the blobServiceEndpoint constant and the accountCredentials variable as constructor parameters:
```
BlobServiceClient serviceClient = new BlobServiceClient(new Uri(blobServiceEndpoint), accountCredentials);
```
In the Main method, add the following line of code to invoke the GetAccountInfoAsync method of the BlobServiceClient class to retrieve account metadata from the service:
```
AccountInfo info = await serviceClient.GetAccountInfoAsync();
```
In the Main method, add the following line of code to render a welcome message:
```
await Console.Out.WriteLineAsync($"Connected to Azure Storage Account");
```
In the Main method, add the following line of code to render the storage account's name:
```
await Console.Out.WriteLineAsync($"Account name:\t{storageAccountName}");
```
In the Main method, add the following line of code to render the type of storage account:
```
await Console.Out.WriteLineAsync($"Account kind:\t{info?.AccountKind}");
```
In the Main method, add the following line of code to render the currently selected stock keeping unit (SKU) for the storage account:
```
await Console.Out.WriteLineAsync($"Account sku:\t{info?.SkuName}");
```

Review the Main method, which should now include:

public static async Task Main(string[] args)
{
    StorageSharedKeyCredential accountCredentials = new StorageSharedKeyCredential(storageAccountName, storageAccountKey);
    BlobServiceClient serviceClient = new BlobServiceClient(new Uri(blobServiceEndpoint), accountCredentials);
    AccountInfo info = await serviceClient.GetAccountInfoAsync();
    await Console.Out.WriteLineAsync($"Connected to Azure Storage Account");
    await Console.Out.WriteLineAsync($"Account name:\t{storageAccountName}");
    await Console.Out.WriteLineAsync($"Account kind:\t{info?.AccountKind}");
    await Console.Out.WriteLineAsync($"Account sku:\t{info?.SkuName}");
}

Save the Program.cs file.
In the Visual Studio Code window, on the Menu Bar, select Terminal and then select New Terminal.
In the terminal, run the following command to run the .NET web application:
```
dotnet run
```
Note: If there are any build errors, review the Program.cs file in the $HOME\training-az204\\Labs\03\Solution\BlobManager folder.
Observe the output from the currently running console application. The output contains metadata for the storage account that was retrieved from the service.
Select Kill Terminal or the Recycle Bin icon to close the currently open terminal and any associated processes.

Task 4: Enumerate the existing containers

In the Program class, enter the following code to create a new private static method named EnumerateContainersAsync, that's asynchronous and has a single BlobServiceClient parameter type:
```
private static async Task EnumerateContainersAsync(BlobServiceClient client)
{        
}
```
In the EnumerateContainersAsync method, enter the following code to create an asynchronous foreach loop that iterates over the results of an invocation of the GetBlobContainersAsync method of the BlobServiceClient class:
```
await foreach (BlobContainerItem container in client.GetBlobContainersAsync())
{
}
```
Within the foreach loop, enter the following code to print the name of each container:
```
await Console.Out.WriteLineAsync($"Container:\t{container.Name}");
```

Review the EnumerateContainersAsync method, which should now include:

private static async Task EnumerateContainersAsync(BlobServiceClient client)
{        
    await foreach (BlobContainerItem container in client.GetBlobContainersAsync())
    {
        await Console.Out.WriteLineAsync($"Container:\t{container.Name}");
    }
}

In the Main method, enter the following code at the end of the method to invoke the EnumerateContainersAsync method, passing in the serviceClient variable as a parameter:
```
await EnumerateContainersAsync(serviceClient);
```

Observe the Program.cs file, which should now include:

using Azure.Storage;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using System;
using System.Threading.Tasks;

public class Program
{
    private const string blobServiceEndpoint = "your blobServiceEndpoint";
    private const string storageAccountName = "your storageAccountName";
    private const string storageAccountKey = "your storageAccountKey";    
    public static async Task Main(string[] args)
    {
        StorageSharedKeyCredential accountCredentials = new StorageSharedKeyCredential(storageAccountName, storageAccountKey);
        BlobServiceClient serviceClient = new     BlobServiceClient(new Uri(blobServiceEndpoint), accountCredentials);
        AccountInfo info = await serviceClient.GetAccountInfoAsync();
        await Console.Out.WriteLineAsync($"Connected to Azure Storage Account");
        await Console.Out.WriteLineAsync($"Account name:\t{storageAccountName}");
        await Console.Out.WriteLineAsync($"Account kind:\t{info?.AccountKind}");
        await Console.Out.WriteLineAsync($"Account sku:\t{info?.SkuName}");
        await EnumerateContainersAsync(serviceClient);
    }        
    private static async Task EnumerateContainersAsync(BlobServiceClient client)
    {        
        await foreach (BlobContainerItem container in client.GetBlobContainersAsync())
        {
            await Console.Out.WriteLineAsync($"Container:\t{container.Name}");
        }
}
}

Save the Program.cs file.
In the Visual Studio Code window, on the Menu Bar, select Terminal and then select New Terminal.
In the terminal, run the following command to run the .NET web application:
```
dotnet run
```
Note: If there are any build errors, review the Program.cs file in the $HOME\training-az204\Labs\03\Solution\BlobManager folder.
Observe the output from the currently running console application. The updated output includes a list of every existing container in the account.
Select Kill Terminal or the Recycle Bin icon to close the currently open terminal and any associated processes.

Review

In this exercise, you accessed existing containers by using the Azure Storage SDK.

LAB 3 - Access containers by using the .NET SDK