Freigeben über

Entwickeln für Azure Files mit .NET

Erfahren Sie, wie Sie .NET-Anwendungen entwickeln, die Azure Files zum Speichern von Daten verwenden. Azure Files ist ein verwalteter Dateifreigabedienst in der Cloud. Sie bietet vollständig verwaltete Dateifreigaben, auf die über die Standardprotokolle Server Message Block (SMB) und Network File System (NFS) zugegriffen werden kann. Azure Files bietet auch eine REST-API für den programmgesteuerten Zugriff auf Dateifreigaben.

In diesem Artikel erfahren Sie mehr über die verschiedenen Ansätze für die Entwicklung mit Azure Files in .NET und wie Sie den Ansatz auswählen, der den Anforderungen Ihrer App am besten entspricht. Außerdem erfahren Sie, wie Sie eine einfache Konsolen-App erstellen, die mit Azure Files-Ressourcen interagiert.

Gilt für:

Verwaltungsmodell Abrechnungsmodell Medienebene Redundanz SMB (KMU) NFS (falls abgekürzt von Network File System gemeint)
Microsoft.Storage Bereitgestellt v2 HDD (Standard) Lokal (LRS) Ja Nein
Microsoft.Storage Bereitgestellt v2 HDD (Standard) Zone (ZRS) Ja Nein
Microsoft.Storage Bereitgestellt v2 HDD (Standard) Geo (GRS) Ja Nein
Microsoft.Storage Bereitgestellt v2 HDD (Standard) GeoZone (GZRS) Ja Nein
Microsoft.Storage Bereitgestellt v1 SSD (Premium) Lokal (LRS) Ja Nein
Microsoft.Storage Bereitgestellt v1 SSD (Premium) Zone (ZRS) Ja Nein
Microsoft.Storage Nutzungsbasierte Bezahlung HDD (Standard) Lokal (LRS) Ja Nein
Microsoft.Storage Nutzungsbasierte Bezahlung HDD (Standard) Zone (ZRS) Ja Nein
Microsoft.Storage Nutzungsbasierte Bezahlung HDD (Standard) Geo (GRS) Ja Nein
Microsoft.Storage Nutzungsbasierte Bezahlung HDD (Standard) GeoZone (GZRS) Ja Nein

Informationen zur .NET-App-Entwicklung mit Azure Files

Azure Files bietet verschiedene Möglichkeiten für .NET-Entwickler, auf Daten zuzugreifen und Ressourcen in Azure Files zu verwalten. Die folgende Tabelle enthält die Ansätze, fasst zusammen, wie sie funktionieren, und enthält Anleitungen zur Verwendung der einzelnen Ansätze:

Ansatz Funktionsweise Wann zu verwenden
Standard-Datei-I/O-Bibliotheken Verwendet API-Aufrufe auf Betriebssystemebene über Azure-Dateifreigaben, die über SMB oder NFS eingebunden wurden. Wenn Sie eine Dateifreigabe mithilfe von SMB/NFS einbinden, können Sie Datei-E/A-Bibliotheken für eine Programmiersprache oder ein Framework verwenden, z. B. System.IO für .NET. Sie verfügen über Branchen-Apps mit vorhandenem Code, der standarddatei-E/A verwendet, und Sie möchten keinen Code für die App neu schreiben, um mit einer Azure-Dateifreigabe zu arbeiten.
FileREST-API Ruft https-Endpunkte direkt auf, um mit daten zu interagieren, die in Azure Files gespeichert sind. Stellt programmgesteuerte Kontrolle über Dateifreigaberessourcen bereit. Das Azure SDK bietet die Clientbibliothek für Dateifreigaben (Azure.Storage.Files.Shares), die auf der FileREST-API basiert, damit Sie mittels der gewohnten .NET-Programmiersprachenparadigmen mit FileREST-API-Vorgängen interagieren können. Sie erstellen Mehrwertdienste und Cloud-Apps für Kunden und möchten erweiterte Funktionen nutzen, die über System.IO nicht verfügbar sind.
REST-API des Speicherressourcenanbieters Verwendet Azure Resource Manager (ARM) zum Verwalten von Speicherkonten und Dateifreigaben. Ruft REST-API-Endpunkte für verschiedene Ressourcenverwaltungsvorgänge auf. Ihre App oder Ihr Dienst muss Ressourcenverwaltungsaufgaben ausführen, z. B. das Erstellen, Löschen oder Aktualisieren von Speicherkonten oder Dateifreigaben.

Allgemeine Informationen zu diesen Ansätzen finden Sie unter Übersicht über die Anwendungsentwicklung mit Azure Files.

Dieser Artikel konzentriert sich auf die Arbeit mit Azure Files-Ressourcen mit den folgenden Ansätzen:

Voraussetzungen

Richten Sie Ihre Umgebung ein

Dieser Abschnitt führt Sie durch die Schritte zum Vorbereiten einer .NET-Konsolen-App für die Arbeit mit Azure Files.

Erstelle das Projekt

Wenn Sie noch nicht über eine .NET-App verfügen, erstellen Sie eine app mit Visual Studio oder der .NET CLI. In diesem Artikel erstellen wir eine Konsolen-App zur Vereinfachung.

  1. Starten Sie Visual Studio, und wählen Sie Neues Projekt erstellen aus. Oder wenn Sie sich in Visual Studio befinden, navigieren Sie zu "Datei>Neues>Projekt".
  2. Wählen Sie im Dialogfeld "Konsolen-App für C#" und dann "Weiter" aus.
  3. Geben Sie einen Namen für das Projekt ein, behalten Sie die Standardwerte bei, und wählen Sie "Weiter" aus.
  4. Wählen Sie für Framework die neueste installierte Version von .NET aus. Behalten Sie die anderen Standardwerte bei, und wählen Sie "Erstellen" aus.

Installiere das Paket

Wenn Sie beabsichtigen, mit Azure Files mit dem System.IO Namespace zu interagieren, müssen Sie keine zusätzlichen Pakete installieren. Der System.IO Namespace ist im .NET SDK enthalten. Wenn Sie die Clientbibliothek für Dateifreigaben für .NET oder die Azure Storage-Verwaltungsbibliothek für .NET verwenden möchten, installieren Sie das Paket mithilfe von NuGet.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt, und wählen Sie NuGet-Pakete verwalten aus.

  2. Wählen Sie in NuGet Package Manager die Option Durchsuchen aus. Suchen Sie dann nach dem entsprechenden Paket, und wählen Sie dann "Installieren" aus. Wählen Sie für die Clientbibliothek für Dateifreigabendie Option Azure.Storage.Files.Shares aus. Wählen Sie für die Azure Storage-Verwaltungsbibliothek Azure.ResourceManager.Storage aus. Wählen Sie für die Azure Identity-Bibliothek, die für kennwortlose Verbindungen erforderlich ist, Azure.Identity aus.

    Mit diesem Schritt werden das Paket und seine Abhängigkeiten installiert.

Hinzufügen von using-Direktiven

Wenn Sie den System.IO Namespace verwenden möchten, fügen Sie oben in der Program.cs-Datei die folgende Using-Direktive hinzu:

using System.IO;

Wenn Sie die Clientbibliothek für Dateifreigaben für .NET verwenden möchten, fügen Sie oben in der Datei Program.cs die folgende using-Direktive hinzu:

using Azure.Storage.Files.Shares;

Wenn Sie beabsichtigen, die Azure Storage-Verwaltungsbibliothek für .NET zu verwenden, fügen Sie oben in der Program.cs-Datei die folgende Direktive hinzu:

using Azure.ResourceManager;

Um die Azure Identity-Bibliothek für kennwortlose Verbindungen mit Azure-Diensten zu verwenden, fügen Sie oben in Ihrer Program.cs-Datei die folgende Direktive hinzu:

using Azure.Identity;

Arbeiten mit Azure Files mithilfe von System.IO

Standarddatei-E/A-Bibliotheken sind die am häufigsten verwendete Methode für den Zugriff und die Arbeit mit Azure Files-Ressourcen. Wenn Sie eine Dateifreigabe mithilfe von SMB oder NFS einbinden, leitet Ihr Betriebssystem API-Anforderungen für das lokale Dateisystem um. Mit diesem Ansatz können Sie Standarddatei-E/A-Bibliotheken wie System.IO verwenden, um mit Dateien und Verzeichnissen in der Freigabe zu interagieren.

Erwägen Sie die Verwendung System.IO , wenn Ihre App Folgendes erfordert:

  • App-Kompatibilität: Ideal für Branchen-Apps mit vorhandenem Code, der bereits verwendet wird System.IO. Sie müssen Code nicht neu schreiben, damit die App mit einer Azure-Dateifreigabe arbeitet.
  • Benutzerfreundlichkeit:System.IO ist von Entwicklern bekannt und einfach zu bedienen. Ein wichtiges Wertversprechen von Azure Files besteht darin, dass sie systemeigene Dateisystem-APIs über SMB und NFS verfügbar macht.

In diesem Abschnitt erfahren Sie, wie Sie System.IO für die Arbeit mit Azure Files-Ressourcen verwenden.

Weitere Informationen und Beispiele finden Sie unter den folgenden Ressourcen:

Einbinden einer Dateifreigabe

Zur Verwendung von System.IO müssen Sie zuerst eine Dateifreigabe einbinden. Informationen zum Einbinden einer Dateifreigabe mithilfe von SMB oder NFS finden Sie in den folgenden Ressourcen:

In diesem Artikel verwenden Sie den folgenden Pfad zum Verweisen auf eine eingebundene SMB-Dateifreigabe unter Windows:

string fileSharePath = @"Z:\file-share";

Beispiel: Herstellen einer Verbindung mit einer Dateifreigabe und Aufzählen von Verzeichnissen mithilfe von System.IO

Das folgende Codebeispiel zeigt, wie Sie eine Verbindung mit einer Dateifreigabe herstellen und die Verzeichnisse in der Freigabe auflisten:

using System.IO;

string fileSharePath = @"Z:\file-share";

EnumerateDirectories(@"Z:\file-share");

static void EnumerateDirectories(string path)
{
    try
    {
        List<string> dirs = new List<string>(Directory.EnumerateDirectories(path));

        foreach (var dir in dirs)
        {
            Console.WriteLine($"{dir.Substring(dir.LastIndexOf(Path.DirectorySeparatorChar) + 1)}");
        }
        Console.WriteLine($"{dirs.Count} directories found.");
    }
    catch (UnauthorizedAccessException ex)
    {
        Console.WriteLine(ex.Message);
    }
    catch (PathTooLongException ex)
    {
        Console.WriteLine(ex.Message);
    }
}

Beispiel: Schreiben in eine Datei in einer Dateifreigabe mithilfe von System.IO

Das folgende Codebeispiel zeigt, wie Text mit der File Klasse geschrieben und angefügt wird:

using System.IO;

string fileSharePath = @"Z:\file-share";

WriteToFile(fileSharePath, "test.txt");

static void WriteToFile(string fileSharePath, string fileName)
{
    string textToWrite = "First line" + Environment.NewLine;
    string filePath = Path.Combine(fileSharePath, fileName);
    
    File.WriteAllText(filePath, textToWrite);

    string[] textToAppend = { "Second line", "Third line" };
    File.AppendAllLines(filePath, textToAppend);
}

Beispiel: Sperren einer Datei in einer Dateifreigabe mithilfe von System.IO

SMB-Clients, die Dateifreigaben einbinden, können Sperrmechanismen des Dateisystems zum Verwalten des Zugriffs auf freigegebene Dateien nutzen.

Das folgende Codebeispiel zeigt, wie Sie eine Datei in einer Dateifreigabe sperren, für die der Freigabemodus auf None festgelegt ist. Dieser Freigabemodus lehnt die Freigabe der aktuellen Datei ab, bis die Datei geschlossen wird.

using System.IO;

string fileSharePath = @"Z:\file-share";

LockFile(Path.Combine(fileSharePath, "test.txt"));

static void LockFile(string filePath)
{
    try
    {
        using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
        {
            Console.WriteLine("File locked.");

            // Do something with file, press Enter to close the stream and release the lock
            Console.ReadLine();

            fs.Close();
            Console.WriteLine("File closed.");
        }
    }
    catch (IOException ex)
    {
        Console.WriteLine(ex.Message);
    }
}

Beachten Sie bei der Verwendung von SMB und der FileREST-API, dass die FileREST-API Leases zum Verwalten von Dateisperren verwendet, während SMB Dateisystemsperren verwendet, die vom Betriebssystem verwaltet werden. Weitere Informationen zum Verwalten von Dateisperrinteraktionen zwischen SMB und der FileREST-API finden Sie unter Verwalten von Dateisperren.

Beispiel: Aufzählen von Datei-ACLs mithilfe von System.IO

Das folgende Codebeispiel zeigt, wie Sie Zugriffssteuerungslisten (ACCESS Control Lists, ACLs) für eine Datei aufzählen:

using System.IO;
using System.Security.AccessControl;

string fileSharePath = @"Z:\file-share";
string fileName = "test.txt";
string filePath = Path.Combine(fileSharePath, fileName);

EnumerateFileACLs(filePath);

static void EnumerateFileACLs(string filePath)
{
    FileInfo fileInfo = new FileInfo(filePath);

    // For directories, use DirectorySecurity instead of FileSecurity
    FileSecurity fSecurity = FileSystemAclExtensions.GetAccessControl(fileInfo);

    // List all access rules for the file
    foreach (FileSystemAccessRule rule in fSecurity.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount)))
    {
        Console.WriteLine($"Identity: {rule.IdentityReference.Value}");
        Console.WriteLine($"Access Control Type: {rule.AccessControlType}");
        Console.WriteLine($"File System Rights: {rule.FileSystemRights}");
        Console.WriteLine();
    }

}

Arbeiten mit Azure Files-Daten unter Verwendung der Clientbibliothek für Dateifreigaben für .NET

Die FileREST-API bietet programmgesteuerten Zugriff auf Azure Files. Sie können HTTPS-Endpunkte aufrufen, um Vorgänge für Dateifreigaben, Verzeichnisse und Dateien auszuführen. Die FileREST-API wurde für hohe Skalierbarkeit und erweiterte Features entwickelt, die möglicherweise nicht über systemeigene Protokolle verfügbar sind. Das Azure SDK stellt Clientbibliotheken bereit, etwa die Clientbibliothek für Dateifreigaben für .NET, die auf der FileREST-API basieren.

Erwägen Sie die Verwendung der FileREST-API und der Dateifreigabe-Clientbibliothek, wenn Ihre Anwendung Folgendes erfordert:

  • Erweiterte Features: Zugriffsvorgänge und Features, die nicht über systemeigene Protokolle verfügbar sind.
  • Benutzerdefinierte Cloudintegrationen: Erstellen Sie benutzerdefinierte Mehrwertdienste wie Sicherung, Antivirensoftware oder Datenverwaltung, die direkt mit Azure Files interagieren.
  • Leistungsoptimierung: Profitieren Sie von Leistungsvorteilen in szenarien mit hoher Skalierung mithilfe von Datenebenenvorgängen.

Die FileREST-API modelliert Azure Files als Eine Hierarchie von Ressourcen und wird für Vorgänge empfohlen, die auf Verzeichnis - oder Dateiebene ausgeführt werden. Sie sollten die REST-API des Speicherressourcenanbieters für Vorgänge bevorzugen, die auf Dateidienst - oder Dateifreigabeebene ausgeführt werden.

In diesem Abschnitt erfahren Sie, wie Sie die Clientbibliothek für Dateifreigaben verwenden, um mit Azure Files-Ressourcen zu arbeiten.

Weitere Informationen und Beispiele finden Sie unter den folgenden Ressourcen:

Autorisieren des Zugriffs und Erstellen eines Clients

Um eine App mit Azure Files zu verbinden, erstellen Sie ein ShareClient Objekt. Dieses Objekt ist Ihr Ausgangspunkt für die Arbeit mit Azure Files-Ressourcen. Die folgenden Codebeispiele zeigen, wie ein ShareClient Objekt mithilfe verschiedener Autorisierungsmechanismen erstellt wird.

Um mit Microsoft Entra ID zu autorisieren, müssen Sie einen Security Principal verwenden. Der Typ des für Sie erforderlichen Sicherheitsprinzipals ist abhängig davon, wo Ihre App ausgeführt wird. Verwenden Sie diese Tabelle als Richtlinie.

Ausführungsort der App Sicherheitsprinzipal Beratung
Lokaler Computer (Entwickeln und Testen) Service Principal Informationen zum Registrieren der App, zum Einrichten einer Microsoft Entra-Gruppe, zum Zuweisen von Rollen und zum Konfigurieren von Umgebungsvariablen finden Sie unter Zugriff über Entwicklerdienstprinzipien autorisieren
Lokaler Computer (Entwickeln und Testen) Benutzeridentität Informationen zum Einrichten einer Microsoft Entra-Gruppe, zum Zuweisen von Rollen und zum Anmelden bei Azure finden Sie unter Zugriff mit Entwickleranmeldeinformationen autorisieren
In Azure gehostet Verwaltete Identität Informationen zum Aktivieren einer verwalteten Identität und zum Zuweisen von Rollen finden Sie unter Authenticating Azure-hosted apps to Azure resources with the Azure SDK for Python (Authentifizieren von Azure-gehosteten Apps bei Azure-Ressourcen mit dem Azure SDK für Python).
Außerhalb von Azure gehostet (z. B. lokale Apps) Service Principal Informationen zum Registrieren der App, zum Zuweisen von Rollen und zum Konfigurieren von Umgebungsvariablen finden Sie unter Authentifizieren bei Azure-Ressourcen von lokal gehosteten .NET-Apps

Damit Sie die Codebeispiele in diesem Artikel verwenden können, weisen Sie dem Sicherheitsprinzipal die integrierte Azure RBAC-Rolle Privilegierter Mitwirkender für Speicherdateidaten zu. Diese Rolle gewährt vollständigen Zugriff zum Lesen, Schreiben, Ändern von ACLs und Löschen für alle Daten in den Freigaben für alle konfigurierten Speicherkonten, unabhängig von den festgelegten NTFS-Berechtigungen auf Datei-/Verzeichnisebene. Weitere Informationen finden Sie unter Zugreifen auf Azure-Dateifreigaben mithilfe von Microsoft Entra ID mit Azure Files OAuth über REST.

Autorisieren des Zugriffs mithilfe von DefaultAzureCredential

Eine einfache und sichere Möglichkeit zum Autorisieren des Zugriffs und der Verbindung mit Azure Files ist das Abrufen eines OAuth-Tokens durch Erstellen einer DefaultAzureCredential-Instanz . Anschließend können Sie mithilfe dieser Anmeldeinformationen ein ShareClient-Objekt erstellen.

Im folgenden Beispiel wird ein mithilfe von ShareClient autorisiertes DefaultAzureCredential-Objekt erstellt. Anschließend wird ein ShareDirectoryClient-Objekt erstellt, das mit einem Verzeichnis in der Freigabe verwendet werden kann:

using Azure.Identity;
using Azure.Storage.Files.Shares;
using Azure.Storage.Files.Shares.Models;

// ...

string accountName = "<account-name>";
string shareName = "<share-name>";

ShareClientOptions options = new()
{
    AllowSourceTrailingDot = true,
    AllowTrailingDot = true,
    ShareTokenIntent = ShareTokenIntent.Backup,
};
ShareClient shareClient = new(
   new Uri($"https://{accountName}.file.core.windows.net/{shareName}"),
   new DefaultAzureCredential(),
   options);

ShareDirectoryClient directoryClient = shareClient.GetDirectoryClient("sample-directory");

Wenn Sie genau wissen, welchen Anmeldeinformationstyp Sie zum Authentifizieren von Benutzern verwenden werden, können Sie mithilfe anderer Klassen in der Azure Identity-Clientbibliothek für .NET ein OAuth-Token abrufen. Diese Klassen werden von der Klasse TokenCredential abgeleitet.

Weitere Informationen zu den einzelnen Autorisierungsmechanismen finden Sie unter Auswählen, wie der Zugriff auf Dateidaten autorisiert werden soll.

Beispiel: Kopieren von Dateien mit der Clientbibliothek für File Shares

Sie können Dateien innerhalb einer Dateifreigabe oder zwischen Dateifreigaben kopieren, indem Sie die folgende Methode verwenden:

Sie können eine Datei in ein Ziel-BLOB kopieren, indem Sie die folgende Methode aus einem BlobClient Objekt verwenden:

Das folgende Codebeispiel zeigt, wie eine Datei in eine Datei in einer anderen Dateifreigabe kopiert wird:

using Azure.Core;
using Azure.Identity;
using Azure.Storage.Files.Shares;
using Azure.Storage.Files.Shares.Models;

string accountName = "<account-name>";
string srcShareName = "src-file-share";
string destShareName = "dest-file-share";
string srcFilePath = "src/path/to/file";
string destFilePath = "dest/path/to/file";

TokenCredential tokenCredential = new DefaultAzureCredential();

ShareClientOptions options = new()
{
    ShareTokenIntent = ShareTokenIntent.Backup,
};

ShareFileClient srcShareFileClient = new(
    new Uri($"https://{accountName}.file.core.windows.net/{srcShareName}/{srcFilePath}"),
    tokenCredential,
    options);

ShareFileClient destShareFileClient = new(
    new Uri($"https://{accountName}.file.core.windows.net/{destShareName}/{destFilePath}"),
    tokenCredential,
    options);

// Copy the file from the source share to the destination share

await destShareFileClient.StartCopyAsync(srcShareFileClient.Uri);

Beispiel: Leasen einer Datei mithilfe der Clientbibliothek für Dateifreigaben

Ein Leasing erstellt eine Sperre für eine Datei, die von Azure über eine Lease-ID verwaltet wird. Die Lease bietet einen Mechanismus zum Koordinieren des Zugriffs auf Dateien über mehrere Clients in einem verteilten System. Eine Lease für eine Datei bietet exklusiven Schreib- und Löschzugriff. Weitere Informationen zu Leasezuständen und -aktionen finden Sie unter Lease File.

Das folgende Codebeispiel zeigt, wie Sie einen Leaseclient erstellen, eine unendliche Dauer-Lease für eine Datei erwerben und die Lease freigeben:

using Azure.Core;
using Azure.Identity;
using Azure.Storage.Files.Shares;
using Azure.Storage.Files.Shares.Models;
using Azure.Storage.Files.Shares.Specialized;

string accountName = "<account-name>";
string shareName = "sample-file-share";
string filePath = "path/to/file";

TokenCredential tokenCredential = new DefaultAzureCredential();

ShareClientOptions options = new()
{
    ShareTokenIntent = ShareTokenIntent.Backup,
};

ShareFileClient fileClient = new(
    new Uri($"https://{accountName}.file.core.windows.net/{shareName}/{filePath}"),
    tokenCredential,
    options);

ShareLeaseClient leaseClient = fileClient.GetShareLeaseClient();

// Acquire a lease on the source file
await leaseClient.AcquireAsync(duration: ShareLeaseClient.InfiniteLeaseDuration);

// Do something with the file

// Release the lease
await leaseClient.ReleaseAsync();

Beachten Sie bei der Verwendung von SMB und der FileREST-API, dass die FileREST-API Leases zum Verwalten von Dateisperren verwendet, während SMB Dateisystemsperren verwendet, die vom Betriebssystem verwaltet werden. Weitere Informationen zum Verwalten von Dateisperrinteraktionen zwischen SMB und der FileREST-API finden Sie unter Verwalten von Dateisperren.

Beispiel: Erstellen und Auflisten von Freigabemomentaufnahmen mithilfe der Clientbibliothek für Dateifreigaben

Freigabemomentaufnahmen sind schreibgeschützte Kopien einer Dateifreigabe zu einem bestimmten Zeitpunkt. Sie können eine Momentaufnahme einer Dateifreigabe erstellen und anschließend diese Momentaufnahme verwenden, um auf die Daten in der Freigabe zum Zeitpunkt der Momentaufnahmeerstellung zuzugreifen. Sie können auch alle Momentaufnahmen in einer Dateifreigabe auflisten und Freigabemomentaufnahmen löschen.

Das folgende Codebeispiel zeigt, wie Sie eine Freigabemomentaufnahme erstellen, die Momentaufnahmen in einer Dateifreigabe auflisten und die Verzeichnisstruktur in einer Freigabemomentaufnahme durchlaufen:

using Azure.Storage.Files.Shares;
using Azure.Storage.Files.Shares.Models;

string connectionString = "<connection-string>";

ShareServiceClient shareServiceClient = new ShareServiceClient(connectionString);
ShareClient shareClient = shareServiceClient.GetShareClient("sample-file-share");

// Create a snapshot

ShareSnapshotInfo snapshotInfo = await shareClient.CreateSnapshotAsync();
Console.WriteLine($"Snapshot created: {snapshotInfo.Snapshot}");

// List snapshots in a share

await foreach (ShareItem shareItem in shareServiceClient.GetSharesAsync(ShareTraits.All, ShareStates.Snapshots))
{
    if (shareItem.Snapshot != null)
    {
        Console.WriteLine($"Share: {shareItem.Name} (Snapshot: {shareItem.Snapshot})");
    }
}

// List directories and files in a share snapshot

string snapshotTimestamp = snapshotInfo.Snapshot.ToString();
ShareClient shareSnapshot = shareClient.WithSnapshot(snapshotTimestamp);
ShareDirectoryClient rootDir = shareSnapshot.GetRootDirectoryClient();

await ListDirectoryTreeAsync(rootDir);

static async Task ListDirectoryTreeAsync(ShareDirectoryClient directory)
{
    await foreach (ShareFileItem fileItem in directory.GetFilesAndDirectoriesAsync())
    {
        if (fileItem.IsDirectory)
        {
            Console.WriteLine($"Directory: {fileItem.Name}");
            await ListDirectoryTreeAsync(directory.GetSubdirectoryClient(fileItem.Name));
        }
        else
        {
            Console.WriteLine($"File: {fileItem.Name}");
        }
    }
}

Hinweis

OAuth-Token, etwa solche, die bei der Verwendung DefaultAzureCredential abgerufen werden, sind für Datenebenenvorgänge auf Dateifreigabeebene nicht zulässig. Für die Verwendung von Freigabemomentaufnahmen muss das Clientobjekt mithilfe des Kontoschlüssels autorisiert werden. Das ShareClient in diesem Codebeispiel erstellte Objekt verwendet eine Verbindungszeichenfolge, die den Kontoschlüssel enthält.

Das Speichern von Kontoschlüsseln oder Verbindungszeichenfolgen stellt ein Sicherheitsrisiko dar. Sie sollten diese nur verwenden, wenn die Microsoft Entra-Authentifizierung nicht verfügbar ist. Weitere Informationen zum sicheren Speichern von Kontoschlüsseln in Azure Key Vault finden Sie unter Azure Key Vault verwaltete Speicherkontoschlüssel.

Verwalten von Azure Files-Ressourcen mithilfe der Azure Storage-Verwaltungsbibliotheken

Die Azure Storage-Verwaltungsbibliotheken basieren auf der REST-API des Azure Storage-Ressourcenanbieters. Der Azure Storage-Ressourcenanbieter ist ein Dienst, der auf Azure Resource Manager basiert, und unterstützt sowohl deklarative Methoden (Vorlagen) als auch imperative Methoden (direkter API-Aufruf). Die REST-API des Azure Storage-Ressourcenanbieters bietet programmgesteuerten Zugriff auf Azure Storage-Ressourcen, einschließlich Dateifreigaben. Das Azure SDK stellt Verwaltungsbibliotheken bereit, die auf der REST-API des Azure Storage-Ressourcenanbieters aufbauen.

Die Verwaltungsbibliotheken werden für Vorgänge empfohlen, die auf Dateidienst - oder Dateifreigabeebene ausgeführt werden. In diesem Abschnitt erfahren Sie, wie Sie die Azure Storage-Verwaltungsbibliotheken zum Verwalten von Azure Files-Ressourcen verwenden.

Beispiel: Erstellen einer Dateifreigabe mithilfe der Azure Storage-Verwaltungsbibliothek

Das folgende Codebeispiel zeigt, wie Sie ein Objekt auf oberster Ebene ArmClient erstellen, den Speicherressourcenanbieter mit einem Abonnement registrieren und eine Dateifreigabe mithilfe der Azure Storage-Verwaltungsbibliothek erstellen:

using Azure;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Storage;

ArmClient armClient = new ArmClient(new DefaultAzureCredential());

// Create a resource identifier, then get the subscription resource
ResourceIdentifier resourceIdentifier = new($"/subscriptions/<subscription-id>");
SubscriptionResource subscription = armClient.GetSubscriptionResource(resourceIdentifier);

ResourceProviderResource resourceProvider =
    await subscription.GetResourceProviderAsync("Microsoft.Storage");

// Check the registration state of the resource provider and register, if needed
if (resourceProvider.Data.RegistrationState == "NotRegistered")
    resourceProvider.Register();

// Get a resource group
ResourceGroupResource resourceGroup = await subscription.GetResourceGroupAsync("<resource-group-name>");

// Get a collection of storage account resources
StorageAccountCollection accountCollection = resourceGroup.GetStorageAccounts();

// Get a specific storage account resource
StorageAccountResource storageAccount = await accountCollection.GetAsync("<storage-account-name>");

// Get a file service resource for the storage account
FileServiceResource fileService = storageAccount.GetFileService();

// Create a new file share (or update if it already exists)
ArmOperation <FileShareResource> fileShareOperation = await fileService
    .GetFileShares()
    .CreateOrUpdateAsync(WaitUntil.Completed, "sample-file-share", new FileShareData()
    {
        ShareQuota = 1024,
        // Add file share properties here
    });

// Get the file share resource
FileShareResource fileShare = fileShareOperation.Value;

Sie können die Dateifreigabeeigenschaften mithilfe der FileShareData-Klasse konfigurieren. Das vorherige Beispiel zeigt, wie die ShareQuota Eigenschaft festgelegt wird.

Hinweis

Zum Ausführen des Registrierungsvorgangs benötigen Sie Berechtigungen für die folgende Azure RBAC-Aktion: Microsoft.Storage/register/action. Diese Berechtigung ist in den integrierten Rollen "Mitwirkender" und "Besitzer" enthalten.

Beispiel: Auflisten von Dateifreigaben und Momentaufnahmen mithilfe der Azure Storage-Verwaltungsbibliothek

Das folgende Codebeispiel zeigt, wie Dateifreigaben und Momentaufnahmen in einem Speicherkonto aufgeführt werden:

// Iterate over a collection of file shares and list them along with any snapshots
string expand = "snapshots";
await foreach (FileShareResource shareResource in fileService.GetFileShares().GetAllAsync(expand: expand))
{
    // Call operations on the file share resource

    // For this demo, print out the resource name and snapshot information
    FileShareData resourceData = shareResource.Data;
    Console.WriteLine($"Resource name: {resourceData.Name}");
    if (resourceData.SnapshotOn.HasValue)
    {
        Console.WriteLine($"Snapshot: {resourceData.SnapshotOn}");
    }
}

Verwandte Inhalte

Weitere Informationen zur Entwicklung mit Azure Files finden Sie in den folgenden Ressourcen: