Tworzenie oprogramowania dla usługi Azure Files przy użyciu platformy .NET

Dowiedz się, jak tworzyć aplikacje platformy .NET korzystające z usługi Azure Files do przechowywania danych. Azure Files to zarządzana usługa udziału plików w chmurze. Zapewnia w pełni zarządzane udziały plików, które są dostępne za pośrednictwem standardowych protokołów SMB (Server Message Block) i Network File System (NFS). Usługa Azure Files udostępnia również interfejs API REST na potrzeby programowego dostępu do udziałów plików.

W tym artykule dowiesz się więcej o różnych podejściach do opracowywania za pomocą usługi Azure Files na platformie .NET oraz o tym, jak wybrać podejście, które najlepiej odpowiada potrzebom aplikacji. Dowiesz się również, jak utworzyć podstawową aplikację konsolową, która współdziała z zasobami usługi Azure Files.

Dotyczy

Model zarządzania	Model rozliczania	Poziom mediów	Redundancja	SMB	NFS
Microsoft.Storage	Przygotowana wersja 2	HDD (standardowa)	Lokalne (LRS)
Microsoft.Storage	Przygotowana wersja 2	HDD (standardowa)	Strefa (ZRS)
Microsoft.Storage	Przygotowana wersja 2	HDD (standardowa)	Geo (GRS)
Microsoft.Storage	Przygotowana wersja 2	HDD (standardowa)	Strefa geograficzna (GZRS)
Microsoft.Storage	Zaprovisionowana wersja 1	SSD klasy premium	Lokalne (LRS)
Microsoft.Storage	Zaprovisionowana wersja 1	SSD klasy premium	Strefa (ZRS)
Microsoft.Storage	Płatność na bieżąco	HDD (standardowa)	Lokalne (LRS)
Microsoft.Storage	Płatność na bieżąco	HDD (standardowa)	Strefa (ZRS)
Microsoft.Storage	Płatność na bieżąco	HDD (standardowa)	Geo (GRS)
Microsoft.Storage	Płatność na bieżąco	HDD (standardowa)	Strefa geograficzna (GZRS)

Informacje o tworzeniu aplikacji platformy .NET za pomocą usługi Azure Files

Usługa Azure Files oferuje deweloperom platformy .NET kilka sposobów uzyskiwania dostępu do danych i zarządzania zasobami w usłudze Azure Files. W poniższej tabeli wymieniono metody, podsumowano sposób ich działania i przedstawiono wskazówki dotyczące tego, kiedy należy używać poszczególnych metod:

Aby uzyskać ogólne informacje na temat tych podejść, zobacz Omówienie tworzenia aplikacji w usłudze Azure Files.

Ten artykuł koncentruje się na pracy z zasobami usługi Azure Files przy użyciu następujących metod:

• Praca z usługą Azure Files przy użyciu System.IO: Zamontuj udział plików przy użyciu protokołu SMB lub NFS i użyj przestrzeni nazw System.IO do pracy z plikami i katalogami w udziale.
• Praca z Azure Files przy użyciu biblioteki klienta dla udziałów plików na platformie .NET: Użyj biblioteki klienta usługi Azure Storage dla udziałów plików na platformie .NET, aby pracować z plikami i katalogami w udziale plików. Ta biblioteka kliencka bazuje na interfejsie API FileREST.
• Zarządzanie zasobami usługi Azure Files przy użyciu bibliotek zarządzania Azure Storage: użyj bibliotek zarządzania Azure Storage, aby zarządzać udziałami plików i innymi zasobami w swoim koncie magazynu. Biblioteki do zarządzania bazują na interfejsie API REST dostawcy zasobów usługi Azure Storage.

Wymagania wstępne

• Subskrypcja platformy Azure — utwórz jedną bezpłatnie
• Konto usługi Azure Storage — utwórz konto usługi Azure Storage
• Najnowszy zestaw .NET SDK dla systemu operacyjnego (pobierz zestaw SDK, a nie środowisko uruchomieniowe)

Konfigurowanie środowiska

W tej sekcji przedstawiono kroki przygotowywania aplikacji konsolowej platformy .NET do pracy z usługą Azure Files.

Tworzenie projektu

Jeśli nie masz jeszcze aplikacji platformy .NET, utwórz aplikację przy użyciu programu Visual Studio lub interfejsu wiersza polecenia platformy .NET. W tym artykule utworzymy aplikację konsolową dla uproszczenia.

Instalowanie pakietu

Jeśli planujesz interakcję z usługą Azure Files przy użyciu System.IO przestrzeni nazw, nie musisz instalować żadnych dodatkowych pakietów. Przestrzeń nazw System.IO jest dołączona do .NET SDK. Jeśli planujesz korzystać z bibliotek klienta udostępniania plików dla platformy .NET lub zarządzania Azure Storage dla platformy .NET, zainstaluj pakiet za pomocą narzędzia NuGet.

dotnet add package Azure.Storage.Files.Shares
dotnet add package Azure.ResourceManager.Storage
dotnet add package Azure.Identity

Dodaj dyrektywy using

Jeśli planujesz użyć przestrzeni nazw System.IO, dodaj następującą dyrektywę using na początku pliku Program.cs.

using System.IO;

Jeśli planujesz używać biblioteki klienta udostępniania plików dla platformy .NET, dodaj następującą dyrektywę 'using' w górnej części pliku Program.cs

using Azure.Storage.Files.Shares;

Jeśli planujesz korzystać z biblioteki zarządzania Azure Storage dla .NET, dodaj następującą dyrektywę using na początku pliku Program.cs:

using Azure.ResourceManager;

Aby użyć biblioteki tożsamości platformy Azure na potrzeby połączeń bez hasła z usługami platformy Azure, dodaj następującą dyrektywę using na początku pliku Program.cs :

using Azure.Identity;

Praca z usługą Azure Files przy użyciu System.IO

Standardowe biblioteki we/wy plików to najbardziej typowy sposób uzyskiwania dostępu do zasobów usługi Azure Files i pracy z nimi. Podczas montowania udziału plików przy użyciu protokołu SMB lub NFS system operacyjny przekierowuje żądania interfejsu API dla lokalnego systemu plików. Takie podejście umożliwia korzystanie ze standardowych bibliotek we/wy plików, takich jak System.IO, do interakcji z plikami i katalogami w udziale.

Rozważ użycie System.IO w przypadku, gdy aplikacja wymaga:

• Zgodność aplikacji: Idealne rozwiązanie dla aplikacji biznesowych z istniejącym kodem, który już używa metody System.IO. Nie musisz ponownie pisać kodu, aby aplikacja działała z współdzieleniem plików Azure.
• Łatwość użycia:System.IO jest dobrze znany przez deweloperów i łatwy w użyciu. Kluczową wartością usługi Azure Files jest to, że uwidacznia natywne interfejsy API systemu plików za pośrednictwem protokołu SMB i systemu plików NFS.

W tej sekcji dowiesz się, jak używać System.IO, aby pracować z zasobami usługi Azure Files.

Więcej informacji i przykładów zawierają następujące zasoby:

• Omówienie operacji I/O plików i strumieni
• Typowe zadania wejścia/wyjścia

Zamontować udział plików

Aby użyć System.IO, należy najpierw zamontować zasób plików. Zapoznaj się z następującymi zasobami, aby uzyskać wskazówki dotyczące sposobu instalowania udziału plików przy użyciu protokołu SMB lub NFS:

• Instalowanie udziału plików SMB w systemie Windows
• Instalowanie udziału plików SMB w systemie Linux
• Montowanie udziału plikowego NFS w systemie Linux

W tym artykule użyjemy następującej ścieżki, aby odwołać się do zamontowanego udziału plików SMB w systemie Windows:

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

Przykład: nawiązywanie połączenia z udziałem plików i wyliczanie katalogów przy użyciu System.IO

W poniższym przykładzie kodu pokazano, jak nawiązać połączenie do zasobu udostępnionego i wyświetlić listę katalogów w nim:

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);
    }
}

Przykład: zapisywanie w pliku w udziale plików przy użyciu System.IO

W poniższym przykładzie kodu pokazano, jak napisać i dołączyć tekst z klasą File :

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);
}

Przykład: blokowanie pliku w udziale plików przy użyciu System.IO

Klienci SMB, którzy podłączają udziały plików, mogą używać mechanizmów blokowania systemu plików do zarządzania dostępem do udostępnionych plików.

Poniższy przykład kodu pokazuje, jak zablokować plik w udziale plików z trybem udostępniania ustawionym na None. Ten tryb udostępniania odrzuca udostępnianie bieżącego pliku do momentu zamknięcia pliku.

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);
    }
}

W przypadku korzystania zarówno z protokołu SMB, jak i interfejsu API FileREST należy pamiętać, że interfejs API FileREST używa dzierżaw do zarządzania blokadami plików, podczas gdy protokół SMB używa blokad systemu plików zarządzanych przez system operacyjny. Aby dowiedzieć się więcej na temat zarządzania interakcjami blokowania plików między protokółem SMB i interfejsem API FileREST, zobacz Zarządzanie blokadami plików.

Przykład: wyliczanie list ACL plików za pomocą System.IO

Poniższy przykład kodu przedstawia sposób wyliczania list kontroli dostępu (ACL) dla pliku:

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();
    }

}

Praca z danymi Azure Files przy użyciu biblioteki klienta do zasobów plików na platformie .NET

Interfejs API FileREST zapewnia dostęp programowy do usługi Azure Files. Umożliwia wywoływanie punktów końcowych HTTPS w celu wykonywania operacji na udostępnionych zasobach plików, katalogach i plikach. Interfejs API FileREST został zaprojektowany z myślą o wysokiej skalowalności i zaawansowanych funkcjach, które mogą nie być dostępne za pośrednictwem protokołów natywnych. Zestaw Azure SDK udostępnia biblioteki klienckie, takie jak biblioteka klienta udziałów plików dla platformy .NET, które są oparte na interfejsie API FileREST.

Rozważ użycie interfejsu API FileREST i biblioteki klienta dysku sieciowego, jeśli aplikacja wymaga:

• Funkcje zaawansowane: Operacje dostępu i funkcje, które nie są dostępne za pośrednictwem protokołów natywnych.
• Niestandardowe integracje z chmurą: Twórz niestandardowe usługi dodane do wartości, takie jak tworzenie kopii zapasowych, ochrony antywirusowej lub zarządzanie danymi, które współdziałają bezpośrednio z usługą Azure Files.
• Optymalizacja wydajności: Skorzystaj z zalet wydajności w scenariuszach o dużej skali przy użyciu operacji płaszczyzny danych.

Interfejs API FileREST modeluje usługę Azure Files jako hierarchię zasobów i jest zalecany w przypadku operacji wykonywanych na poziomie katalogu lub pliku . Powinieneś preferować interfejs API REST dostawcy zasobów usługi Storage dla operacji wykonywanych na poziomie usługi plików lub udziału plików.

W tej sekcji dowiesz się, jak używać biblioteki klienta Azure Files do pracy z zasobami usługi Azure Files.

Więcej informacji i przykładów zawierają następujące zasoby:

• Biblioteka klienta udziałów plików usługi Azure Storage dla platformy .NET
• Przykłady korzystania z biblioteki klienta dla udziałów plików w Azure Storage na platformie .NET

Autoryzowanie dostępu i tworzenie klienta

Aby połączyć aplikację z usługą ShareClient Azure Files, utwórz obiekt. Ten obiekt jest punktem wyjścia do pracy z zasobami usługi Azure Files. W poniższych przykładach kodu pokazano, jak utworzyć ShareClient obiekt przy użyciu różnych mechanizmów autoryzacji.

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");

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

StorageSharedKeyCredential sharedKeyCredential = 
    new StorageSharedKeyCredential(accountName, accountKey);

ShareClient shareClient = new ShareClient(
    new Uri($"https://{accountName}.file.core.windows.net/{shareName}"),
    sharedKeyCredential);

string connectionString = "<connection-string>";
string shareName = "<share-name>";

ShareClient shareClient = new ShareClient(connectionString, shareName);

Aby dowiedzieć się więcej na temat każdego z tych mechanizmów autoryzacji, zobacz Wybieranie sposobu autoryzowania dostępu do danych plików.

Przykład: kopiowanie plików z użyciem biblioteki klienta do współdzielenia plików

Pliki w udziale plików lub między udziałami plików można skopiować przy użyciu następującej metody:

• StartCopyAsync

Plik można skopiować przy użyciu następującej metody z obiektu BlobClient do docelowego obiektu blob.

• StartCopyFromUriAsync

W poniższym przykładzie kodu pokazano, jak skopiować plik do pliku w innym udziale plików:

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);

Przykład: dzierżawa pliku przy użyciu biblioteki klienta udostępniania plików

Dzierżawa tworzy blokadę pliku zarządzanego przez platformę Azure za pośrednictwem identyfikatora dzierżawy. Dzierżawa zapewnia mechanizm koordynowania dostępu do plików między wieloma klientami w systemie rozproszonym. Dzierżawa pliku zapewnia wyłączny dostęp do zapisu i usuwania. Aby dowiedzieć się więcej o stanach dzierżawy i akcjach, zobacz Plik dzierżawy.

Poniższy przykład kodu pokazuje, jak utworzyć klienta najmu, uzyskać nieskończony czas trwania najmu na plik i zwolnić najem.

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();

W przypadku korzystania zarówno z protokołu SMB, jak i interfejsu API FileREST należy pamiętać, że interfejs API FileREST używa dzierżaw do zarządzania blokadami plików, podczas gdy protokół SMB używa blokad systemu plików zarządzanych przez system operacyjny. Aby dowiedzieć się więcej na temat zarządzania interakcjami blokowania plików między protokółem SMB i interfejsem API FileREST, zobacz Zarządzanie blokadami plików.

Przykład: Tworzenie i wyświetlanie listy migawek współdzielonych zasobów przy użyciu biblioteki klienta współdzielonych zasobów plikowych.

Migawki udziałów plików to kopie tylko do odczytu danej wersji udziału plików w określonym momencie. Możesz utworzyć migawkę udziału plików, a następnie użyć tej migawki, aby uzyskać dostęp do danych w udziale w chwili jej utworzenia. Można również wyświetlić listę wszystkich migawek w udziale plików i usunąć migawki udziałów.

Poniższy przykład kodu pokazuje, jak utworzyć migawkę udziału, wyświetlić listę migawek udziału plików oraz przejść przez drzewo katalogów w migawce udziału.

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}");
        }
    }
}

Zarządzanie zasobami usługi Azure Files przy użyciu bibliotek zarządzania usługi Azure Storage

Biblioteki zarządzania usługi Azure Storage są oparte na interfejsie API REST dostawcy zasobów usługi Azure Storage. Dostawca zasobów usługi Azure Storage jest usługą opartą na usłudze Azure Resource Manager i obsługuje metody deklaratywne (szablony) i imperatywne (bezpośrednie wywołanie interfejsu API). Interfejs API REST dostawcy zasobów usługi Azure Storage zapewnia programowy dostęp do zasobów usługi Azure Storage, w tym udziałów plików. Zestaw Azure SDK udostępnia biblioteki zarządzania oparte na interfejsie API REST dostawcy zasobów usługi Azure Storage.

Biblioteki zarządzania są zalecane w przypadku operacji wykonywanych na poziomie usługi plików lub udziału plików . W tej sekcji dowiesz się, jak zarządzać zasobami usługi Azure Files przy użyciu bibliotek zarządzania usługi Azure Storage.

Przykład: tworzenie udziału plików przy użyciu biblioteki zarządzania Azure Storage

W poniższym przykładzie kodu pokazano, jak utworzyć obiekt najwyższego poziomu ArmClient, zarejestrować dostawcę zasobów usługi Storage do subskrypcji oraz utworzyć udział plików przy użyciu biblioteki do zarządzania Azure Storage.

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;

Właściwości udziału plików można skonfigurować przy użyciu klasy FileShareData . Poprzedni przykład pokazuje, jak ustawić właściwość ShareQuota.

Przykład: Wyświetlanie listy udziałów plików i migawek przy użyciu biblioteki zarządzania usługi Azure Storage

Poniższy przykład kodu pokazuje, jak wyświetlić listę udostępnionych zasobów plików i migawek na koncie magazynu.

// 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}");
    }
}

Powiązana zawartość

Aby uzyskać więcej informacji o programowaniu za pomocą usługi Azure Files, zobacz następujące zasoby:

• Omówienie tworzenia aplikacji za pomocą usługi Azure Files
• Nazewnictwo i odwoływanie się do udziałów, katalogów, plików i metadanych
• Zarządzanie blokadami plików
• Operacje na katalogach
• Operacje na plikach