Archiviare e accedere ai dati in Archiviazione di Azure daXamarin.Forms

Scaricare l'esempio

Archiviazione di Azure è una soluzione di archiviazione cloud scalabile che può essere usata per archiviare dati non strutturati e strutturati. Questo articolo illustra come usare Xamarin.Forms per archiviare dati di testo e binari in Archiviazione di Azure e come accedere ai dati.

Archiviazione di Azure offre quattro servizi di archiviazione:

• Archiviazione BLOB. Un BLOB può essere di tipo testo o binario, ad esempio backup, macchine virtuali, file multimediali o documenti.
• La tabella Archiviazione è un archivio di attributi chiave NoSQL.
• Queue Archiviazione è un servizio di messaggistica per l'elaborazione e la comunicazione del flusso di lavoro tra i servizi cloud.
• L'Archiviazione file fornisce l'archiviazione condivisa usando il protocollo SMB.

Sono disponibili due tipi di account di archiviazione:

• Un account di archiviazione per utilizzo generico consente di accedere ai servizi di Archiviazione di Azure da un singolo account.
• Un account di archiviazione BLOB è un account di archiviazione specializzato per l'archiviazione di BLOB. Questo tipo di account è consigliato quando è sufficiente archiviare i dati BLOB.

Questo articolo e l'applicazione di esempio associata illustra il caricamento di file di immagine e di testo nell'archiviazione BLOB e il download. Inoltre, illustra anche il recupero di un elenco di file dall'archivio BLOB e l'eliminazione di file.

Per altre informazioni sulle Archiviazione di Azure, vedere Introduzione alle Archiviazione.

Nota

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Introduzione all'Archiviazione BLOB

L'archiviazione BLOB è costituita da tre componenti, illustrati nel diagramma seguente:

Tutti gli accessi a Archiviazione di Azure sono tramite un account di archiviazione. Un account di archiviazione può contenere un numero illimitato di contenitori e un contenitore può archiviare un numero illimitato di BLOB, fino al limite di capacità dell'account di archiviazione.

Un BLOB è un file di qualsiasi tipo e dimensione. Archiviazione di Azure supporta tre tipi di BLOB diversi:

• I BLOB in blocchi sono ottimizzati per lo streaming e l'archiviazione di oggetti cloud e sono una buona scelta per l'archiviazione di backup, file multimediali, documenti e così via. I BLOB in blocchi possono avere dimensioni fino a 195 GB.
• I BLOB di accodamento sono simili ai BLOB in blocchi, ma sono ottimizzati per le operazioni di accodamento, ad esempio la registrazione. I BLOB di accodamento possono avere dimensioni fino a 195 GB.
• I BLOB di pagine sono ottimizzati per operazioni di lettura/scrittura frequenti e vengono in genere usati per archiviare le macchine virtuali e i relativi dischi. I BLOB di pagine possono avere dimensioni fino a 1 Tb.

Nota

Si noti che gli account di archiviazione BLOB supportano BLOB in blocchi e accodamenti, ma non BLOB di pagine.

Un BLOB viene caricato in Archiviazione di Azure e scaricato da Archiviazione di Azure, come flusso di byte. Pertanto, i file devono essere convertiti in un flusso di byte prima del caricamento e riconvertita nella relativa rappresentazione originale dopo il download.

Ogni oggetto archiviato in Archiviazione di Azure ha un indirizzo URL univoco. Il nome dell'account di archiviazione costituisce il sottodominio di tale indirizzo e la combinazione di sottodominio e nome di dominio costituisce un endpoint per l'account di archiviazione. Ad esempio, se l'account di archiviazione è denominato mystorageaccount, l'endpoint BLOB predefinito per l'account di archiviazione è https://mystorageaccount.blob.core.windows.net.

L'URL per accedere a un oggetto in un account di archiviazione viene formato aggiungendo la posizione dell'oggetto nell'account di archiviazione all'endpoint. Ad esempio, un indirizzo BLOB avrà il formato https://mystorageaccount.blob.core.windows.net/mycontainer/myblob.

Attrezzaggio

Il processo di integrazione di un account Archiviazione di Azure in un'applicazione Xamarin.Forms è il seguente:

1. Creare un account di archiviazione. Per altre informazioni, vedere Creare un account di archiviazione.
2. Aggiungere la libreria client Archiviazione di Azure all'applicazioneXamarin.Forms.
3. Configurare il stringa di connessione di archiviazione. Per altre informazioni, vedere Connessione ing to Archiviazione di Azure.
4. Aggiungere using direttive per gli spazi dei Microsoft.WindowsAzure.Storage nomi e Microsoft.WindowsAzure.Storage.Blob alle classi che accederanno Archiviazione di Azure.

Connessione ad Archiviazione di Azure

Ogni richiesta eseguita sulle risorse dell'account di archiviazione deve essere autenticata. Anche se i BLOB possono essere configurati per supportare l'autenticazione anonima, esistono due approcci principali che un'applicazione può usare per l'autenticazione con un account di archiviazione:

• Chiave condivisa. Questo approccio usa il nome dell'account Archiviazione di Azure e la chiave dell'account per accedere ai servizi di archiviazione. Alla creazione di un account di archiviazione vengono assegnate due chiavi private che possono essere usate per l'autenticazione con chiave condivisa.
• Firma di accesso condiviso. Si tratta di un token che può essere aggiunto a un URL che consente l'accesso delegato a una risorsa di archiviazione, con le autorizzazioni specificate, per il periodo di tempo in cui è valido.

è possibile specificare le stringhe di Connessione ion che includono le informazioni di autenticazione necessarie per accedere alle risorse Archiviazione di Azure da un'applicazione. Inoltre, un stringa di connessione può essere configurato per connettersi all'emulatore di archiviazione di Azure da Visual Studio.

Nota

Archiviazione di Azure supporta HTTP e HTTPS in un stringa di connessione. È tuttavia consigliabile usare HTTPS.

Connessione all'emulatore di Archiviazione di Azure

L'emulatore di archiviazione di Azure fornisce un ambiente locale che emula i servizi BLOB, code e tabelle di Azure a scopo di sviluppo.

Per connettersi all'emulatore di archiviazione di Azure, è necessario usare il stringa di connessione seguente:

UseDevelopmentStorage=true

Per altre informazioni sull'emulatore di archiviazione di Azure, vedere Usare l'emulatore di archiviazione di Azure per sviluppo e test.

Connessione di Archiviazione di Azure tramite una chiave condivisa

Il formato di stringa di connessione seguente deve essere usato per connettersi a Archiviazione di Azure con una chiave condivisa:

DefaultEndpointsProtocol=[http|https];AccountName=myAccountName;AccountKey=myAccountKey

myAccountName deve essere sostituito con il nome dell'account di archiviazione e myAccountKey deve essere sostituito con una delle due chiavi di accesso dell'account.

Nota

Quando si usa l'autenticazione con chiave condivisa, il nome dell'account e la chiave dell'account verranno distribuiti a ogni persona che usa l'applicazione, che fornirà l'accesso in lettura/scrittura completo all'account di archiviazione. Pertanto, usare l'autenticazione con chiave condivisa solo a scopo di test e non distribuire mai chiavi ad altri utenti.

Connessione di Archiviazione di Azure tramite una firma di accesso condiviso

Il formato di stringa di connessione seguente deve essere usato per connettersi a Archiviazione di Azure con una firma di accesso condiviso:

BlobEndpoint=myBlobEndpoint;SharedAccessSignature=mySharedAccessSignature

myBlobEndpoint deve essere sostituito con l'URL dell'endpoint BLOB e mySharedAccessSignature deve essere sostituito con la firma di accesso condiviso. La firma di accesso condiviso fornisce il protocollo, l'endpoint del servizio e le credenziali per accedere alla risorsa.

Nota

L'autenticazione sas è consigliata per le applicazioni di produzione. Tuttavia, in un'applicazione di produzione la firma di accesso condiviso deve essere recuperata da un servizio back-end su richiesta, anziché essere in bundle con l'applicazione.

Per altre informazioni sulle firme di accesso condiviso, vedere Uso delle firme di accesso condiviso.

Creazione di un contenitore

Il GetContainer metodo viene usato per recuperare un riferimento a un contenitore denominato, che può quindi essere usato per recuperare i BLOB dal contenitore o per aggiungere BLOB al contenitore. L'esempio di codice seguente illustra il metodo GetContainer:

static CloudBlobContainer GetContainer(ContainerType containerType)
{
  var account = CloudStorageAccount.Parse(Constants.StorageConnection);
  var client = account.CreateCloudBlobClient();
  return client.GetContainerReference(containerType.ToString().ToLower());
}

Il CloudStorageAccount.Parse metodo analizza un stringa di connessione e restituisce un'istanza CloudStorageAccount che rappresenta l'account di archiviazione. Un'istanza CloudBlobClient , usata per recuperare contenitori e BLOB, viene quindi creata dal CreateCloudBlobClient metodo . Il GetContainerReference metodo recupera il contenitore specificato come CloudBlobContainer istanza, prima che venga restituito al metodo chiamante. In questo esempio, il nome del contenitore è il ContainerType valore di enumerazione, convertito in una stringa minuscola.

Nota

I nomi dei contenitori devono essere minuscoli e devono iniziare con una lettera o un numero. Inoltre, possono contenere solo lettere, numeri e il carattere trattino e devono avere una lunghezza compresa tra 3 e 63 caratteri.

Il GetContainer metodo viene richiamato come segue:

var container = GetContainer(containerType);

L'istanza CloudBlobContainer può quindi essere usata per creare un contenitore se non esiste già:

await container.CreateIfNotExistsAsync();

Per impostazione predefinita, un contenitore appena creato è privato. Ciò significa che è necessario specificare una chiave di accesso all'archiviazione per recuperare i BLOB dal contenitore. Per informazioni sulla creazione di BLOB all'interno di un contenitore pubblico, vedere Creare un contenitore.

Caricamento di dati in un contenitore

Il UploadFileAsync metodo viene usato per caricare un flusso di dati di byte nell'archivio BLOB ed è illustrato nell'esempio di codice seguente:

public static async Task<string> UploadFileAsync(ContainerType containerType, Stream stream)
{
  var container = GetContainer(containerType);
  await container.CreateIfNotExistsAsync();

  var name = Guid.NewGuid().ToString();
  var fileBlob = container.GetBlockBlobReference(name);
  await fileBlob.UploadFromStreamAsync(stream);

  return name;
}

Dopo aver recuperato un riferimento al contenitore, il metodo crea il contenitore, se non esiste già. Viene quindi creato un nuovo Guid oggetto per fungere da nome BLOB univoco e un riferimento a blocchi BLOB viene recuperato come CloudBlockBlob istanza. Il flusso di dati viene quindi caricato nel BLOB usando il UploadFromStreamAsync metodo , che crea il BLOB se non esiste già o lo sovrascrive se esiste.

Prima che un file possa essere caricato nell'archivio BLOB usando questo metodo, deve essere convertito in un flusso di byte. Questo esempio di codice è illustrato nell'esempio di codice seguente:

var byteData = Encoding.UTF8.GetBytes(text);
uploadedFilename = await AzureStorage.UploadFileAsync(ContainerType.Text, new MemoryStream(byteData));

I text dati vengono convertiti in una matrice di byte, che viene quindi sottoposta a wrapping come flusso passato al UploadFileAsync metodo .

Download di dati da un contenitore

Il GetFileAsync metodo viene usato per scaricare i dati BLOB da Archiviazione di Azure ed è illustrato nell'esempio di codice seguente:

public static async Task<byte[]> GetFileAsync(ContainerType containerType, string name)
{
  var container = GetContainer(containerType);

  var blob = container.GetBlobReference(name);
  if (await blob.ExistsAsync())
  {
    await blob.FetchAttributesAsync();
    byte[] blobBytes = new byte[blob.Properties.Length];

    await blob.DownloadToByteArrayAsync(blobBytes, 0);
    return blobBytes;
  }
  return null;
}

Dopo aver recuperato un riferimento al contenitore, il metodo recupera un riferimento BLOB per i dati archiviati. Se il BLOB esiste, le relative proprietà vengono recuperate dal FetchAttributesAsync metodo . Viene creata una matrice di byte delle dimensioni corrette e il BLOB viene scaricato come matrice di byte restituiti al metodo chiamante.

Dopo aver scaricato i dati dei byte BLOB, è necessario convertirli nella relativa rappresentazione originale. Questo esempio di codice è illustrato nell'esempio di codice seguente:

var byteData = await AzureStorage.GetFileAsync(ContainerType.Text, uploadedFilename);
string text = Encoding.UTF8.GetString(byteData);

La matrice di byte viene recuperata da Archiviazione di Azure dal GetFileAsync metodo , prima che venga convertita nuovamente in una stringa con codifica UTF8.

Elenco dei dati in un contenitore

Il GetFilesListAsync metodo viene usato per recuperare un elenco di BLOB archiviati in un contenitore ed è illustrato nell'esempio di codice seguente:

public static async Task<IList<string>> GetFilesListAsync(ContainerType containerType)
{
  var container = GetContainer(containerType);

  var allBlobsList = new List<string>();
  BlobContinuationToken token = null;

  do
  {
    var result = await container.ListBlobsSegmentedAsync(token);
    if (result.Results.Count() > 0)
    {
      var blobs = result.Results.Cast<CloudBlockBlob>().Select(b => b.Name);
      allBlobsList.AddRange(blobs);
    }
    token = result.ContinuationToken;
  } while (token != null);

  return allBlobsList;
}

Dopo aver recuperato un riferimento al contenitore, il metodo usa il metodo del ListBlobsSegmentedAsync contenitore per recuperare i riferimenti ai BLOB all'interno del contenitore. I risultati restituiti dal ListBlobsSegmentedAsync metodo vengono enumerati mentre l'istanza BlobContinuationToken non nullè . Ogni BLOB viene sottoposto a cast dall'oggetto restituito IListBlobItem a un CloudBlockBlob oggetto per accedere alla Name proprietà del BLOB, prima che venga aggiunto il valore alla allBlobsList raccolta. Dopo che l'istanza BlobContinuationToken è null, è stato restituito l'ultimo nome del BLOB e l'esecuzione esce dal ciclo.

Eliminazione di dati da un contenitore

Il DeleteFileAsync metodo viene usato per eliminare un BLOB da un contenitore ed è illustrato nell'esempio di codice seguente:

public static async Task<bool> DeleteFileAsync(ContainerType containerType, string name)
{
  var container = GetContainer(containerType);
  var blob = container.GetBlobReference(name);
  return await blob.DeleteIfExistsAsync();
}

Dopo aver recuperato un riferimento al contenitore, il metodo recupera un riferimento BLOB per il BLOB specificato. Il BLOB viene quindi eliminato con il DeleteIfExistsAsync metodo .

Collegamenti correlati

• Archiviazione di Azure (esempio)
• Introduzione alle Archiviazione.
• Come usare Archiviazione BLOB da Xamarin
• Uso delle firme di accesso condiviso
• Windows Archiviazione di Azure (NuGet)