Azure Storage with .NET

Getting Started with Azure Storage

Azure Storage offers a highly scalable, available, and secure cloud storage solution for a wide range of data needs. For .NET developers, the Azure SDK for .NET provides comprehensive libraries to interact with these services.

To begin, you'll need to install the relevant NuGet packages:

Install-Package Azure.Storage.Blobs
Install-Package Azure.Storage.Queues
Install-Package Azure.Data.Tables
Install-Package Azure.Storage.Files.Shares
            

You can authenticate to Azure Storage using connection strings or Azure Active Directory credentials. For development and testing, the Azure Storage Emulator or Azurite is a great option.

Azure Blob Storage

Blob Storage is ideal for storing large amounts of unstructured data, such as text or binary data. Common use cases include serving images or documents directly to a browser, storing files for distributed access, streaming video and audio, writing to log files, and storing data for backup and restore, disaster recovery, and archiving.

Basic Operations with Blobs

Here's a simple example of uploading a file to Blob Storage using .NET:

using Azure.Storage.Blobs;
using System;
using System.IO;
using System.Text;

// Replace with your actual connection string
string connectionString = "YOUR_AZURE_STORAGE_CONNECTION_STRING";
string containerName = "my-container";
string blobName = "my-blob.txt";
string filePath = "local-file.txt";

// Create a dummy local file for the example
File.WriteAllText(filePath, "This is the content of the file.");

try
{
    // Create a BlobServiceClient object
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);

    // Get a reference to a container
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    // If the container doesn't exist, create it
    containerClient.CreateIfNotExists();

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

    // Upload the file
    using (FileStream uploadFileStream = File.OpenRead(filePath))
    {
        var response = blobClient.UploadAsync(uploadFileStream, true); // Overwrite if it exists
        Console.WriteLine($"File '{blobName}' uploaded successfully.");
    }
}
catch (Exception ex)
{
    Console.WriteLine($"Error uploading file: {ex.Message}");
}
finally
{
    // Clean up the dummy file
    if (File.Exists(filePath))
    {
        File.Delete(filePath);
    }
}
            

For more advanced operations like downloading, deleting, and managing blob properties, refer to the official Azure Blob Storage documentation.

Azure Queue Storage

Queue Storage is used for storing large numbers of messages that can be processed asynchronously. It's great for decoupling application components.

Sending and Receiving Messages

using Azure.Storage.Queues;
using System;
using System.Threading.Tasks;

// Replace with your actual connection string
string connectionString = "YOUR_AZURE_STORAGE_CONNECTION_STRING";
string queueName = "my-queue";

try
{
    // Create a QueueServiceClient object
    QueueServiceClient queueServiceClient = new QueueServiceClient(connectionString);

    // Get a reference to a queue
    QueueClient queueClient = queueServiceClient.GetQueueClient(queueName);
    // If the queue doesn't exist, create it
    queueClient.CreateIfNotExists();

    // Send a message
    string messageContent = "Process this data.";
    await queueClient.SendMessageAsync(messageContent);
    Console.WriteLine($"Message '{messageContent}' sent to queue '{queueName}'.");

    // Receive a message (and delete it after processing)
    var response = await queueClient.ReceiveMessageAsync();
    var message = response.Value;

    if (message != null)
    {
        Console.WriteLine($"Received message: {message.MessageText}");
        await queueClient.DeleteMessageAsync(message.MessageId, message.PopReceipt);
        Console.WriteLine($"Message deleted from queue '{queueName}'.");
    }
}
catch (Exception ex)
{
    Console.WriteLine($"Error interacting with queue: {ex.Message}");
}
            

Explore Azure Queue Storage concepts for more details.

Azure Table Storage

Table Storage is a NoSQL key-attribute store that accepts authenticated calls on the .NET framework. You can store a large amount of data, and access them from anywhere in the world. Each table consists of entities, and each entity consists of properties.

Working with Entities

With the Azure.Data.Tables SDK, you can perform CRUD operations on your table data.

using Azure;
using Azure.Data.Tables;
using System;

// Replace with your actual connection string
string connectionString = "YOUR_AZURE_STORAGE_CONNECTION_STRING";
string tableName = "my-entities";

// Define a simple entity
public class Product : ITableEntity
{
    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public DateTimeOffset? Timestamp { get; set; }
    public ETag ETag { get; set; }

    public string Name { get; set; }
    public int Quantity { get; set; }
}

try
{
    // Create a TableServiceClient
    TableServiceClient tableServiceClient = new TableServiceClient(connectionString);

    // Get a reference to a table
    TableClient tableClient = tableServiceClient.GetTableClient(tableName);
    // Create the table if it doesn't exist
    tableClient.CreateIfNotExists();

    // Create a new entity
    Product product1 = new Product
    {
        PartitionKey = "Electronics",
        RowKey = "101",
        Name = "Laptop",
        Quantity = 5
    };

    // Add entity
    await tableClient.UpsertEntityAsync(product1);
    Console.WriteLine("Entity added successfully.");

    // Get entity
    Response<Product> retrievedProduct = await tableClient.GetEntityAsync<Product>>("Electronics", "101");
    Console.WriteLine($"Retrieved Product: {retrievedProduct.Value.Name}, Quantity: {retrievedProduct.Value.Quantity}");
}
catch (Exception ex)
{
    Console.WriteLine($"Error interacting with table: {ex.Message}");
}
            

Learn more about Azure Table Storage.

Azure File Storage

File Storage offers fully managed file shares in the cloud that are accessible via the industry-standard Server Message Block (SMB) protocol. You can mount File Storage shares simultaneously by on-premises or cloud applications.

Using File Shares

The .NET SDK for Azure Files enables you to programmatically interact with your file shares, including creating and deleting shares, uploading, downloading, and managing files.

See the Azure File Storage documentation for detailed examples and guidance.