Desarrollo para Azure Files con .NETDevelop for Azure Files with .NET

Aprenda los conceptos básicos de desarrollar aplicaciones .NET que usen Azure Files para almacenar datos.Learn the basics of developing .NET applications that use Azure Files to store data. En este artículo se muestra cómo crear una aplicación de consola simple para hacer lo siguiente con .NET y Azure Files:This article shows how to create a simple console application to do the following with .NET and Azure Files:

  • Obtenga el contenido de un archivo.Get the contents of a file.
  • Establezca la cuota o tamaño máximo para un recurso compartido de archivos.Set the maximum size, or quota, for a file share.
  • Cree una firma de acceso compartido (SAS) para un archivo.Create a shared access signature (SAS) for a file.
  • Copie un archivo en otro en la misma cuenta de almacenamiento.Copy a file to another file in the same storage account.
  • Copie un archivo en un blob en la misma cuenta de almacenamiento.Copy a file to a blob in the same storage account.
  • Cree una instantánea de un recurso compartido de archivos.Create a snapshot of a file share.
  • Restaure un archivo desde una instantánea de recurso compartido.Restore a file from a share snapshot.
  • Use las métricas de Azure Storage para solucionar problemas.Use Azure Storage Metrics for troubleshooting.

Para obtener más información acerca de Azure Files, consulte ¿Qué es Azure Files?.To learn more about Azure Files, see What is Azure Files?

Sugerencia

Extraer del repositorio ejemplos de código de Azure StorageCheck out the Azure Storage code samples repository

Para encontrar ejemplos de código de Azure Storage de un extremo a otro y fáciles de usar que se pueden descargar y ejecutar, consulte nuestra lista de ejemplos de Azure Storage.For easy-to-use end-to-end Azure Storage code samples that you can download and run, please check out our list of Azure Storage Samples.

Descripción de las API de .NETUnderstanding the .NET APIs

Azure Files proporciona dos enfoques generales para las aplicaciones cliente: bloque de mensajes del servidor (SMB) y REST.Azure Files provides two broad approaches to client applications: Server Message Block (SMB) and REST. Dentro de. NET, las API System.IO y Azure.Storage.Files.Shares extraen estos métodos.Within .NET, the System.IO and Azure.Storage.Files.Shares APIs abstract these approaches.

APIAPI Cuándo se usaWhen to use NotasNotes
System.IOSystem.IO Su aplicación:Your application:
  • Es necesario leer o escribir archivos mediante SMBNeeds to read/write files by using SMB
  • Se ejecuta en un dispositivo que tenga acceso a través del puerto 445 a su cuenta de Azure FilesIs running on a device that has access over port 445 to your Azure Files account
  • No es necesario administrar cualquiera de las opciones administrativas del recurso compartido de archivosDoesn't need to manage any of the administrative settings of the file share
La E/S de archivos de Azure Files a través de SMB normalmente es igual que la E/S con cualquier recurso compartido de red o dispositivo de almacenamiento local.File I/O implemented with Azure Files over SMB is generally the same as I/O with any network file share or local storage device. Para obtener una introducción a una serie de características en .NET, incluida la E/S de archivos, consulte Aplicación de consola.For an introduction to a number of features in .NET, including file I/O, see the Console Application tutorial.
Azure.Storage.Files.SharesAzure.Storage.Files.Shares Su aplicación:Your application:
  • No se puede tener acceso a Azure Files mediante SMB en el puerto 445 debido a restricciones de ISP o firewallCan't access Azure Files by using SMB on port 445 because of firewall or ISP constraints
  • Requiere funcionalidad administrativa, como la capacidad de establecer la cuota de un recurso compartido de archivo o crear una firma de acceso compartidoRequires administrative functionality, such as the ability to set a file share's quota or create a shared access signature
Este artículo muestra el uso de Azure.Storage.Files.Shares para la E/S de archivos con REST (en lugar de SMB) y la administración del recurso compartido de archivos.This article demonstrates the use of Azure.Storage.Files.Shares for file I/O using REST instead of SMB and management of the file share.

Creación de la aplicación de consola y obtención del ensambladoCreate the console application and obtain the assembly

Puede usar la biblioteca cliente de Azure Files en cualquier tipo de aplicación .NET.You can use the Azure Files client library in any type of .NET app. Estas aplicaciones incluyen la nube de Azure, la Web, el escritorio y aplicaciones móviles.These apps include Azure cloud, web, desktop, and mobile apps. En esta guía, creamos una aplicación de consola para hacerlo más sencillo.In this guide, we create a console application for simplicity.

En Visual Studio, cree una nueva aplicación de consola de Windows.In Visual Studio, create a new Windows console application. Los siguientes pasos muestran cómo crear una aplicación de consola en Visual Studio 2019.The following steps show you how to create a console application in Visual Studio 2019. Los pasos son similares en otras versiones de Visual Studio.The steps are similar in other versions of Visual Studio.

  1. Inicie Visual Studio y seleccione Crear un proyecto .Start Visual Studio and select Create a new project .
  2. En Crear un proyecto , elija Aplicación de consola (.NET Framework) para C# y seleccione Siguiente .In Create a new project , choose Console App (.NET Framework) for C#, and then select Next .
  3. En Configure su nuevo proyecto , escriba un nombre para la app y seleccione Crear .In Configure your new project , enter a name for the app, and select Create .

Agregue todos los ejemplos de código en este artículo a la clase Program en el archivo Program.cs .Add all the code examples in this article to the Program class in the Program.cs file.

Uso de NuGet para instalar los paquetes necesariosUse NuGet to install the required packages

Consulte estos paquetes en el proyecto:Refer to these packages in your project:

Puede usar NuGet para obtener los paquetes.You can use NuGet to obtain the packages. Siga estos pasos:Follow these steps:

  1. En el Explorador de soluciones , haga clic con el botón derecho en el proyecto y seleccione Administrar paquetes de NuGet .In Solution Explorer , right-click your project and choose Manage NuGet Packages .

  2. En Administrador de paquetes NuGet , seleccione Examinar .In NuGet Package Manager , select Browse . A continuación, busque y elija Azure.Core , y, después, seleccione Instalar .Then search for and choose Azure.Core , and then select Install .

    En este paso se instala el paquete y sus dependencias.This step installs the package and its dependencies.

  3. Busque e instale estos paquetes:Search for and install these packages:

    • Azure.Storage.BlobsAzure.Storage.Blobs
    • Azure.Storage.Files.SharesAzure.Storage.Files.Shares
    • System.Configuration.ConfigurationManagerSystem.Configuration.ConfigurationManager

Guardar las credenciales de la cuenta de almacenamiento en el archivo app.configSave your storage account credentials to the App.config file

A continuación, guardará las credenciales en el archivo App.config del proyecto.Next, save your credentials in your project's App.config file. En el Explorador de soluciones , haga doble clic en App.config y edite el archivo para que sea similar al ejemplo siguiente.In Solution Explorer , double-click App.config and edit the file so that it is similar to the following example.

Reemplace myaccount por el nombre de la cuenta de almacenamiento y mykey por la clave de la cuenta de almacenamiento.Replace myaccount with your storage account name and mykey with your storage account key.

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

Nota

El emulador de almacenamiento de Azurite no admite Azure Files actualmente. La cadena de conexión debe hacer referencia a una cuenta de Azure Storage en la nube para trabajar con Azure Files.Your connection string must target an Azure storage account in the cloud to work with Azure Files.

Adición de directivas usingAdd using directives

En el Explorador de soluciones , abra el archivo Program.cs y agregue lo siguiente mediante directivas al principio del archivo.In Solution Explorer , open the Program.cs file, and add the following using directives to the top of the file.

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;

Obtener acceso al recurso compartido de archivos mediante programaciónAccess the file share programmatically

En el archivo Program.cs , agregue el código siguiente para obtener acceso al recurso compartido de archivos mediante programación.In the Program.cs file, add the following code to access the file share programmatically.

El método siguiente crea un recurso compartido de archivos si aún no existe.The following method creates a file share if it doesn't already exist. El método se inicia creando un objeto ShareClient a partir de una cadena de conexión.The method starts by creating a ShareClient object from a connection string. A continuación, en el ejemplo se intenta descargar un archivo que creamos anteriormente.The sample then attempts to download a file we created earlier. Llame a este método desde Main().Call this method from 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");
    }
}

Establecer el tamaño máximo para un recurso compartido de archivosSet the maximum size for a file share

A partir de la versión 5.x de la biblioteca cliente de Azure Files, se puede establecer la cuota (tamaño máximo) de un recurso compartido de archivos.Beginning with version 5.x of the Azure Files client library, you can set the quota (maximum size) for a file share. También puede comprobar cuántos datos se almacenan actualmente en el recurso compartido.You can also check to see how much data is currently stored on the share.

Al establecer la cuota para un recurso compartido, se limita el tamaño total de los archivos almacenados en el recurso compartido.Setting the quota for a share limits the total size of the files stored on the share. Si el tamaño total de los archivos del recurso compartido supera la cuota, los clientes no pueden aumentar el tamaño de los archivos existentes.If the total size of files on the share exceeds the quota, clients can't increase the size of existing files. Los clientes tampoco pueden crear archivos nuevos, a menos que estén vacíos.Clients also can't create new files, unless those files are empty.

En el ejemplo siguiente se muestra cómo comprobar el uso actual de un recurso compartido y cómo establecer la cuota para el recurso compartido.The example below shows how to check the current usage for a share and how to set the quota for the share.

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

Generar una firma de acceso compartido para un archivo o recurso compartido de archivosGenerate a shared access signature for a file or file share

A partir de la versión 5.x de la biblioteca cliente de Azure Files, puede generar una firma de acceso compartido (SAS) para un recurso compartido de archivos o para un archivo individual.Beginning with version 5.x of the Azure Files client library, you can generate a shared access signature (SAS) for a file share or for an individual file.

El método de ejemplo siguiente devuelve una SAS en un archivo del recurso compartido especificado.The following example method returns a SAS on a file in the specified share.

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

Para más información sobre la creación y el uso de firmas de acceso compartido, consulte Funcionamiento de una firma de acceso compartido.For more information about creating and using shared access signatures, see How a shared access signature works.

Copiar archivosCopy files

A partir de la versión 5.x de la biblioteca cliente de Azure Files, puede copiar un archivo en otro, un archivo en un blob o un blob en un archivo.Beginning with version 5.x of the Azure Files client library, you can copy a file to another file, a file to a blob, or a blob to a file.

También puede usar AzCopy para copiar un archivo en otro o para copiar un blob en un archivo o viceversa.You can also use AzCopy to copy one file to another or to copy a blob to a file or the other way around. Consulte Introducción a AzCopy.See Get started with AzCopy.

Nota

Si va a copiar un blob en un archivo o un archivo en un blob, debe usar una firma de acceso compartido (SAS) para autorizar el acceso al objeto de origen, incluso si está copiando en la misma cuenta de almacenamiento.If you are copying a blob to a file, or a file to a blob, you must use a shared access signature (SAS) to authorize access to the source object, even if you are copying within the same storage account.

Copiar un archivo en otroCopy a file to another file

En el ejemplo siguiente se copia un archivo en otro en el mismo recurso compartido.The following example copies a file to another file in the same share. Puede usar la autenticación de clave compartida para realizar la copia porque en esta operación se copian archivos de la misma cuenta de almacenamiento.You can use Shared Key authentication to do the copy because this operation copies files within the same storage account.

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

Copiar un archivo en un blobCopy a file to a blob

En el ejemplo siguiente se crea un archivo y se copia en un blob de la misma cuenta de almacenamiento.The following example creates a file and copies it to a blob within the same storage account. El ejemplo crea una SAS para el archivo de origen, que el servicio usa para autorizar el acceso al archivo de origen durante la operación de copia.The example creates a SAS for the source file, which the service uses to authorize access to the source file during the copy operation.

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

Puede copiar un blob en un archivo de la misma manera.You can copy a blob to a file in the same way. Si el objeto de origen es un blob, cree una SAS para autorizar el acceso a dicho blob durante la operación de copia.If the source object is a blob, then create a SAS to authorize access to that blob during the copy operation.

Instantáneas de recursos compartidoShare snapshots

A partir de la versión 8.5 de la biblioteca cliente de Azure Files, se puede crear una instantánea de recurso compartido.Beginning with version 8.5 of the Azure Files client library, you can create a share snapshot. Las instantáneas de recursos compartidos también se pueden enumerar, explorar y eliminar.You can also list or browse share snapshots and delete share snapshots. Una vez creadas, las instantáneas de recursos compartidos son de solo lectura.Once created, share snapshots are read-only.

Creación de instantáneas de recurso compartidoCreate share snapshots

En el siguiente ejemplo se crea una instantánea de recurso compartido.The following example creates a file share snapshot.

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

Enumerar instantáneas del recurso compartidoList share snapshots

En el ejemplo siguiente se enumeran las instantáneas de un recurso compartido.The following example lists the snapshots on a share.

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

Enumeración de archivos y directorios en instantáneas de recursos compartidosList files and directories within share snapshots

En el ejemplo siguiente se examinan los archivos y directorios de instantáneas de recursos compartidos.The following example browses files and directories within share snapshots.

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

Restauración de recursos compartidos de archivos o archivos desde instantáneas de recursos compartidosRestore file shares or files from share snapshots

La toma de una instantánea de un recurso compartido de archivos permite recuperar archivos individuales o todo el recurso compartido de archivos.Taking a snapshot of a file share enables you to recover individual files or the entire file share.

Para restaurar un archivo de una instantánea del recurso compartido de archivos, consulte las instantáneas de recursos compartidos de un recurso compartido de archivos.You can restore a file from a file share snapshot by querying the share snapshots of a file share. Después, puede recuperar un archivo que pertenezca a una instantánea de recurso compartido determinada.You can then retrieve a file that belongs to a particular share snapshot. Use esa versión para leer directamente el archivo o restaurarlo.Use that version to directly read or to restore the file.

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

Eliminación de instantáneas de recursos compartidosDelete share snapshots

En el siguiente ejemplo se elimina una instantánea de recurso compartido.The following example deletes a file share snapshot.

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

Solución de problemas de Azure Files mediante métricasTroubleshoot Azure Files by using metrics

Azure Storage Analytics admite métricas para Azure Files.Azure Storage Analytics supports metrics for Azure Files. Con los datos de las métricas, es posible seguir paso a paso las solicitudes y diagnosticar problemas.With metrics data, you can trace requests and diagnose issues.

Puede habilitar las métricas para Azure Files mediante Azure Portal.You can enable metrics for Azure Files from the Azure portal. La métrica también se puede habilitar mediante programación. Para ello, hay que llamar a la operación Set File Service Properties con la API de REST o una de sus análogas de la biblioteca cliente de Azure Files.You can also enable metrics programmatically by calling the Set File Service Properties operation with the REST API or one of its analogs in the Azure Files client library.

En el siguiente ejemplo de código se muestra cómo usar la biblioteca cliente de .NET a fin de habilitar las métricas para Azure Files.The following code example shows how to use the .NET client library to enable metrics for 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();
}

Si encuentra algún problema, puede consultar Solución de problemas de Azure Files en Windows.If you encounter any problems, you can refer to Troubleshoot Azure Files problems in Windows.

Pasos siguientesNext steps

Para más información acerca de Azure Files, consulte los siguientes recursos:For more information about Azure Files, see the following resources:

Artículos y vídeos conceptualesConceptual articles and videos

Compatibilidad de herramientas con el almacenamiento de archivosTooling support for File storage

ReferenciaReference