Condividi tramite

Sviluppare per File di Azure con .NET

Informazioni su come sviluppare applicazioni .NET che usano File di Azure per archiviare i dati. File di Azure è un servizio di condivisione file gestito nel cloud. Fornisce condivisioni file completamente gestite accessibili tramite i protocolli SMB (Server Message Block) e NFS (Network File System) standard del settore. File di Azure fornisce anche un'API REST per l'accesso a livello di codice alle condivisioni file.

In questo articolo vengono illustrati i diversi approcci allo sviluppo con File di Azure in .NET e come scegliere l'approccio più adatto alle esigenze dell'app. Si apprenderà anche come creare un'app console di base che interagisce con le risorse di File di Azure.

Si applica a

Modello di gestione Modello di fatturazione Livello supporti Ridondanza Piccole e Medie Imprese (PMI) NFS (Network File System)
Microsoft.Storage Con provisioning v2 HDD (standard) Locale Sì No
Microsoft.Storage Con provisioning v2 HDD (standard) Della zona Sì No
Microsoft.Storage Con provisioning v2 HDD (standard) Geografica Sì No
Microsoft.Storage Con provisioning v2 HDD (standard) GeoZone (GZRS) Sì No
Microsoft.Storage Con provisioning v1 SSD (Premium) Locale Sì No
Microsoft.Storage Con provisioning v1 SSD (Premium) Della zona Sì No
Microsoft.Storage Pagamento in base al consumo HDD (standard) Locale Sì No
Microsoft.Storage Pagamento in base al consumo HDD (standard) Della zona Sì No
Microsoft.Storage Pagamento in base al consumo HDD (standard) Geografica Sì No
Microsoft.Storage Pagamento in base al consumo HDD (standard) GeoZone (GZRS) Sì No

Informazioni sullo sviluppo di app .NET con File di Azure

File di Azure offre diversi modi per gli sviluppatori .NET di accedere ai dati e gestire le risorse in File di Azure. La tabella seguente elenca gli approcci, riepiloga il funzionamento e fornisce indicazioni su quando usare ogni approccio:

Avvicinarsi Come funziona Utilizzo di
Librerie di I/O file standard Usa chiamate API a livello di sistema operativo tramite condivisioni file di Azure montate usando SMB o NFS. Quando si monta una condivisione file usando SMB/NFS, è possibile usare librerie di I/O di file per un linguaggio di programmazione o un framework, ad esempio System.IO per .NET. Hai app line-of-business con codice esistente che utilizza l'I/O di file standard e non vuoi riscrivere il codice per far sì che l'app funzioni con una condivisione file di Azure.
FileREST API Chiama direttamente gli endpoint HTTPS per interagire con i dati archiviati in File di Azure. Fornisce il controllo a livello di codice sulle risorse di condivisione file. Azure SDK fornisce la libreria client delle condivisioni file (Azure.Storage.Files.Shares) basata sull'API FileREST, consentendo di interagire con le operazioni api FileREST tramite paradigmi noti del linguaggio di programmazione .NET. Si creano servizi cloud e app a valore aggiunto per i clienti e si vogliono usare funzionalità avanzate non disponibili tramite System.IO.
API REST del provider di risorse di archiviazione Usa Azure Resource Manager (ARM) per gestire gli account di archiviazione e le condivisioni file. Chiama gli endpoint DELL'API REST per varie operazioni di gestione delle risorse. L'app o il servizio deve eseguire attività di gestione delle risorse, ad esempio la creazione, l'eliminazione o l'aggiornamento di account di archiviazione o condivisioni file.

Per informazioni generali su questi approcci, vedere Panoramica dello sviluppo di applicazioni con File di Azure.

Questo articolo è incentrato sull'uso delle risorse di File di Azure usando gli approcci seguenti:

Prerequisiti

Configurazione dell'ambiente

Questa sezione illustra i passaggi per preparare un'app console .NET da usare con File di Azure.

Creare il progetto

Se non si ha già un'app .NET, crearne una usando Visual Studio o l'interfaccia della riga di comando di .NET. In questo articolo viene creata un'app console per semplicità.

  1. Avviare Visual Studio e selezionare Crea un nuovo progetto. In alternativa, se ci si trova in Visual Studio, passare a File>Nuovo>progetto.
  2. Nella finestra di dialogo scegliere App console per C# e selezionare Avanti.
  3. Immettere un nome per il progetto, lasciare le impostazioni predefinite e selezionare Avanti.
  4. Per Framework selezionare la versione più recente installata di .NET. Lasciare le altre impostazioni predefinite e selezionare Crea.

Installare il pacchetto

Se si prevede di interagire con File di Azure usando lo System.IO spazio dei nomi , non è necessario installare pacchetti aggiuntivi. Lo System.IO spazio dei nomi è incluso in .NET SDK. Se si prevede di usare la libreria client condivisioni file per .NET o la libreria di gestione di Archiviazione di Azure per .NET, installare il pacchetto usando NuGet.

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto e scegliere Gestisci pacchetti NuGet.

  2. In Gestione pacchetti NuGet, selezionare Sfoglia. Cercare quindi e scegliere il pacchetto appropriato e selezionare Installa. Per la libreria client condivisioni file scegliere Azure.Storage.Files.Shares. Per la libreria di gestione di Archiviazione di Azure scegliere Azure.ResourceManager.Storage. Per la libreria di identità di Azure, necessaria per le connessioni senza password, scegliere Azure.Identity.

    Questo passaggio installa il pacchetto e le relative dipendenze.

Aggiungere le direttive using

Se si prevede di usare lo System.IO spazio dei nomi , aggiungere la direttiva using seguente all'inizio del file Program.cs :

using System.IO;

Se si prevede di usare la libreria client condivisioni file per .NET, aggiungere la direttiva using seguente all'inizio del file Program.cs :

using Azure.Storage.Files.Shares;

Se si prevede di usare la libreria di gestione di Archiviazione di Azure per .NET, aggiungere la direttiva using seguente all'inizio del file Program.cs :

using Azure.ResourceManager;

Per usare la libreria di identità di Azure per le connessioni senza password ai servizi di Azure, aggiungere la direttiva using seguente all'inizio del file Program.cs :

using Azure.Identity;

Usare File di Azure con System.IO

Le librerie di I/O di file standard sono il modo più comune per accedere e usare le risorse di File di Azure. Quando si monta una condivisione file usando SMB o NFS, il sistema operativo reindirizza le richieste API per il file system locale. Questo approccio consente di usare librerie di I/O di file standard, ad esempio System.IO, per interagire con file e directory nella condivisione.

Prendere in considerazione l'uso System.IO quando l'app richiede:

  • Compatibilità delle app: Ideale per le app line-of-business con codice esistente che usa System.IOgià . Non è necessario riscrivere il codice affinché l'app funzioni con una condivisione file di Azure.
  • Facilità d'uso:System.IO è ben noto dagli sviluppatori e facile da usare. Una proposta di valore chiave di File di Azure consiste nell'esposizione delle API del file system native tramite SMB e NFS.

In questa sezione si apprenderà come usare per usare System.IO le risorse di File di Azure.

Per altre informazioni ed esempi, vedere le risorse seguenti:

Montare una condivisione di file

Per usare System.IO, è necessario prima montare una condivisione file. Per indicazioni su come montare una condivisione file con SMB o NFS, vedere le risorse seguenti:

In questo articolo viene usato il percorso seguente per fare riferimento a una condivisione file SMB montata in Windows:

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

Esempio: Connettersi a una condivisione file ed enumerare le directory usando System.IO

Nell'esempio di codice seguente viene illustrato come connettersi a una condivisione file ed elencare le directory nella condivisione:

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

Esempio: Scrivere in un file in una condivisione file usando System.IO

Nell'esempio di codice seguente viene illustrato come scrivere e aggiungere testo con la File classe :

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

Esempio: Bloccare un file in una condivisione file usando System.IO

I client SMB che montano condivisioni file possono usare meccanismi di blocco del file system per gestire l'accesso ai file condivisi.

Nell'esempio di codice seguente viene illustrato come bloccare un file in una condivisione file con modalità condivisione impostata su None. Questa modalità di condivisione rifiuta la condivisione del file corrente fino alla chiusura del file.

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

Quando si usano sia SMB che l'API FileREST, tenere presente che l'API FileREST usa lease per gestire i blocchi di file, mentre SMB usa blocchi del file system gestiti dal sistema operativo. Per altre informazioni sulla gestione delle interazioni di blocco dei file tra SMB e l'API FileREST, vedere Gestire i blocchi di file.

Esempio: Enumerare gli ACL di file usando System.IO

Nell'esempio di codice seguente viene illustrato come enumerare gli elenchi di controllo di accesso (ACL) per un file:

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

}

Usare i dati di File di Azure usando la libreria client Condivisioni file per .NET

L'API FileREST fornisce l'accesso a livello di codice a File di Azure. Consente di chiamare gli endpoint HTTPS per eseguire operazioni su condivisioni file, directory e file. L'API FileREST è progettata per funzionalità avanzate e scalabilità elevate che potrebbero non essere disponibili tramite protocolli nativi. Azure SDK fornisce librerie client, ad esempio la libreria client condivisioni file per .NET, che si basano sull'API FileREST.

È consigliabile usare l'API FileREST e la libreria client di condivisione file se l'applicazione richiede:

  • Funzionalità avanzate: Operazioni di accesso e funzionalità non disponibili tramite protocolli nativi.
  • Integrazioni cloud personalizzate: Creare servizi personalizzati a valore aggiunto, ad esempio backup, antivirus o gestione dei dati, che interagiscono direttamente con File di Azure.
  • Ottimizzazione delle prestazioni: Sfruttare i vantaggi delle prestazioni in scenari su larga scala usando le operazioni del piano dati.

L'API FileREST modella File di Azure come gerarchia di risorse ed è consigliata per le operazioni eseguite a livello di directory o file . È consigliabile preferire l'API REST del provider di risorse di archiviazione per le operazioni eseguite a livello di servizio file o condivisione file .

In questa sezione si apprenderà come utilizzare la libreria client File Shares per gestire le risorse di Azure Files.

Per altre informazioni ed esempi, vedere le risorse seguenti:

Autorizzare l'accesso e creare un client

Per connettere un'app a File di Azure, creare un oggetto ShareClient. Questo oggetto è il punto di partenza per l'uso delle risorse di File di Azure. Negli esempi di codice seguenti viene illustrato come creare un ShareClient oggetto usando meccanismi di autorizzazione diversi.

Per autorizzare con Microsoft Entra ID è necessario usare un'entità di sicurezza. Il tipo di entità di sicurezza necessaria dipende dalla posizione in cui viene eseguita l'app. Usare questa tabella come riferimento.

Posizione in cui viene eseguita l'applicazione Entità di sicurezza principale Indicazioni
Computer locale (sviluppo e test) Service Principal Per informazioni su come registrare l'app, configurare un gruppo di Microsoft Entra, assegnare ruoli e configurare le variabili di ambiente, vedere Autorizzare l'accesso usando le entità servizio per sviluppatori
Computer locale (sviluppo e test) Identità utente Per informazioni su come configurare un gruppo di Microsoft Entra, assegnare ruoli e accedere ad Azure, vedere Autorizzare l'accesso usando le credenziali per sviluppatori
Ospitato su Azure Identità gestita Per informazioni su come abilitare l'identità gestita e assegnare ruoli, vedere Autorizzare l'accesso dalle app ospitate in Azure usando un'identità gestita
Ospitata all'esterno di Azure (ad esempio, app locali) Service Principal Per informazioni su come registrare l'app, assegnare ruoli e configurare le variabili di ambiente, vedere Autorizzare l'accesso dalle app locali usando un'entità servizio dell'applicazione

Per lavorare con gli esempi di codice in questo articolo, assegnare all'entità di sicurezza il ruolo predefinito di Controllo degli accessi in base al ruolo di Azure Collaboratore con privilegi per i dati dei file di archiviazione. Questo ruolo fornisce l'accesso completo in lettura, scrittura, modifica ACL ed eliminazione su tutti i dati nelle condivisioni per tutti gli account di archiviazione configurati, indipendentemente dalle autorizzazioni NTFS impostate a livello di file/directory. Per ulteriori informazioni, vedere Accedere alle condivisioni file di Azure utilizzando Microsoft Entra ID con OAuth Files di Azure tramite REST.

Autorizzare l'accesso con DefaultAzureCredential

Un modo semplice e sicuro per autorizzare l'accesso e connettersi a File di Azure consiste nel ottenere un token OAuth creando un'istanza DefaultAzureCredential . È quindi possibile usare tale credenziale per creare un ShareClient oggetto .

Nell'esempio seguente viene creato un ShareClient oggetto autorizzato usando DefaultAzureCredential, quindi viene creato un ShareDirectoryClient oggetto per lavorare con una directory nella condivisione:

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

Se si conosce esattamente il tipo di credenziali che si useranno per autenticare gli utenti, è possibile ottenere un token OAuth usando altre classi nella libreria client di Azure.Identity per .NET. Queste classi derivano dalla classe TokenCredential.

Per altre informazioni su ognuno di questi meccanismi di autorizzazione, vedere Scegliere come autorizzare l'accesso ai dati dei file.

Esempio: Copiare file usando la libreria client Condivisioni file

È possibile copiare file all'interno di una condivisione file o tra condivisioni file usando il metodo seguente:

È possibile copiare un file in un BLOB di destinazione usando il metodo seguente da un BlobClient oggetto :

Nell'esempio di codice seguente viene illustrato come copiare un file in un file in un'altra condivisione file:

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

Esempio: Creare un lease su un file usando la libreria client di Condivisioni file

Un lease crea un blocco in un file gestito da Azure tramite un ID lease. Il lease fornisce un meccanismo per coordinare l'accesso ai file tra più client in un sistema distribuito. Un lease su un file fornisce accesso esclusivo in scrittura ed eliminazione. Per altre informazioni sugli stati di lease e sulle azioni, vedere File di lease.

L'esempio di codice seguente illustra come creare un client di lease, acquisire un lease di durata infinito in un file e rilasciare il lease:

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

Quando si usano sia SMB che l'API FileREST, tenere presente che l'API FileREST usa lease per gestire i blocchi di file, mentre SMB usa blocchi del file system gestiti dal sistema operativo. Per altre informazioni sulla gestione delle interazioni di blocco dei file tra SMB e l'API FileREST, vedere Gestire i blocchi di file.

Esempio: creare ed elencare snapshot di condivisioni usando la libreria client di Condivisioni file

Gli snapshot di condivisione sono copie di sola lettura di una condivisione file in un momento specifico. È possibile creare uno snapshot di una condivisione file e quindi usare lo snapshot per accedere ai dati nella condivisione al momento della creazione dello snapshot. È anche possibile elencare tutti gli snapshot in una condivisione file ed eliminare gli snapshot di condivisione.

Nell'esempio di codice seguente viene illustrato come creare uno snapshot di condivisione, elencare gli snapshot in una condivisione file e attraversare l'albero della directory in uno snapshot di condivisione:

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

Nota

I token OAuth, ad esempio quelli ottenuti quando si usa DefaultAzureCredential, non sono consentiti per le operazioni del piano dati a livello di condivisione file. Per usare gli snapshot di condivisione, l'oggetto client deve essere autorizzato usando la chiave dell'account. L'oggetto ShareClient creato in questo esempio di codice usa una stringa di connessione, che include la chiave dell'account.

L'archiviazione delle chiavi dell'account o delle stringhe di connessione presenta un rischio per la sicurezza. È consigliabile usarli solo quando l'autenticazione di Microsoft Entra non è disponibile. Per altre informazioni sull'archiviazione sicura delle chiavi dell'account in Azure Key Vault, vedere Informazioni sulle chiavi dell'account di archiviazione gestito di Azure Key Vault.

Gestire le risorse di File di Azure usando le librerie di gestione di Archiviazione di Azure

Le librerie di gestione di Archiviazione di Azure sono basate sull'API REST del provider di risorse di Archiviazione di Azure. Il provider di risorse di Archiviazione di Azure è un servizio basato su Azure Resource Manager e supporta sia metodi dichiarativi (modelli) che imperativi (chiamata API diretta). L'API REST del provider di risorse di Archiviazione di Azure fornisce l'accesso a livello di codice alle risorse di Archiviazione di Azure, incluse le condivisioni file. Azure SDK offre librerie di gestione basate sull'API REST del provider di risorse di Archiviazione di Azure.

Le librerie di gestione sono consigliate per le operazioni eseguite a livello di servizio file o condivisione file . In questa sezione si apprenderà come usare le librerie di gestione di Archiviazione di Azure per gestire le risorse di File di Azure.

Esempio: Creare una condivisione file usando la libreria di gestione di Archiviazione di Azure

L'esempio di codice seguente illustra come creare un oggetto di primo livello ArmClient , registrare il provider di risorse di archiviazione con una sottoscrizione e creare una condivisione file usando la libreria di gestione di Archiviazione di Azure:

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;

È possibile configurare le proprietà della condivisione file usando la classe FileShareData . Nell'esempio precedente viene illustrato come impostare la ShareQuota proprietà .

Nota

Per eseguire l'operazione di registrazione, sono necessarie le autorizzazioni per la seguente azione RBAC di Azure: Microsoft.Storage/register/action. Questa autorizzazione è inclusa nei ruoli predefiniti Collaboratore e Proprietario.

Esempio: Elencare condivisioni file e snapshot usando la libreria di gestione di Archiviazione di Azure

L'esempio di codice seguente illustra come elencare condivisioni file e snapshot in un account di archiviazione:

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

Contenuti correlati

Per altre informazioni sullo sviluppo con File di Azure, vedere le risorse seguenti: