Fejlesztés az Azure Files szolgáltatáshoz a .NET-keretrendszerrel

  • Cikk

Megismerheti az adatok tárolására Azure Files használó .NET-alkalmazások fejlesztésének alapjait. Ez a cikk bemutatja, hogyan hozhat létre egyszerű konzolalkalmazást a .NET és a Azure Files használatához:

  • Fájl tartalmának lekérése.
  • Fájlmegosztás maximális méretének vagy kvótájának beállítása.
  • Közös hozzáférésű jogosultságkód (SAS) létrehozása egy fájlhoz.
  • Fájl másolása másik fájlba egy tárfiókon belül.
  • Fájl másolása blobba egy tárfiókon belül.
  • Pillanatkép létrehozása egy fájlmegosztásról.
  • Fájl visszaállítása megosztási pillanatképből.
  • Hibaelhárításhoz használja az Azure Storage-metrikákat.

A Azure Files kapcsolatos további információkért lásd: Mi az a Azure Files?

Tipp

Az Azure Storage kódmintatár megtekintése

Letölthető és futtatható, könnyen használható teljes körű Azure Storage-kódmintákért tekintse meg az Azure Storage-minták listáját.

A következőre érvényes:

Fájlmegosztás típusa SMB NFS
Standard szintű fájlmegosztások (GPv2), LRS/ZRS Igen Nem
Standard szintű fájlmegosztások (GPv2), GRS/GZRS Igen Nem
Prémium fájlmegosztások (FileStorage), LRS/ZRS Igen No

A .NET API-k ismertetése

Az Azure Files két széleskörű megközelítést nyújt az ügyfélalkalmazásokhoz: az SMB protokollt és a REST-et. A .NET-en belül a és Azure.Storage.Files.Shares az System.IO API-k elvonják ezeket a megközelítéseket.

API A következő esetekben használja Megjegyzések
System.IO Az alkalmazás/alkalmazásnak:
  • Az SMB használatával kell fájlokat olvasni/írni
  • Olyan eszközön fut, amely a 445-ös porton keresztül éri el az Azure Files-fiókot.
  • Nem kell kezelnie a fájlmegosztás rendszergazdai beállításait.
 A Azure Files SMB-en keresztül implementált fájl I/O általában megegyezik az I/O-val bármely hálózati fájlmegosztással vagy helyi tárolóeszközzel. A .NET számos funkciójának , köztük a fájl I/O-jának ismertetését a Konzolalkalmazás oktatóanyagában tekintheti meg.
Azure.Storage.Files.Shares Az alkalmazás/alkalmazásnak:
  • Tűzfal- vagy internetszolgáltatói korlátozások miatt nem lehet hozzáférni a Azure Files az SMB-vel a 445-ös porton
  • Rendszergazdai funkciókat igényel, például a fájlmegosztás kvótájának beállítását vagy közös hozzáférésű jogosultságkód létrehozásának lehetőségét.
 Ez a cikk bemutatja, hogy a fájl I/O-jának Azure.Storage.Files.Shares használata REST-et használ az SMB helyett és a fájlmegosztás kezelését.

A konzolalkalmazás létrehozása és az összeállítás elérése

A Azure Files ügyfélkódtárat bármilyen típusú .NET-alkalmazásban használhatja. Ezek az alkalmazások közé tartoznak az Azure-felhő- és webes, asztali és mobilalkalmazások. Ebben az útmutatóban egy konzolalkalmazást hozunk létre az egyszerűség kedvéért.

Hozzon létre egy új Windows-konzolalkalmazást a Visual Studióban. Az alábbi lépések bemutatják, hogyan hozhat létre konzolalkalmazást a Visual Studio 2019-ben. A lépések a Visual Studio más verziói esetén is hasonlók.

  1. Indítsa el a Visual Studiót, és válassza az Új projekt létrehozása lehetőséget.
  2. Az Új projekt létrehozása területen válassza a C# konzolalkalmazás (.NET-keretrendszer) elemét, majd kattintson a Tovább gombra.
  3. Az Új projekt konfigurálása területen adja meg az alkalmazás nevét, majd válassza a Létrehozás lehetőséget.

Adja hozzá a cikkben szereplő összes példakódot a ProgramProgram.cs fájl osztályához.

A szükséges csomagok telepítése a NuGettel

Tekintse meg ezeket a csomagokat a projektben:

A nuGet használatával beszerezheti a csomagokat. Kövesse az alábbi lépéseket:

  1. A Megoldáskezelő kattintson a jobb gombbal a projektre, és válassza a Manage NuGet Packages (NuGet-csomagok kezelése) lehetőséget.

  2. A NuGet-csomagkezelőben válassza a Tallózás lehetőséget. Ezután keresse meg és válassza az Azure.Core elemet, majd válassza a Telepítés lehetőséget.

    Ez a lépés telepíti a csomagot és annak függőségeit.

  3. Keresse meg és telepítse az alábbi csomagokat:

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

Tárfiók hitelesítő adatainak mentése a App.config fájlba

Ezután mentse a hitelesítő adatait a projekt App.config fájljába. A Megoldáskezelő kattintson App.config duplán, és szerkessze a fájlt úgy, hogy az az alábbi példához hasonló legyen.

Cserélje le myaccount a elemet a tárfiók nevére és mykey a tárfiók kulcsára.

<?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>

Megjegyzés

Az Azurite Storage Emulator jelenleg nem támogatja a Azure Files. A kapcsolati sztring egy azure-tárfiókot kell céloznia a felhőben a Azure Files való együttműködéshez.

Hozzáadás irányelvekkel

A Megoldáskezelő nyissa meg a Program.cs fájlt, és adja hozzá a következő parancsokat a fájl elejéhez.

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;

A fájlmegosztás szoftveres elérése

A Program.cs fájlban adja hozzá az alábbi kódot a fájlmegosztás programozott módon való eléréséhez.

A következő metódus fájlmegosztást hoz létre, ha még nem létezik. A metódus első lépése egy ShareClient-objektum létrehozása egy kapcsolati sztring. A minta ezután megpróbál letölteni egy korábban létrehozott fájlt. Hívja meg ezt a metódust innen: Main().

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

Egy fájlmegosztás maximális méretének beállítása

A Azure Files ügyfélkódtár 5.x verziójától kezdve beállíthatja a fájlmegosztások kvótáját (maximális méretét). Azt is ellenőrizheti, hogy aktuálisan mennyi adatot tárol a fájlmegosztás.

A megosztás kvótájának beállítása korlátozza a megosztáson tárolt fájlok teljes méretét. Ha a megosztáson lévő fájlok teljes mérete meghaladja a kvótát, az ügyfelek nem növelhetik a meglévő fájlok méretét. Az ügyfelek nem hozhatnak létre új fájlokat, kivéve, ha ezek a fájlok üresek.

Az alábbi példa bemutatja, hogyan ellenőrizheti egy megosztás aktuális kihasználását, és hogyan adhat meg hozzá kvótát.

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

Közös hozzáférésű jogosultságkód létrehozása egy fájlhoz vagy fájlmegosztáshoz

A Azure Files ügyfélkódtár 5.x-es verziójától kezdve létrehozhat egy közös hozzáférésű jogosultságkódot (SAS) egy fájlmegosztáshoz vagy egy adott fájlhoz.

Az alábbi példametódus egy SAS-t ad vissza a megadott megosztásban lévő fájlon.

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

A közös hozzáférésű jogosultságkódok létrehozásával és használatával kapcsolatos további információkért lásd: A közös hozzáférésű jogosultságkód működése.

Fájlok másolása

A Azure Files ügyfélkódtár 5.x-es verziójától kezdve egy fájlt átmásolhat egy másik fájlba, egy fájlt egy blobba vagy egy blobot egy fájlba.

Az AzCopy használatával is másolhat egy fájlt egy másikba, vagy blobokat másolhat egy fájlba, vagy fordítva. Lásd: Az AzCopy használatának első lépései.

Megjegyzés

Ha egy blobot másol egy fájlba vagy egy fájlt egy blobba, akkor is közös hozzáférésű jogosultságkóddal (SAS) kell engedélyeznie a forrásobjektumhoz való hozzáférést, ha a másolás tárfiókon belül történik.

Fájl másolása másik fájlba

Az alábbi példa megosztáson belül másol át egy fájlt egy másikba. A megosztott kulcsos hitelesítéssel elvégezheti a másolást, mert ez a művelet fájlokat másol ugyanabban a tárfiókban.

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

Fájl másolása blobba

Az alábbi példa létrehoz egy fájlt, és átmásolja egy ugyanabban a tárfiókban található blobba. A példa létrehoz a forrásfájlhoz egy SAS-t, amellyel a szolgáltatás engedélyezi a forrásfájlhoz való hozzáférést a másolási művelet alatt.

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

Ugyanígy másolhat blobokat fájlokba. Ha a forrásobjektum egy blob, hozzon létre egy SAS-t, amely engedélyezi a blobhoz való hozzáférést a másolási művelet során.

Pillanatképek megosztása

A Azure Files ügyfélkódtár 8.5-ös verziójától kezdve létrehozhat megosztási pillanatképet. Ezekből felsorolást is készíthet, tallózhat köztük, és törölheti is a megosztási pillanatképeket. A létrehozás után a megosztási pillanatképek írásvédettek.

Megosztási pillanatképek létrehozása

Az alábbi példával létrehozhat egy fájlmegosztási pillanatképet.

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

Megosztási pillanatképek felsorolása

Az alábbi példa egy megosztás pillanatképeit sorolja fel.

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

Fájlok és könyvtárak listázása megosztási pillanatképeken belül

Az alábbi példa a megosztási pillanatképeken belüli fájlokat és könyvtárakat böngészi.

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

Fájlmegosztások vagy fájlok visszaállítása megosztási pillanatképekből

A fájlmegosztások pillanatképének készítése lehetővé teszi az egyes fájlok vagy a teljes fájlmegosztás helyreállítását.

A fájlmegosztási pillanatképekből a fájlok a pillanatkép lekérdezésével állíthatók vissza. Ezután lekérhet egy adott megosztási pillanatképhez tartozó fájlt. Ezzel a verzióval közvetlenül olvashatja vagy állíthatja vissza a fájlt.

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

Megosztási pillanatképek törlése

Az alábbi példával törölhet egy fájlmegosztási pillanatképet.

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

Azure Files hibaelhárítása metrikák használatával

Az Azure Storage Analytics támogatja a Azure Files metrikáit. A metrikai adatok segítségével nyomon követheti a kéréseket, és diagnosztizálhatja a problémákat.

A metrikákat a Azure Portal Azure Files engedélyezheti. A metrikákat programozott módon is engedélyezheti, ha meghívja a Fájlszolgáltatás tulajdonságainak beállítása műveletet a REST API-val vagy annak egyik analógjával a Azure Files ügyfélkódtárban.

Az alábbi példakód bemutatja, hogyan engedélyezheti a metrikákat a .NET-ügyfélkódtár használatával Azure Files.

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

Ha problémákat tapasztal, tekintse meg a Azure Files hibaelhárítását ismertető cikket.

Következő lépések

A Azure Files kapcsolatos további információkért tekintse meg az alábbi forrásanyagokat:

Elméleti cikkek és videók

File Storage-eszköztámogatás

Referencia

Az elavult .NET-verziójú 11.x SDK-kkal kapcsolatos kódmintákért lásd: Kódminták a .NET 11.x-es verziójával.