Dela via

Utveckla för Azure Files med .NET

Lär dig hur du utvecklar .NET-applikationer som använder Azure Files för att lagra data. Azure Files är en hanterad fillagringstjänst i molnet. Den tillhandahåller fullständigt hanterade filresurser som är tillgängliga via branschstandardprotokollen Server Message Block (SMB) och NFS (Network File System). Azure Files tillhandahåller också ett REST-API för programmatisk åtkomst till filresurser.

I den här artikeln lär du dig om de olika metoderna för att utveckla med Azure Files i .NET och hur du väljer den metod som bäst passar behoven för din app. Du får också lära dig hur du skapar en grundläggande konsolapp som interagerar med Azure Files-resurser.

Gäller för

Hanteringsmodell Faktureringsmodell Medieklass Redundans Små och medelstora företag (SMB) NFS (Network File System)
Microsoft.Storage, lagringstjänster Provisionerad v2 HDD (standard) Lokalt (LRS) Ja Inga
Microsoft.Storage, lagringstjänster Provisionerad v2 HDD (standard) Zon (ZRS) Ja Inga
Microsoft.Storage, lagringstjänster Provisionerad v2 HDD (standard) Geo (GRS) Ja Inga
Microsoft.Storage, lagringstjänster Provisionerad v2 HDD (standard) GeoZone (GZRS) Ja Inga
Microsoft.Storage, lagringstjänster Tillhandahållen v1 SSD (hög kvalitet) Lokalt (LRS) Ja Inga
Microsoft.Storage, lagringstjänster Tillhandahållen v1 SSD (hög kvalitet) Zon (ZRS) Ja Inga
Microsoft.Storage, lagringstjänster Betala efter hand HDD (standard) Lokalt (LRS) Ja Inga
Microsoft.Storage, lagringstjänster Betala efter hand HDD (standard) Zon (ZRS) Ja Inga
Microsoft.Storage, lagringstjänster Betala efter hand HDD (standard) Geo (GRS) Ja Inga
Microsoft.Storage, lagringstjänster Betala efter hand HDD (standard) GeoZone (GZRS) Ja Inga

Om .NET-app-utveckling med Azure Files

Azure Files erbjuder flera sätt för .NET-utvecklare att få tillgång till data och hantera resurser i Azure Files. I följande tabell visas metoderna, sammanfattar hur de fungerar och ger vägledning om när du ska använda varje metod:

Tillvägagångssätt Så här fungerar det När man ska använda
Standardbibliotek för fil-I/O Använder API-anrop på operativsystemsnivå via Azure-filresurser som monterats med SMB eller NFS. När du monterar en fildelning genom att använda SMB/NFS kan du använda fil I/O-bibliotek för ett programmeringsspråk eller ramverk, såsom System.IO för .NET. Du har verksamhetsspecifika appar med befintlig kod som använder standardfil-I/O och du vill inte skriva om kod för att appen ska fungera med en Azure-filresurs.
FileREST API Anropar HTTPS-slutpunkter direkt för att interagera med data som lagras i Azure Files. Ger programmatisk kontroll över fildelningsresurser. Azure SDK tillhandahåller klientbiblioteket File Shares (Azure.Storage.Files.Shares) som bygger på FileREST API, vilket gör att du kan interagera med FileREST API-operationer genom välbekanta paradigmer i .NET-programmeringsspråket. Du bygger värdeskapande molntjänster och appar för kunder och vill använda avancerade funktioner som inte är tillgängliga via System.IO.
REST API för lagringsresursprovider Använder Azure Resource Manager (ARM) för att hantera lagringskonton och filresurser. Anropar REST API-slutpunkter för olika resurshanteringsåtgärder. Din app eller tjänst måste utföra resurshanteringsuppgifter, till exempel att skapa, ta bort eller uppdatera lagringskonton eller filresurser.

Allmän information om dessa metoder finns i Översikt över programutveckling med Azure Files.

Den här artikeln fokuserar på att arbeta med Azure Files-resurser med hjälp av följande metoder:

Förutsättningar

Konfigurera din miljö

Den här sektionen vägleder dig genom stegen för att förbereda en .NET-konsolapp för att arbeta med Azure-filer.

Skapa projektet

Om du inte redan har en .NET-app, skapa en med hjälp av Visual Studio eller .NET CLI. I den här artikeln skapar vi en konsolapp för enkelhetens skull.

  1. Starta Visual Studio och välj Skapa ett nytt projekt. Om du är i Visual Studio går du till Nytt filprojekt>>.
  2. I dialogrutan väljer du Konsolapp för C# och sedan Nästa.
  3. Ange ett namn för projektet, lämna standardvärdena och välj Nästa.
  4. För Framework väljer du den senaste installerade versionen av .NET. Lämna de andra standardvärdena och välj Skapa.

Installera paketet

Om du planerar att interagera med Azure Files med hjälp av System.IO-namnrymden behöver du inte installera några ytterligare paket. Namnområdet System.IO inkluderas med .NET SDK. Om du planerar att använda klientbiblioteket för File Shares för .NET eller Azure Storage-hanteringsbiblioteket för .NET, installera paketet med hjälp av NuGet.

  1. Högerklicka på projektet i Solution Explorer och välj Hantera NuGet-paket.

  2. I NuGet Package Manager väljer du Bläddra. Sök sedan efter och välj det lämpliga paketet och välj Installera. För klientbiblioteket för filresurser, välj Azure.Storage.Files.Shares. För Azure Storage-hanteringsbiblioteket väljer du Azure.ResourceManager.Storage. För biblioteket Azure Identity, som behövs för lösenordsfria anslutningar, välj Azure.Identity.

    Det här steget installerar paketet och dess beroenden.

Lägga till med hjälp av direktiv

Om du planerar att använda System.IO namnområdet, lägg till följande using-direktiv högst upp i din Program.cs fil:

using System.IO;

Om du planerar att använda File Shares-klientbiblioteket för .NET, lägg till följande using-direktiv högst upp i din Program.cs-fil:

using Azure.Storage.Files.Shares;

Om du planerar att använda Azure Storage-hanteringsbiblioteket för .NET lägger du till följande användningsdirektiv överst i filen Program.cs :

using Azure.ResourceManager;

För att använda Azure Identity-biblioteket för lösenordslösa anslutningar till Azure-tjänster, lägg till följande "using"-direktiv högst upp i din Program.cs-fil.

using Azure.Identity;

Arbeta med Azure Files med System.IO

Standardfil-I/O-bibliotek är det vanligaste sättet att komma åt och arbeta med Azure Files-resurser. När du monterar en fildelning med SMB eller NFS omdirigerar operativsystemet API-begäranden för det lokala filsystemet. Denna metod gör det möjligt för dig att använda standardfilsbibliotek, såsom System.IO, för att interagera med filer och kataloger i delningen.

Överväg att använda System.IO när din app kräver:

  • Appkompatibilitet: Perfekt för företagsapplikationer med befintlig kod som redan använder System.IO. Du behöver inte skriva om kod för att appen ska fungera med en Azure-filresurs.
  • Användarvänlighet:System.IO är välkänt bland utvecklare och lätt att använda. Ett viktigt värdeförslag för Azure Files är att det exponerar interna filsystem-API:er via SMB och NFS.

I det här avsnittet lär du dig hur du använder System.IO för att arbeta med Azure-fileresurser.

Mer information och exempel finns i följande resurser:

Koppla upp en filresurser

För att använda System.IO måste du först montera en fillagring. Se följande resurser för vägledning om hur du monterar en filresurs med SMB eller NFS:

I den här artikeln använder vi följande sökväg för att hänvisa till en monterad SMB-filresurs på Windows:

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

Exempel: Anslut till en fillagring och uppräkna kataloger med hjälp av System.IO

Följande kodexempel visar hur du ansluter till en filresurs och listar katalogerna i resursen:

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

Exempel: Skriv till en fil i en delad filresurs med hjälp av System.IO

Följande kodexempel visar hur du skriver och lägger till text med File klassen:

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

Exempel: Lås en fil i en filresurs med hjälp av System.IO

SMB-klienter som monterar filresurser kan använda låsningsmekanismer för filsystem för att hantera åtkomst till delade filer.

Följande kodexempel visar hur man låser en fil i en filresurs med delningsläge inställt till None. Det här delningsläget avböjer delning av den aktuella filen tills filen är stängd.

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

När du använder både SMB och FileREST-API:et bör du tänka på att FileREST-API:et använder leasar för att hantera fillås, medan SMB använder filsystemlås som hanteras av operativsystemet. Mer information om hur du hanterar fillåsningsinteraktioner mellan SMB och FileREST-API:et finns i Hantera fillås.

Exempel: Räkna upp fil-ACL:er med hjälp av System.IO

I följande kodexempel visas hur du räknar upp åtkomstkontrollistor (ACL:er) för en fil:

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

}

Arbeta med Azure Files-data med hjälp av filresursklientbiblioteket för .NET

FileREST-API:et ger programmatisk åtkomst till Azure Files. Det gör att du kan anropa HTTPS-slutpunkter för att utföra åtgärder på filresurser, kataloger och filer. FileREST-API:et är utformat för hög skalbarhet och avancerade funktioner som kanske inte är tillgängliga via interna protokoll. Azure SDK tillhandahåller klientbibliotek, till exempel filresursklientbiblioteket för .NET, som bygger på FileREST-API:et.

Överväg att använda FileREST-API:et och filresursklientbiblioteket om programmet kräver:

  • Avancerade funktioner: Åtkomståtgärder och funktioner som inte är tillgängliga via interna protokoll.
  • Anpassade molnintegreringar: Skapa anpassade mervärdestjänster, till exempel säkerhetskopiering, antivirus eller datahantering, som interagerar direkt med Azure Files.
  • Prestandaoptimering: Dra nytta av prestandafördelar i storskaliga scenarier med hjälp av dataplansåtgärder.

FileREST API modellerar Azure Files som en resurshierarki och rekommenderas för åtgärder som utförs på katalog- eller filnivå . Du bör föredra REST-API:et för lagringsresursprovidern för åtgärder som utförs på filtjänst- eller filresursnivå .

I det här avsnittet lär du dig hur du använder klientbiblioteket för filresurser för att arbeta med Azure-filer.

Mer information och exempel finns i följande resurser:

Auktorisera åtkomst och skapa en klient

Skapa ett ShareClient objekt för att ansluta en app till Azure Files. Det här objektet är startpunkten för att arbeta med Azure Files-resurser. Följande kodexempel visar hur du skapar ett ShareClient objekt med olika auktoriseringsmekanismer.

För att auktorisera med Microsoft Entra ID behöver du använda en säkerhetsprincipal. Vilken typ av säkerhetsprincip du behöver beror på var din app körs. Använd den här tabellen som en guide.

Var appen körs Säkerhetsprincip Vägledning
Lokal dator (utveckla och testa) Service Principal Information om hur du registrerar appen, konfigurerar en Microsoft Entra-grupp, tilldelar roller och konfigurerar miljövariabler finns i Auktorisera åtkomst med utvecklartjänstens huvudnamn
Lokal dator (utveckla och testa) Användaridentitet Information om hur du konfigurerar en Microsoft Entra-grupp, tilldelar roller och loggar in på Azure finns i Auktorisera åtkomst med autentiseringsuppgifter för utvecklare
Värdhanterad i Azure Hanterad identitet Information om hur du aktiverar hanterad identitet och tilldelar roller finns i Auktorisera åtkomst från Azure-värdbaserade appar med hjälp av en hanterad identitet
Värdhanterad utanför Azure (till exempel lokala appar) Service Principal Information om hur du registrerar appen, tilldelar roller och konfigurerar miljövariabler finns i Auktorisera åtkomst från lokala appar med hjälp av ett huvudnamn för programtjänsten

Om du vill arbeta med kodexemplen i den här artikeln ska du tilldela Azure RBAC:s inbyggda roll Storage File Data Privileged Contributor till säkerhetsobjektet. Den här rollen ger fullständig läs-, skriv-, ändrings-ACL:er och borttagningsåtkomst för alla data i resurserna för alla konfigurerade lagringskonton oavsett vilka NTFS-behörigheter på fil-/katalognivå som har angetts. Mer information finns i Access Azure file shares using Microsoft Entra ID with Azure Files OAuth over REST (Åtkomst till Azure-filresurser med Microsoft Entra-ID med Azure Files OAuth via REST).

Auktorisera åtkomst med defaultAzureCredential

Ett enkelt och säkert sätt att auktorisera åtkomst och ansluta till Azure Files är att hämta en OAuth-token genom att skapa en DefaultAzureCredential-instans . Du kan sedan använda den autentiseringsuppgiften för att skapa ett ShareClient objekt.

I följande exempel skapas ett ShareClient-objekt som har auktoriserats med DefaultAzureCredential, och sedan skapas ett ShareDirectoryClient-objekt för att arbeta med en katalog i resursdelningen.

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

Om du vet exakt vilken typ av autentiseringsuppgifter du använder för att autentisera användare kan du hämta en OAuth-token med hjälp av andra klasser i Azure Identity-klientbiblioteket för .NET. Dessa klasser härleds från klassen TokenCredential .

Mer information om var och en av dessa auktoriseringsmekanismer finns i Välj hur du auktoriserar åtkomst till fildata.

Exempel: Kopiera filer med hjälp av klientbiblioteket för fildelningar

Du kan kopiera filer i en filresurs eller mellan filresurser med hjälp av följande metod:

Du kan kopiera en fil till en målblob med hjälp av följande metod från ett BlobClient objekt:

I följande kodexempel visas hur du kopierar en fil till en fil i en annan filresurs:

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

Exempel: Hyra en fil med hjälp av File Shares klientbiblioteket

Ett lån skapar ett lås på en fil som hanteras av Azure via ett låne-ID. Hyresavtalet ger en mekanism för att samordna åtkomsten till filer mellan flera klienter i ett distribuerat system. Ett lån på en fil ger exklusiv skriv- och borttagningsåtkomst. Mer information om lånetillstånd och åtgärder finns i Lånefil.

I följande kodexempel visas hur du skapar en låneklient, skaffar ett lån med obegränsad varaktighet för en fil och släpper lånet:

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

När du använder både SMB och FileREST-API:et bör du tänka på att FileREST-API:et använder leasar för att hantera fillås, medan SMB använder filsystemlås som hanteras av operativsystemet. Mer information om hur du hanterar fillåsningsinteraktioner mellan SMB och FileREST-API:et finns i Hantera fillås.

Exempel: Skapa och lista ögonblicksbilder med hjälp av klientbiblioteket för fildelningar

Snapshots av delningar är skrivskyddade kopior av en filresurs vid en viss tidpunkt. Du kan skapa en ögonblicksbild av en filresurs och sedan använda ögonblicksbilden för att komma åt data i resursen när ögonblicksbilden skapades. Du kan också lista alla ögonblicksbilder i en fildelning och ta bort ögonblicksbilder av fildelningen.

Följande kodexempel visar hur du skapar en resursögonblicksbild, listar ögonblicksbilderna i en filresurs och passerar katalogträdet i en resursögonblicksbild:

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

Anmärkning

OAuth-token, till exempel de som hämtas när du använder DefaultAzureCredential, är inte tillåtna för dataplansåtgärder på fildelningsnivå. Om du vill arbeta med dela ögonblicksbilder måste klientobjektet auktoriseras med hjälp av kontots nyckel. Objektet ShareClient som skapas i det här kodexemplet använder en anslutningssträng som innehåller kontonyckeln.

Lagring av kontonycklar eller anslutningssträngar utgör en säkerhetsrisk. Du bör bara använda dem när Microsoft Entra-autentisering inte är tillgänglig. Mer information om hur du lagrar kontonycklar på ett säkert sätt i Azure Key Vault finns i Om Azure Key Vault-hanterade lagringskontonycklar.

Hantera Azure Files-resurser med hjälp av Azure Storage-hanteringsbiblioteken

Azure Storage-hanteringsbiblioteken bygger på REST-API:et för Azure Storage-resursprovidern. Azure Storage-resursprovidern är en tjänst baserad på Azure Resource Manager och stöder både deklarativa metoder (mallar) och imperativa metoder (direkt API-anrop). REST-API:n för resursleverantören Azure Storage ger programmatisk åtkomst till Azure Storage-resurser, inklusive fildelningar. Azure SDK tillhandahåller hanteringsbibliotek som bygger på REST-API:et för Azure Storage-resursprovidern.

Hanteringsbiblioteken rekommenderas för åtgärder som utförs på filtjänst- eller filresursnivå . I det här avsnittet får du lära dig hur du använder Azure Storage-hanteringsbiblioteken för att hantera Azure Files-resurser.

Exempel: Skapa en fildelad resurs med hjälp av Azure Storage-hanteringsbiblioteket

I följande kodexempel visas hur du skapar ett top-nivå ArmClient objekt, registrerar lagringsleverantören med en prenumeration och skapar en fildelning med hjälp av Azure Storage-hanteringsbiblioteket:

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;

Du kan konfigurera filresursens egenskaper med klassen FileShareData. Det föregående exemplet visar hur man ställer in egenskapen ShareQuota.

Anmärkning

För att utföra registeråtgärden behöver du behörigheter för följande Azure RBAC-åtgärd: Microsoft.Storage/register/action. Denna behörighet ingår i de inbyggda rollerna Contributor och Owner.

Exempel: Lista fildelningar och ögonblicksbilder med hjälp av Azure Storage-hanteringsbiblioteket

Följande kodexempel visar hur du listar filresurser och ögonblicksbilder i ett lagringskonto:

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

Relaterat innehåll

Mer information om hur du utvecklar med Azure Files finns i följande resurser: