Come usare l'archiviazione BLOB da Xamarin

Panoramica

Xamarin consente agli sviluppatori di utilizzare una base di codici C# condivisa per creare applicazioni per Windows Store, iOS e Android con le proprie interfacce utente native. Questa esercitazione illustra come usare l'archiviazione BLOB di Azure con un'applicazione per Xamarin. Per maggiori informazioni su Archiviazione di Azure, prima di approfondire il codice, vedere Introduzione ad Archiviazione di Microsoft Azure.

Creare un account di archiviazione di Azure

Il modo più semplice per creare il primo account di archiviazione di Azure consiste nell'usare il portale di Azure. Per altre informazioni, vedere Creare un account di archiviazione.

È anche possibile creare un account di archiviazione di Azure usando Azure PowerShell, l'interfaccia della riga di comando di Azure o la libreria client del provider di risorse di archiviazione per .NET.

Se si preferisce non creare un account di archiviazione in questa fase, è anche possibile usare l'emulatore di archiviazione di Azure per eseguire e testare il codice in un ambiente locale. Per altre informazioni, vedere Usare l'emulatore di archiviazione di Azure per sviluppo e test.

Configurare l'applicazione per l'accesso all'archiviazione di Azure

Per autenticare l'applicazione per accedere ai servizi di archiviazione, è possibile procedere in due modi:

  • Chiave condivisa: usare la Chiave condivisa solo a scopo di test
  • Firma di accesso condiviso: usare la firma di accesso condiviso per le applicazioni per la produzione

Chiave condivisa

L'autenticazione con la chiave condivisa implica che l'applicazione userà il nome account e la chiave dell'account per accedere ai servizi di archiviazione. Per mostrare rapidamente come usare questa libreria, in questa guida introduttiva verrà usata l'autenticazione con la chiave condivisa.

Avviso

Per scopi di test, usare solo l'autenticazione con chiave condivisa. Il nome account e la chiave dell'account, che concedono l'accesso completo in lettura/scrittura all'account di archiviazione associato, verranno distribuiti a ogni persona che scarica l'app. Questa procedura non è consigliabile perché si rischia che la chiave venga compromessa da client non attendibili.

Quando si usa l'autenticazione con la chiave condivisa, si creerà una stringa di connessione. La stringa di connessione è costituita da:

  • DefaultEndpointsProtocol : è possibile scegliere HTTP o HTTPS. Tuttavia, è vivamente consigliato l'uso di HTTPS.
  • Nome account : nome dell'account di archiviazione
  • Chiave account: se si usa il portale di Azure, passare all'account di archiviazione e fare clic sull'icona delle chiavi per trovare queste informazioni.
  • (Facoltativo) EndpointSuffix : usata per i servizi di archiviazione in aree con suffissi dell'endpoint diversi, ad esempio per Azure China o Azure Governance.

Ecco un esempio di stringa di connessione che usa l'autenticazione con la chiave condivisa:

"DefaultEndpointsProtocol=https;AccountName=your_account_name_here;AccountKey=your_account_key_here"

Firme di accesso condiviso

Per un'applicazione mobile, il metodo consigliato per autenticare una richiesta da parte di un client in base al servizio di archiviazione di Azure è di usare una firma di accesso condiviso. La firma di accesso condiviso consente di concedere a un client l'accesso a una risorsa per un periodo di tempo specificato, con un set di autorizzazioni specificato. Il proprietario dell'account di archiviazione dovrà generare una firma di accesso condiviso che verrà usata dai client mobili. Per generare la firma di accesso condiviso da distribuire ai client, è possibile che si voglia scrivere un apposito servizio separato. A scopo di test è possibile usare Microsoft Azure Storage Explorer o il portale di Azure per generare una firma di accesso condiviso. Quando si crea la firma di accesso condiviso, è possibile specificare l'intervallo di tempo in cui la firma di accesso condiviso è valida e le autorizzazioni che la firma di accesso condiviso concede al client.

L'esempio seguente mostra come usare Esplora archivi di Microsoft Azure per generare una firma di accesso condiviso.

  1. Se non è già stato fatto, installare Esplora archivi di Microsoft Azure
  2. connessione alla sottoscrizione.
  3. Fare clic sull'account di archiviazione e quindi sulla scheda "Azioni" in basso a sinistra. Fare clic su "Get Shared Access Signature" (Ottieni firma di accesso condiviso) per generare una "stringa di connessione" per la firma di accesso condiviso.
  4. Di seguito è riportato un esempio di una stringa di connessione della firma di accesso condiviso che concede le autorizzazioni di lettura e scrittura a livello di servizio, contenitore e oggetto per il servizio BLOB dell'account di archiviazione.

    "SharedAccessSignature=sv=2015-04-05&ss=b&srt=sco&sp=rw&se=2016-07-21T18%3A00%3A00Z&sig=3ABdLOJZosCp0o491T%2BqZGKIhafF1nlM3MzESDDD3Gg%3D;BlobEndpoint=https://youraccount.blob.core.windows.net"

Come si può osservare, quando si usa una firma di accesso condiviso, non si espone la chiave dell'account nell'applicazione. Per altre informazioni sulla firma di accesso condiviso e sulle procedure consigliate per il relativo uso, vedere Firme di accesso condiviso, parte 1: conoscere il modello di firma di accesso condiviso.

Creare una nuova applicazione Xamarin

Per questa esercitazione verrà generata un'applicazione destinata ad Android, iOS e Windows. Questa applicazione creerà semplicemente un contenitore nel quale caricherà un BLOB. Verrà usato Visual Studio in Windows, ma le stesse istruzioni possono essere applicate per la creazione di un'applicazione con Xamarin Studio su macOS.

Attenersi alla procedura seguente per creare l'applicazione:

  1. Se necessario, scaricare e installare Xamarin per Visual Studio.
  2. Aprire Visual Studio e creare un'applicazione vuota (nativa portatile): File > Nuovo > Progetto > Multipiattaforma > Applicazione vuota (nativa portatile).
  3. Nel riquadro Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione e selezionare Gestisci pacchetti NuGet per la soluzione. Cercare WindowsAzure.Storage e installare la versione stabile più recente su tutti i progetti nella soluzione.
  4. Compilare ed eseguire il progetto.

A questo punto si disporrà di un'applicazione che consente di fare clic su un pulsante e incrementare un contatore.

Creare un contenitore e caricare un BLOB

Quindi, sotto il progetto (Portable), si aggiungerà codice a MyClass.cs. Questo codice crea un contenitore e carica in esso un oggetto BLOB. MyClass.cs deve apparire come segue:

using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Blob;
using System.Threading.Tasks;

namespace XamarinApp
{
    public class MyClass
    {
        public MyClass ()
        {
        }

        public static async Task performBlobOperation()
        {
            // Retrieve storage account from connection string.
            CloudStorageAccount storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=your_account_name_here;AccountKey=your_account_key_here");

            // Create the blob client.
            CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();

            // Retrieve reference to a previously created container.
            CloudBlobContainer container = blobClient.GetContainerReference("mycontainer");

            // Create the container if it doesn't already exist.
            await container.CreateIfNotExistsAsync();

            // Retrieve reference to a blob named "myblob".
            CloudBlockBlob blockBlob = container.GetBlockBlobReference("myblob");

            // Create the "myblob" blob with the text "Hello, world!"
            await blockBlob.UploadTextAsync("Hello, world!");
        }
    }
}

Assicurarsi di sostituire "your_account_name_here" e "your_account_key_here" con il nome e la chiave dell'account effettivi.

Tutti i progetti iOS, Android e Windows Phone contengono riferimenti al progetto portatile, vale a dire che è possibile scrivere tutto il codice condiviso in una posizione e utilizzarlo in tutti i progetti. È ora possibile aggiungere la seguente riga di codice in ogni progetto per iniziare a sfruttare i vantaggi: MyClass.performBlobOperation()

XamarinApp.Droid > MainActivity.cs

using Android.App;
using Android.Widget;
using Android.OS;

namespace XamarinApp.Droid
{
    [Activity (Label = "XamarinApp.Droid", MainLauncher = true, Icon = "@drawable/icon")]
    public class MainActivity : Activity
    {
        int count = 1;

        protected override async void OnCreate (Bundle bundle)
        {
            base.OnCreate (bundle);

            // Set our view from the "main" layout resource
            SetContentView (Resource.Layout.Main);

            // Get our button from the layout resource,
            // and attach an event to it
            Button button = FindViewById<Button> (Resource.Id.myButton);

            button.Click += delegate {
                button.Text = string.Format ("{0} clicks!", count++);
            };

            await MyClass.performBlobOperation();
            }
        }
    }
}

XamarinApp.iOS > ViewController.cs

using System;
using UIKit;

namespace XamarinApp.iOS
{
    public partial class ViewController : UIViewController
    {
        int count = 1;

        public ViewController (IntPtr handle) : base (handle)
        {
        }

        public override async void ViewDidLoad ()
        {
            int count = 1;

            public ViewController (IntPtr handle) : base (handle)
            {
            }

            public override async void ViewDidLoad ()
            {
                base.ViewDidLoad ();
                // Perform any additional setup after loading the view, typically from a nib.
                Button.AccessibilityIdentifier = "myButton";
                Button.TouchUpInside += delegate {
                    var title = string.Format ("{0} clicks!", count++);
                    Button.SetTitle (title, UIControlState.Normal);
                };

                await MyClass.performBlobOperation();
            }

            public override void DidReceiveMemoryWarning ()
            {
                base.DidReceiveMemoryWarning ();
                // Release any cached data, images, etc that aren't in use.
            }
        }
    }
}

XamarinApp.WinPhone > MainPage.xaml > MainPage.xaml.cs

using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Navigation;

// The Blank Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=391641

namespace XamarinApp.WinPhone
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        int count = 1;

        public MainPage()
        {
            this.InitializeComponent();

            this.NavigationCacheMode = NavigationCacheMode.Required;
        }

        /// <summary>
        /// Invoked when this page is about to be displayed in a Frame.
        /// </summary>
        /// <param name="e">Event data that describes how this page was reached.
        /// This parameter is typically used to configure the page.</param>
        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            int count = 1;

            public MainPage()
            {
                this.InitializeComponent();

                this.NavigationCacheMode = NavigationCacheMode.Required;
            }

            /// <summary>
            /// Invoked when this page is about to be displayed in a Frame.
            /// </summary>
            /// <param name="e">Event data that describes how this page was reached.
            /// This parameter is typically used to configure the page.</param>
            protected override async void OnNavigatedTo(NavigationEventArgs e)
            {
                // TODO: Prepare page for display here.

                // TODO: If your application contains multiple pages, ensure that you are
                // handling the hardware Back button by registering for the
                // Windows.Phone.UI.Input.HardwareButtons.BackPressed event.
                // If you are using the NavigationHelper provided by some templates,
                // this event is handled for you.
                Button.Click += delegate {
                    var title = string.Format("{0} clicks!", count++);
                    Button.Content = title;
                };

                await MyClass.performBlobOperation();
            }
        }
    }
}

Eseguire l'applicazione

È ora possibile eseguire questa applicazione in un emulatore Android o Windows Phone. È inoltre possibile eseguire questa applicazione in un emulatore iOS, ma questo richiederà un Mac. Per istruzioni specifiche su come eseguire questa operazione, leggere la documentazione relativa alla connessione di Visual Studio a un Mac

Dopo aver eseguito l'applicazione, verrà creato il contenitore mycontainer nell'account di archiviazione. Questo deve contenere il BLOB, myblob, che include il testo, Hello, world!. È possibile verificarlo tramite Esplora archivi di Microsoft Azure.

Passaggi successivi

In questa esercitazione è stato illustrato come creare un'applicazione multipiattaforma in Xamarin che usa Archiviazione di Azure, con particolare attenzione a uno scenario di archiviazione BLOB. È tuttavia possibile svolgere molte altre operazioni, non solo con l'archiviazione BLOB, ma anche con archiviazione tabelle, archiviazione file e archiviazione code. Per altre informazioni, vedere gli articoli seguenti:

Suggerimento

Gestire le risorse dell'archivio BLOB di Azure con Microsoft Azure Storage Explorer

Esplora archivi di Microsoft Azure è un'app autonoma gratuita di Microsoft che consente di gestire risorse di Archiviazione BLOB di Azure. Esplora archivi di Microsoft Azure consente di creare, leggere, aggiornare ed eliminare contenitori BLOB e BLOB, nonché di gestire l'accesso ai contenitori BLOB e ai BLOB.