Entwickeln für Azure Files mit .NET

Lernen Sie die Grundlagen der Entwicklung von .NET-Anwendungen kennen, die Azure Files zum Speichern von Daten verwenden. Dieser Artikel zeigt, wie Sie eine einfache Konsolenanwendung erstellen, um Folgendes mit .NET und Azure Files durchzuführen:

  • Abrufen der Inhalte einer Datei
  • Festlegen der maximalen Größe (des Kontingents) für eine Dateifreigabe
  • Erstellen einer SAS (Shared Access Signature) für eine Datei
  • Kopieren einer Datei in eine andere Datei im gleichen Speicherkonto
  • Kopieren einer Datei in ein Blob im gleichen Speicherkonto
  • Erstellen einer Momentaufnahme einer Dateifreigabe
  • Wiederherstellen aus der Momentaufnahme einer Freigabe
  • Verwenden von Azure-Speichermetriken für die Problembehandlung

Weitere Informationen zu Azure Files finden Sie unter Was ist Azure Files?.

Tipp

Repository mit Azure Storage-Codebeispielen

In unserer Liste mit Azure Storage-Beispielen finden Sie benutzerfreundliche, umfassende Azure Storage-Codebeispiele, die Sie herunterladen und ausführen können.

Gilt für:

Dateifreigabetyp SMB NFS
Standard-Dateifreigaben (GPv2), LRS/ZRS Yes No
Standard-Dateifreigaben (GPv2), GRS/GZRS Yes No
Premium-Dateifreigaben (FileStorage), LRS/ZRS Yes No

Grundlegendes zu den .NET-APIs

Azure Files bietet zwei allgemeine Ansätze für Clientansätze: Server Message Block (SMB) und REST. Innerhalb von .NET werden diese Ansätze durch die APIs System.IO und Azure.Storage.Files.Shares abstrahiert.

API Verwendung Notizen
System.IO Ihre Anwendung:
  • Muss Dateien mithilfe von SMB lesen/schreiben
  • Wird auf einem Gerät ausgeführt, das über Port 445 Zugriff auf Ihr Azure Files-Konto hat
  • Muss keine Verwaltungseinstellungen der Dateifreigabe verwalten
Datei-E/A-Vorgänge, die mit Azure Files über SMB implementiert wurden, entsprechen normalerweise E/A-Vorgängen bei einer beliebigen Netzwerkdateifreigabe oder einem beliebigen lokalen Speichergerät. Eine Einführung in mehrere Features in .NET, einschließlich Datei-E/A-Vorgängen, finden Sie im Tutorial zur Konsolenanwendung.
Azure.Storage.Files.Shares Ihre Anwendung:
  • Kann aufgrund von Firewall- oder ISP-Einschränkungen nicht mithilfe von SMB an Port 445 auf Azure Files zugreifen
  • Benötigt Verwaltungsfunktionen, etwa die Möglichkeit, das Kontingent einer Dateifreigabe festzulegen oder eine SAS (Shared Access Signature) zu erstellen
Dieser Artikel veranschaulicht die Verwendung von Azure.Storage.Files.Shares für Datei-E/A-Vorgänge mithilfe von REST statt SMB sowie die Verwaltung der Dateifreigabe.

Erstellen der Konsolenanwendung und Erhalten der Assembly

Sie können die Azure Files-Clientbibliothek in jeder Art von .NET-App verwenden. Dies umfasst Azure-Cloud-Apps, Web-Apps, Desktop-Apps und mobile Apps. In diesem Leitfaden erstellen wir der Einfachheit halber eine Konsolenanwendung.

Erstellen Sie in Visual Studio eine neue Windows-Konsolenanwendung. In den folgenden Schritten wird veranschaulicht, wie Sie eine Konsolenanwendung in Visual Studio 2019 erstellen. Die Schritte sind in anderen Versionen von Visual Studio ähnlich.

  1. Starten Sie Visual Studio, und wählen Sie Neues Projekt erstellen aus.
  2. Wählen Sie unter Neues Projekt erstellen die Option Konsolen-App (.NET Framework) für C# und dann Weiter aus.
  3. Geben Sie unter Neues Projekt konfigurieren einen Namen für die App ein, und wählen Sie Erstellen aus.

Fügen Sie alle Codebeispiele in diesem Artikel der Klasse Program in der Datei Program.cs hinzu.

Verwenden von NuGet zum Installieren der erforderlichen Pakete

Verweisen Sie in Ihrem Projekt auf die folgenden Pakete:

Sie können die Pakete über NuGet abrufen. Folgen Sie diesen Schritten:

  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 nach Azure.Core, und wählen Sie das Paket aus. Klicken Sie dann auf Installieren.

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

  3. Suchen und installieren Sie diese Pakete:

    • Azure.Storage.Blobs
    • Azure.Storage.Files.Shares
    • System.Configuration.ConfigurationManager

Speichern der Anmeldeinformationen für Ihr Speicherkonto in der Datei „App.config“

Als Nächstes speichern Sie Ihre Anmeldeinformationen in der Datei App.config des Projekts. Doppelklicken Sie im Projektmappen-Explorer auf App.config, und bearbeiten Sie die Datei so, dass sie dem folgenden Beispiel ähnelt.

Ersetzen Sie myaccount durch den Namen Ihres Speicherkontos und mykey durch Ihren Speicherkontoschlüssel.

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <appSettings>
    <add key="StorageConnectionString" 
      value="DefaultEndpointsProtocol=https;AccountName=myaccount;AccountKey=mykey;EndpointSuffix=core.windows.net" />
    <add key="StorageAccountName" value="myaccount" />
    <add key="StorageAccountKey" value="mykey" />
  </appSettings>
</configuration>

Hinweis

Der Azure-Speicheremulator unterstützt Azure Files derzeit nicht. Die Verbindungszeichenfolge muss auf ein Azure-Speicherkonto in der Cloud verweisen, damit die Verwendung von Azure Files funktioniert.

Hinzufügen von using-Direktiven

Öffnen Sie im Projektmappen-Explorer die Datei Program.cs, und fügen Sie am Anfang der Datei mithilfe von using-Anweisungen Folgendes hinzu.

using System;
using System.Configuration;
using System.IO;
using System.Threading.Tasks;
using Azure;
using Azure.Storage;
using Azure.Storage.Blobs;
using Azure.Storage.Files.Shares;
using Azure.Storage.Files.Shares.Models;
using Azure.Storage.Sas;

Programmgesteuertes Zugreifen auf die Dateifreigabe

Fügen Sie in der Datei Program.cs folgenden Code hinzu, um programmgesteuert auf die Dateifreigabe zuzugreifen.

Die folgende Methode erstellt eine Dateifreigabe, falls noch keine vorhanden ist. Zuerst erstellt die Methode ein ShareClient-Objekt aus einer Verbindungszeichenfolge. Das Beispiel versucht dann, eine Datei herunterzuladen, die wir zu einem früheren Zeitpunkt erstellt haben. Rufen Sie diese Methode aus Main() auf.

//-------------------------------------------------
// Create a file share
//-------------------------------------------------
public async Task CreateShareAsync(string shareName)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instantiate a ShareClient which will be used to create and manipulate the file share
    ShareClient share = new ShareClient(connectionString, shareName);

    // Create the share if it doesn't already exist
    await share.CreateIfNotExistsAsync();

    // Ensure that the share exists
    if (await share.ExistsAsync())
    {
        Console.WriteLine($"Share created: {share.Name}");

        // Get a reference to the sample directory
        ShareDirectoryClient directory = share.GetDirectoryClient("CustomLogs");

        // Create the directory if it doesn't already exist
        await directory.CreateIfNotExistsAsync();

        // Ensure that the directory exists
        if (await directory.ExistsAsync())
        {
            // Get a reference to a file object
            ShareFileClient file = directory.GetFileClient("Log1.txt");

            // Ensure that the file exists
            if (await file.ExistsAsync())
            {
                Console.WriteLine($"File exists: {file.Name}");

                // Download the file
                ShareFileDownloadInfo download = await file.DownloadAsync();

                // Save the data to a local file, overwrite if the file already exists
                using (FileStream stream = File.OpenWrite(@"downloadedLog1.txt"))
                {
                    await download.Content.CopyToAsync(stream);
                    await stream.FlushAsync();
                    stream.Close();

                    // Display where the file was saved
                    Console.WriteLine($"File downloaded: {stream.Name}");
                }
            }
        }
    }
    else
    {
        Console.WriteLine($"CreateShareAsync failed");
    }
}

Festlegen der maximalen Größe für eine Dateifreigabe

Ab Version 5.x der Azure Files-Clientbibliothek können Sie das Kontingent (die maximale Größe) für eine Dateifreigabe festlegen. Sie können auch überprüfen, wie viele Daten sich aktuell auf der Freigabe befinden.

Eine Festlegung des Kontingents für eine Freigabe begrenzt die Gesamtgröße der Dateien, die in der Freigabe gespeichert werden. Wenn die Gesamtgröße der Dateien in der Freigabe das Kontingent überschreitet, können Clients die Größe vorhandener Dateien nicht erhöhen. Clients können auch keine neuen Dateien erstellen, außer wenn diese Dateien leer sind.

Das folgende Beispiel zeigt, wie Sie die aktuelle Nutzung einer Freigabe überprüfen und das Kontingent für die Freigabe festlegen.

//-------------------------------------------------
// Set the maximum size of a share
//-------------------------------------------------
public async Task SetMaxShareSizeAsync(string shareName, int increaseSizeInGiB)
{
    const long ONE_GIBIBYTE = 10737420000; // Number of bytes in 1 gibibyte

    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instantiate a ShareClient which will be used to access the file share
    ShareClient share = new ShareClient(connectionString, shareName);

    // Create the share if it doesn't already exist
    await share.CreateIfNotExistsAsync();

    // Ensure that the share exists
    if (await share.ExistsAsync())
    {
        // Get and display current share quota
        ShareProperties properties = await share.GetPropertiesAsync();
        Console.WriteLine($"Current share quota: {properties.QuotaInGB} GiB");

        // Get and display current usage stats for the share
        ShareStatistics stats = await share.GetStatisticsAsync();
        Console.WriteLine($"Current share usage: {stats.ShareUsageInBytes} bytes");

        // Convert current usage from bytes into GiB
        int currentGiB = (int)(stats.ShareUsageInBytes / ONE_GIBIBYTE);

        // This line sets the quota to be the current 
        // usage of the share plus the increase amount
        await share.SetQuotaAsync(currentGiB + increaseSizeInGiB);

        // Get the new quota and display it
        properties = await share.GetPropertiesAsync();
        Console.WriteLine($"New share quota: {properties.QuotaInGB} GiB");
    }
}

Generieren einer SAS für eine Datei oder Dateifreigabe

Ab Version 5.x der Azure Files-Clientbibliothek können Sie eine SAS (Shared Access Signature) für eine Dateifreigabe oder für eine einzelne Datei generieren.

Die folgende Beispielmethode gibt eine SAS in einer Datei in der angegebenen Freigabe zurück.

//-------------------------------------------------
// Create a SAS URI for a file
//-------------------------------------------------
public Uri GetFileSasUri(string shareName, string filePath, DateTime expiration, ShareFileSasPermissions permissions)
{
    // Get the account details from app settings
    string accountName = ConfigurationManager.AppSettings["StorageAccountName"];
    string accountKey = ConfigurationManager.AppSettings["StorageAccountKey"];

    ShareSasBuilder fileSAS = new ShareSasBuilder()
    {
        ShareName = shareName,
        FilePath = filePath,

        // Specify an Azure file resource
        Resource = "f",

        // Expires in 24 hours
        ExpiresOn = expiration
    };

    // Set the permissions for the SAS
    fileSAS.SetPermissions(permissions);

    // Create a SharedKeyCredential that we can use to sign the SAS token
    StorageSharedKeyCredential credential = new StorageSharedKeyCredential(accountName, accountKey);

    // Build a SAS URI
    UriBuilder fileSasUri = new UriBuilder($"https://{accountName}.file.core.windows.net/{fileSAS.ShareName}/{fileSAS.FilePath}");
    fileSasUri.Query = fileSAS.ToSasQueryParameters(credential).ToString();

    // Return the URI
    return fileSasUri.Uri;
}

Weitere Informationen zum Erstellen und Verwenden von Shared Access Signatures finden Sie unter Funktionsweise von Shared Access Signatures.

Kopieren von Dateien

Ab Version 5.x der Azure Files-Clientbibliothek können Sie eine Datei in eine andere Datei, eine Datei in ein Blob oder ein Blob in eine Datei kopieren.

Sie können auch AzCopy verwenden, um eine Datei in eine andere oder ein Blob in eine Datei (oder umgekehrt) zu kopieren. Informationen finden Sie unter Übertragen von Daten mit AzCopy v10.

Hinweis

Wenn Sie ein BLOB in eine Datei oder eine Datei in ein BLOB kopieren, müssen Sie eine SAS verwenden, um den Zugriff auf das Quellobjekt zu autorisieren. Dies gilt selbst dann, wenn Sie innerhalb desselben Speicherkontos kopieren.

Kopieren einer Datei in eine andere Datei

Im folgenden Beispiel wird eine Datei in eine andere Datei in derselben Freigabe kopiert. Für den Kopiervorgang können Sie die Authentifizierung mit gemeinsam verwendetem Schlüssel verwenden, weil dieser Vorgang Dateien innerhalb ein und desselben Speicherkontos kopiert.

//-------------------------------------------------
// Copy file within a directory
//-------------------------------------------------
public async Task CopyFileAsync(string shareName, string sourceFilePath, string destFilePath)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Get a reference to the file we created previously
    ShareFileClient sourceFile = new ShareFileClient(connectionString, shareName, sourceFilePath);

    // Ensure that the source file exists
    if (await sourceFile.ExistsAsync())
    {
        // Get a reference to the destination file
        ShareFileClient destFile = new ShareFileClient(connectionString, shareName, destFilePath);

        // Start the copy operation
        await destFile.StartCopyAsync(sourceFile.Uri);

        if (await destFile.ExistsAsync())
        {
            Console.WriteLine($"{sourceFile.Uri} copied to {destFile.Uri}");
        }
    }
}

Kopieren einer Datei in ein Blob

Im folgenden Beispiel wird eine Datei erstellt und in ein Blob im selben Speicherkonto kopiert. In dem Beispiel wird für die Quelldatei eine SAS erstellt, die der Dienst dazu verwendet, während des Kopiervorgangs den Zugriff auf die Quelldatei zu autorisieren.

//-------------------------------------------------
// Copy a file from a share to a blob
//-------------------------------------------------
public async Task CopyFileToBlobAsync(string shareName, string sourceFilePath, string containerName, string blobName)
{
    // Get a file SAS from the method created ealier
    Uri fileSasUri = GetFileSasUri(shareName, sourceFilePath, DateTime.UtcNow.AddHours(24), ShareFileSasPermissions.Read);

    // Get a reference to the file we created previously
    ShareFileClient sourceFile = new ShareFileClient(fileSasUri);

    // Ensure that the source file exists
    if (await sourceFile.ExistsAsync())
    {
        // Get the connection string from app settings
        string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

        // Get a reference to the destination container
        BlobContainerClient container = new BlobContainerClient(connectionString, containerName);

        // Create the container if it doesn't already exist
        await container.CreateIfNotExistsAsync();

        BlobClient destBlob = container.GetBlobClient(blobName);

        await destBlob.StartCopyFromUriAsync(sourceFile.Uri);

        if (await destBlob.ExistsAsync())
        {
            Console.WriteLine($"File {sourceFile.Name} copied to blob {destBlob.Name}");
        }
    }
}

Auf gleiche Weise können Sie ein BLOB in eine Datei kopieren. Wenn das Quellobjekt ein BLOB ist, erstellen Sie eine SAS, um den Zugriff auf dieses BLOB während des Kopiervorgangs zu autorisieren.

Freigabemomentaufnahmen

Ab Version 8.5 der Azure Files-Clientbibliothek können Sie eine Freigabemomentaufnahme erstellen. Außerdem können Sie Freigabemomentaufnahmen auflisten, durchsuchen und löschen. Freigabemomentaufnahmen sind schreibgeschützt.

Erstellen von Freigabemomentaufnahmen

Im folgenden Beispiel wird eine Freigabemomentaufnahme erstellt.

//-------------------------------------------------
// Create a share snapshot
//-------------------------------------------------
public async Task CreateShareSnapshotAsync(string shareName)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instatiate a ShareServiceClient
    ShareServiceClient shareServiceClient = new ShareServiceClient(connectionString);

    // Instantiate a ShareClient which will be used to access the file share
    ShareClient share = shareServiceClient.GetShareClient(shareName);

    // Ensure that the share exists
    if (await share.ExistsAsync())
    {
        // Create a snapshot
        ShareSnapshotInfo snapshotInfo = await share.CreateSnapshotAsync();
        Console.WriteLine($"Snapshot created: {snapshotInfo.Snapshot}");
    }
}

Auflisten von Freigabemomentaufnahmen

Das folgende Beispiel listet die Momentaufnahmen in einer Freigabe auf.

//-------------------------------------------------
// List the snapshots on a share
//-------------------------------------------------
public void ListShareSnapshots()
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instatiate a ShareServiceClient
    ShareServiceClient shareServiceClient = new ShareServiceClient(connectionString);

    // Display each share and the snapshots on each share
    foreach (ShareItem item in shareServiceClient.GetShares(ShareTraits.All, ShareStates.Snapshots))
    {
        if (null != item.Snapshot)
        {
            Console.WriteLine($"Share: {item.Name}\tSnapshot: {item.Snapshot}");
        }
    }
}

Auflisten von Dateien und Verzeichnissen in Freigabemomentaufnahmen

Das folgende Beispiel durchsucht Dateien und Verzeichnisse in Freigabemomentaufnahmen.

//-------------------------------------------------
// List the snapshots on a share
//-------------------------------------------------
public void ListSnapshotContents(string shareName, string snapshotTime)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instatiate a ShareServiceClient
    ShareServiceClient shareService = new ShareServiceClient(connectionString);

    // Get a ShareClient
    ShareClient share = shareService.GetShareClient(shareName);

    Console.WriteLine($"Share: {share.Name}");

    // Get as ShareClient that points to a snapshot
    ShareClient snapshot = share.WithSnapshot(snapshotTime);

    // Get the root directory in the snapshot share
    ShareDirectoryClient rootDir = snapshot.GetRootDirectoryClient();

    // Recursively list the directory tree
    ListDirTree(rootDir);
}

//-------------------------------------------------
// Recursively list a directory tree
//-------------------------------------------------
public void ListDirTree(ShareDirectoryClient dir)
{
    // List the files and directories in the snapshot
    foreach (ShareFileItem item in dir.GetFilesAndDirectories())
    {
        if (item.IsDirectory)
        {
            Console.WriteLine($"Directory: {item.Name}");
            ShareDirectoryClient subDir = dir.GetSubdirectoryClient(item.Name);
            ListDirTree(subDir);
        }
        else
        {
            Console.WriteLine($"File: {dir.Name}\\{item.Name}");
        }
    }
}

Wiederherstellen von Dateifreigaben oder Dateien aus Freigabemomentaufnahmen

Die Erstellung einer Momentaufnahme von einer Dateifreigabe ermöglicht die Wiederherstellung einzelner Dateien oder der gesamten Dateifreigabe.

Zum Wiederherstellen einer Datei aus einer Dateifreigabemomentaufnahme können Sie die Freigabemomentaufnahmen einer Dateifreigabe abfragen. Danach können Sie eine Datei abrufen, die zu einer bestimmten Freigabemomentaufnahme gehört. Verwenden Sie diese Version, um die Datei direkt zu lesen oder wiederherzustellen.

//-------------------------------------------------
// Restore file from snapshot
//-------------------------------------------------
public async Task RestoreFileFromSnapshot(string shareName, string directoryName, string fileName, string snapshotTime)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instatiate a ShareServiceClient
    ShareServiceClient shareService = new ShareServiceClient(connectionString);

    // Get a ShareClient
    ShareClient share = shareService.GetShareClient(shareName);

    // Get as ShareClient that points to a snapshot
    ShareClient snapshot = share.WithSnapshot(snapshotTime);

    // Get a ShareDirectoryClient, then a ShareFileClient to the snapshot file
    ShareDirectoryClient snapshotDir = snapshot.GetDirectoryClient(directoryName);
    ShareFileClient snapshotFile = snapshotDir.GetFileClient(fileName);

    // Get a ShareDirectoryClient, then a ShareFileClient to the live file
    ShareDirectoryClient liveDir = share.GetDirectoryClient(directoryName);
    ShareFileClient liveFile = liveDir.GetFileClient(fileName);

    // Restore the file from the snapshot
    ShareFileCopyInfo copyInfo = await liveFile.StartCopyAsync(snapshotFile.Uri);

    // Display the status of the operation
    Console.WriteLine($"Restore status: {copyInfo.CopyStatus}");
}

Löschen von Freigabemomentaufnahmen

Im folgenden Beispiel wird eine Freigabemomentaufnahme gelöscht.

//-------------------------------------------------
// Delete a snapshot
//-------------------------------------------------
public async Task DeleteSnapshotAsync(string shareName, string snapshotTime)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instatiate a ShareServiceClient
    ShareServiceClient shareService = new ShareServiceClient(connectionString);

    // Get a ShareClient
    ShareClient share = shareService.GetShareClient(shareName);

    // Get a ShareClient that points to a snapshot
    ShareClient snapshotShare = share.WithSnapshot(snapshotTime);

    try
    {
        // Delete the snapshot
        await snapshotShare.DeleteIfExistsAsync();
    }
    catch (RequestFailedException ex)
    {
        Console.WriteLine($"Exception: {ex.Message}");
        Console.WriteLine($"Error code: {ex.Status}\t{ex.ErrorCode}");
    }
}

Behandeln von Azure Files-Problemen mithilfe von Metriken

Azure Storage Analytics unterstützt Metriken für Azure Files. Mit Metrikdaten können Sie Anforderungen verfolgen und Probleme diagnostizieren.

Die Metriken für Azure Files können über das Azure-Portal aktiviert werden. Sie können Metriken auch programmgesteuert aktivieren, indem Sie den Vorgang Set File Service Properties mit der REST-API oder einem entsprechenden Vorgang in der Azure Files-Clientbibliothek aufrufen.

Das folgende Codebeispiel zeigt, wie Sie die .NET-Clientbibliothek zum Aktivieren von Metriken für Azure Files verwenden.

//-------------------------------------------------
// Use metrics
//-------------------------------------------------
public async Task UseMetricsAsync()
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instatiate a ShareServiceClient
    ShareServiceClient shareService = new ShareServiceClient(connectionString);

    // Set metrics properties for File service
    await shareService.SetPropertiesAsync(new ShareServiceProperties()
    {
        // Set hour metrics
        HourMetrics = new ShareMetrics()
        {
            Enabled = true,
            IncludeApis = true,
            Version = "1.0",

            RetentionPolicy = new ShareRetentionPolicy()
            {
                Enabled = true,
                Days = 14
            }
        },

        // Set minute metrics
        MinuteMetrics = new ShareMetrics()
        {
            Enabled = true,
            IncludeApis = true,
            Version = "1.0",

            RetentionPolicy = new ShareRetentionPolicy()
            {
                Enabled = true,
                Days = 7
            }
        }
    });

    // Read the metrics properties we just set
    ShareServiceProperties serviceProperties = await shareService.GetPropertiesAsync();

    // Display the properties
    Console.WriteLine();
    Console.WriteLine($"HourMetrics.InludeApis: {serviceProperties.HourMetrics.IncludeApis}");
    Console.WriteLine($"HourMetrics.RetentionPolicy.Days: {serviceProperties.HourMetrics.RetentionPolicy.Days}");
    Console.WriteLine($"HourMetrics.Version: {serviceProperties.HourMetrics.Version}");
    Console.WriteLine();
    Console.WriteLine($"MinuteMetrics.InludeApis: {serviceProperties.MinuteMetrics.IncludeApis}");
    Console.WriteLine($"MinuteMetrics.RetentionPolicy.Days: {serviceProperties.MinuteMetrics.RetentionPolicy.Days}");
    Console.WriteLine($"MinuteMetrics.Version: {serviceProperties.MinuteMetrics.Version}");
    Console.WriteLine();
}

Wenn Probleme auftreten, können Sie auf Behandeln von Azure Files-Problemen unter Windows verweisen.

Nächste Schritte

Weitere Informationen zu Azure Files finden Sie in den folgenden Ressourcen:

Konzeptionelle Artikel und Videos

Toolunterstützung für Dateispeicher

Verweis