Introduzione all'archiviazione tabelle di Azure e a Servizi connessi di Visual Studio (ASP.NET)

Suggerimento

Provare Esplora archivi Microsoft Azure

Microsoft Azure Storage Explorer è un'app autonoma gratuita di Microsoft che consente di rappresentare facilmente dati di Archiviazione di Azure in Windows, macOS e Linux.

Panoramica

L’archiviazione tabelle di Azure consente di archiviare grandi quantità di dati strutturati. Il servizio è un datastore NoSQL che accetta chiamate autenticate dall'interno e dall'esterno del cloud di Azure. Le tabelle di Azure sono ideali per l'archiviazione di dati strutturati non relazionali.

Questa esercitazione illustra come scrivere codice ASP.NET per alcuni scenari comuni usando le entità di archiviazione tabelle di Azure. Questi scenari includono la creazione di una tabella, l'aggiunta, la creazione di query ed eliminazione di entità di tabella.

Prerequisiti

Informazioni sul Servizio tabelle

Il servizio di archiviazione tabelle di Azure consente di archiviare grandi quantità di dati strutturati. Il servizio è un datastore NoSQL che accetta chiamate autenticate dall'interno e dall'esterno del cloud di Azure. Le tabelle di Azure sono ideali per l'archiviazione di dati strutturati non relazionali. Di seguito sono riportati gli utilizzi più comuni per il servizio tabelle.

  • Archiviazione di terabyte di dati strutturati in grado di servire applicazioni su scala Web
  • Archiviazione di set di dati che non richiedono join complessi, chiavi esterne o stored procedure e che possono essere denormalizzati per l'accesso rapido
  • Esecuzione rapida di query sui dati mediante un indice cluster
  • Accesso ai dati tramite il protocollo OData e query LINQ con librerie .NET WCF Data Service

È possibile utilizzare il servizio tabelle per archiviare e interrogare grandi set di dati strutturati non relazionali, con tabelle scalabili in base all'aumento della domanda

Concetti del servizio tabelle

Il servizio tabelle contiene i componenti seguenti:

Diagramma dei componenti del servizio tabelle

  • Formato dell'URL: il codice fa riferimento alle tabelle in un account usando il formato di indirizzo seguente:
    http://<storage account>.table.core.windows.net/<table>

    È possibile fare riferimento direttamente alle tabelle di Azure utilizzando questo indirizzo con il protocollo OData. Per altre informazioni, vedere OData.org.

  • Account di archiviazione: l'accesso ad Archiviazione di Azure viene eseguito esclusivamente tramite un account di archiviazione. Per informazioni sulla capacità dell'account di archiviazione, vedere Obiettivi di scalabilità e prestazioni per Archiviazione di Azure .
  • Tabella: una tabella è una raccolta di entità. Le tabelle non impongono uno schema sulle entità, pertanto una singola tabella può contenere entità che presentano set di proprietà diversi. Il numero di tabelle che un account di archiviazione può contenere è limitato solo in base al limite di capacità dell'account di archiviazione.
  • Entità: un'entità è un set di proprietà, simile a una riga di database. Un'entità può avere una dimensione massima di 1 MB.
  • Proprietà: una proprietà è una coppia nome-valore. Ogni entità può includere fino a 252 proprietà per l'archiviazione dei dati. Ogni entità dispone inoltre di 3 proprietà di sistema che specificano una chiave di partizione, una chiave di riga e un timestamp. Le entità con la stessa chiave di partizione possono essere interrogate più rapidamente e inserite o aggiornate in operazioni atomiche. La chiave di riga di un'entità ne rappresenta l'identificatore univoco all'interno di una partizione.

Per informazioni sulle proprietà e i tipi di tabelle, vedere Informazioni sul modello di dati del servizio tabelle.

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.

Configurare l'ambiente di sviluppo

Questa sezione illustra la configurazione dell'ambiente di sviluppo, incluse la creazione di un'app ASP.NET MVC, l'aggiunta di una connessione di Servizi connessi, l'aggiunta di un controller e la specifica delle direttive degli spazi dei nomi necessarie.

Creare un progetto di app ASP.NET MVC

  1. Aprire Visual Studio.

  2. Scegliere File->Nuovo->Progetto dal menu principale.

  3. Nella finestra di dialogo Nuovo progetto specificare le opzioni evidenziate nella figura seguente:

    Creazione di un progetto ASP.NET

  4. Selezionare OK.

  5. Nella finestra di dialogo Nuovo progetto ASP.NET specificare le opzioni evidenziate nella figura seguente:

    Specificare MVC

  6. Selezionare OK.

Usare Servizi connessi per connettersi a un account di archiviazione di Azure

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto e scegliere Aggiungi > Servizi connessi dal menu di scelta rapida.

  2. Nella finestra di dialogo Aggiungi servizio connesso scegliere Archiviazione di Azure, quindi fare clic su Configura.

    Finestra di dialogo Servizi connessi

  3. Nella finestra di dialogo Archiviazione di Azure selezionare l'account di archiviazione di Azure desiderato e selezionare Aggiungi.

Creare un controller MVC

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse su Controller e selezionare Aggiungi > Controller dal menu di scelta rapida.

    Aggiungere un controller a un'app MVC ASP.NET

  2. Nella finestra di dialogo Aggiungi scaffolding fare clic su Controller MVC 5 - Vuoto e selezionare Aggiungi.

    Specificare il tipo di controller MVC

  3. Nella finestra di dialogo Aggiungi controller assegnare un nome al controller TablesController e selezionare Aggiungi.

    Assegnare un nome al controller MVC

  4. Aggiungere le direttive using seguenti al file TablesController.cs:

    using Microsoft.Azure;
    using Microsoft.WindowsAzure.Storage;
    using Microsoft.WindowsAzure.Storage.Auth;
    using Microsoft.WindowsAzure.Storage.Table;
    

Creare una classe di modello

Molti esempi in questo articolo usano una classe derivata da TableEntity, denominata CustomerEntity. La procedura seguente consente di dichiarare questa classe come classe di modello:

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse su Modelli e selezionare Aggiungi > Classe dal menu di scelta rapida.

  2. Nella finestra di dialogo Aggiungi nuovo elemento assegnare un nome alla classe, CustomerEntity.

  3. Aprire il file CustomerEntity.cs e aggiungere le direttive using seguenti:

    using Microsoft.WindowsAzure.Storage.Table;
    
  4. Modificare la classe in modo che, al termine, la classe venga dichiarata come illustrato nel codice seguente. La classe dichiara una classe di entità denominata CustomerEntity che usa il nome e il cognome del cliente rispettivamente come chiave di riga e chiave di partizione.

    public class CustomerEntity : TableEntity
    {
        public CustomerEntity(string lastName, string firstName)
        {
            this.PartitionKey = lastName;
            this.RowKey = firstName;
        }
    
        public CustomerEntity() { }
    
        public string Email { get; set; }
    }
    

Creare una tabella

I passaggi seguenti illustrano come creare una tabella:

Nota

Questa sezione presuppone che siano stati completati i passaggi descritti in Configurare l'ambiente di sviluppo.

  1. Aprire il file TablesController.cs .

  2. Aggiungere un metodo denominato CreateTable che restituisce un ActionResult.

    public ActionResult CreateTable()
    {
        // The code in this section goes here.
    
        return View();
    }
    
  3. Nel metodo CreateTable recuperare un oggetto CloudStorageAccount che rappresenta le informazioni sull'account di archiviazione. Usare il codice seguente per ottenere la stringa di connessione di archiviazione e le informazioni sull'account di archiviazione dalla configurazione del servizio di Azure: sostituire <nome account di archiviazione> con il nome dell'account di archiviazione Azure a cui si sta accedendo.

    CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
       CloudConfigurationManager.GetSetting("<storage-account-name>_AzureStorageConnectionString"));
    
  4. Ottenere un oggetto CloudTableClient che rappresenta un client del servizio tabelle.

    CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
    
  5. Ottenere un oggetto CloudTable che rappresenta un riferimento al nome della tabella desiderata. Il metodo CloudTableClient.GetTableReference non esegue una richiesta all'archiviazione tabelle. Il riferimento viene restituito indipendentemente dall'esistenza della tabella.

    CloudTable table = tableClient.GetTableReference("TestTable");
    
  6. Chiamare il metodo CloudTable.CreateIfNotExists per creare la tabella se non esiste. Il metodo CloudTable.CreateIfNotExists restituisce true se la tabella non esiste e viene creata correttamente. In caso contrario, viene restituito false.

    ViewBag.Success = table.CreateIfNotExists();
    
  7. Aggiornare ViewBag con il nome della tabella.

    ViewBag.TableName = table.Name;
    
  8. In Esplora soluzioni espandere la cartella Views, fare clic con il pulsante destro del mouse su Tabelle e dal menu di scelta rapida selezionare Aggiungi->Visualizzazione.

  9. Nella finestra di dialogo Aggiungi visualizzazione immettere CreateTable per il nome della visualizzazione e selezionare Aggiungi.

  10. Aprire CreateTable.cshtml e modificarlo in modo che l'aspetto sia simile al frammento di codice seguente:

    @{
        ViewBag.Title = "Create Table";
    }
    
    <h2>Create Table results</h2>
    
    Creation of @ViewBag.TableName @(ViewBag.Success == true ? "succeeded" : "failed")
    
  11. In Esplora soluzioni espandere la cartella Views->Shared e aprire _Layout.cshtml.

  12. Dopo l'ultimo Html.ActionLink aggiungere il seguente Html.ActionLink:

    <li>@Html.ActionLink("Create table", "CreateTable", "Tables")</li>
    
  13. Eseguire l'applicazione e selezionare Create table per visualizzare risultati simili allo screenshot seguente:

    Crea tabella

    Come accennato in precedenza, il metodo CloudTable.CreateIfNotExists restituisce true solo quando la tabella non esiste e viene creata. Se quindi si esegue l'app quando la tabella esiste, il metodo restituisce false. Per eseguire l'app più volte, è necessario eliminare la tabella prima di eseguire di nuovo l'app. L'eliminazione della tabella può essere eseguita tramite il metodo CloudTable.Delete. È possibile anche eliminare la tabella usando il portale Azure o Esplora archivi di Microsoft Azure.

Aggiungere un'entità a una tabella

Per eseguire il mapping di entità a oggetti C#, viene usata una classe personalizzata derivata da TableEntity. Per aggiungere un'entità a una classe, creare una classe che definisca le proprietà dell'entità. Questa sezione illustra come definire una classe di entità che usa il nome e il cognome del cliente rispettivamente come chiave di riga e chiave di partizione. La combinazione della chiave di riga e della chiave di partizione di un'entità consentono di identificare in modo univoco l'entità nella tabella. Le query su entità con la stessa chiave di partizione vengono eseguite più rapidamente di quelle con chiavi di partizione diverse, tuttavia l'uso di chiavi di partizione diverse assicura una maggiore scalabilità delle operazioni parallele. Tutte le proprietà da archiviare nel servizio tabelle devono essere proprietà pubbliche di un tipo supportato che espone entrambi i valori di impostazione e recupero. La classe di entità deve dichiarare un costruttore pubblico senza parametri.

Nota

Questa sezione presuppone che siano stati completati i passaggi descritti in Configurare l'ambiente di sviluppo.

  1. Aprire il file TablesController.cs .

  2. Aggiungere la seguente direttiva in modo che il codice nel file TablesController.cs possa accedere alla classe CustomerEntity:

    using StorageAspnet.Models;
    
  3. Aggiungere un metodo denominato AddEntity che restituisce un ActionResult.

    public ActionResult AddEntity()
    {
        // The code in this section goes here.
    
        return View();
    }
    
  4. Nel metodo AddEntity recuperare un oggetto CloudStorageAccount che rappresenta le informazioni sull'account di archiviazione. Usare il codice seguente per ottenere la stringa di connessione di archiviazione e le informazioni sull'account di archiviazione dalla configurazione del servizio di Azure: sostituire <nome account di archiviazione> con il nome dell'account di archiviazione Azure a cui si sta accedendo.

    CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
       CloudConfigurationManager.GetSetting("<storage-account-name>_AzureStorageConnectionString"));
    
  5. Ottenere un oggetto CloudTableClient che rappresenta un client del servizio tabelle.

    CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
    
  6. Ottenere un oggetto CloudTable che rappresenta un riferimento alla tabella in cui si sta aggiungendo la nuova entità.

    CloudTable table = tableClient.GetTableReference("TestTable");
    
  7. Creare un'istanza e inizializzare la classe CustomerEntity.

    CustomerEntity customer1 = new CustomerEntity("Harp", "Walter");
    customer1.Email = "Walter@contoso.com";
    
  8. Creare un oggetto TableOperation che inserisce l'entità cliente.

    TableOperation insertOperation = TableOperation.Insert(customer1);
    
  9. Eseguire l'operazione di inserimento chiamando il metodo CloudTable.Execute. È possibile verificare il risultato dell'operazione controllando la proprietà TableResult.HttpStatusCode. Il codice di stato 2xx indica che l'azione richiesta dal client è stata elaborata correttamente. Ad esempio, l'inserimento di nuove entità genera il codice di stato HTTP 204 indicante che l'operazione è stata elaborata correttamente e il server non ha restituito alcun contenuto.

    TableResult result = table.Execute(insertOperation);
    
  10. Aggiornare ViewBag con il nome della tabella e i risultati dell'operazione di inserimento.

    ViewBag.TableName = table.Name;
    ViewBag.Result = result.HttpStatusCode;
    
  11. In Esplora soluzioni espandere la cartella Views, fare clic con il pulsante destro del mouse su Tabelle e dal menu di scelta rapida selezionare Aggiungi->Visualizzazione.

  12. Nella finestra di dialogo Aggiungi visualizzazione immettere AddEntity per il nome della visualizzazione e selezionare Aggiungi.

  13. Aprire AddEntity.cshtml e modificarlo in modo che l'aspetto sia simile al frammento di codice seguente:

    @{
        ViewBag.Title = "Add entity";
    }
    
    <h2>Add entity results</h2>
    
    Insert of entity into @ViewBag.TableName @(ViewBag.Result == 204 ? "succeeded" : "failed")
    
  14. In Esplora soluzioni espandere la cartella Views->Shared e aprire _Layout.cshtml.

  15. Dopo l'ultimo Html.ActionLink aggiungere il seguente Html.ActionLink:

    <li>@Html.ActionLink("Add entity", "AddEntity", "Tables")</li>
    
  16. Eseguire l'applicazione e selezionare Aggiungi entità per visualizzare risultati simili allo screenshot seguente:

    Aggiungi entità

    È possibile verificare che l'entità sia stata aggiunta seguendo i passaggi nella sezione Ottenere una singola entità. È possibile anche usare Esplora archivi di Microsoft Azure per visualizzare tutte le entità per le tabelle.

Aggiungere un batch di entità a una tabella

Oltre ad aggiungere entità a una tabella una alla volta, è possibile aggiungere entità anche in batch. L'aggiunta di entità in batch riduce il numero di round trip tra il codice e il servizio tabelle di Azure. I passaggi seguenti illustrano come aggiungere più entità a una tabella con una singola operazione di inserimento:

Nota

Questa sezione presuppone che siano stati completati i passaggi descritti in Configurare l'ambiente di sviluppo.

  1. Aprire il file TablesController.cs .

  2. Aggiungere un metodo denominato AddEntities che restituisce un ActionResult.

    public ActionResult AddEntities()
    {
        // The code in this section goes here.
    
        return View();
    }
    
  3. Nel metodo AddEntities recuperare un oggetto CloudStorageAccount che rappresenta le informazioni sull'account di archiviazione. Usare il codice seguente per ottenere la stringa di connessione di archiviazione e le informazioni sull'account di archiviazione dalla configurazione del servizio di Azure: sostituire <nome account di archiviazione> con il nome dell'account di archiviazione Azure a cui si sta accedendo.

    CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
       CloudConfigurationManager.GetSetting("<storage-account-name>_AzureStorageConnectionString"));
    
  4. Ottenere un oggetto CloudTableClient che rappresenta un client del servizio tabelle.

    CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
    
  5. Ottenere un oggetto CloudTable che rappresenta un riferimento alla tabella in cui si sta aggiungendo le nuove entità.

    CloudTable table = tableClient.GetTableReference("TestTable");
    
  6. Creare un'istanza di alcuni oggetti cliente basati sulla classe di modello CustomerEntity presentati nella sezione Aggiungere un'entità a una tabella.

    CustomerEntity customer1 = new CustomerEntity("Smith", "Jeff");
    customer1.Email = "Jeff@contoso.com";
    
    CustomerEntity customer2 = new CustomerEntity("Smith", "Ben");
    customer2.Email = "Ben@contoso.com";
    
  7. Ottenere un oggetto TableBatchOperation.

    TableBatchOperation batchOperation = new TableBatchOperation();
    
  8. Aggiungere le entità all'oggetto di operazione di inserimento in batch.

    batchOperation.Insert(customer1);
    batchOperation.Insert(customer2);
    
  9. Eseguire l'operazione di inserimento in batch chiamando il metodo CloudTable.ExecuteBatch.

    IList<TableResult> results = table.ExecuteBatch(batchOperation);
    
  10. Il metodo CloudTable.ExecuteBatch restituisce un elenco di oggetti TableResult in cui ogni oggetto TableResult può essere esaminato per determinare l'esito positivo o negativo di ogni singola operazione. Per questo esempio, passare l'elenco a una visualizzazione e mostrare i risultati di ogni operazione.

    return View(results);
    
  11. In Esplora soluzioni espandere la cartella Views, fare clic con il pulsante destro del mouse su Tabelle e dal menu di scelta rapida selezionare Aggiungi->Visualizzazione.

  12. Nella finestra di dialogo Aggiungi visualizzazione immettere AddEntities per il nome della visualizzazione e selezionare Aggiungi.

  13. Aprire AddEntities.cshtml e modificarlo in modo che l'aspetto sia simile al seguente.

    @model IEnumerable<Microsoft.WindowsAzure.Storage.Table.TableResult>
    @{
        ViewBag.Title = "AddEntities";
    }
    
    <h2>Add-entities results</h2>
    
    <table border="1">
        <tr>
            <th>First name</th>
            <th>Last name</th>
            <th>HTTP result</th>
        </tr>
        @foreach (var result in Model)
        {
        <tr>
            <td>@((result.Result as StorageAspnet.Models.CustomerEntity).RowKey)</td>
            <td>@((result.Result as StorageAspnet.Models.CustomerEntity).PartitionKey)</td>
            <td>@result.HttpStatusCode</td>
        </tr>
        }
    </table>
    
  14. In Esplora soluzioni espandere la cartella Views->Shared e aprire _Layout.cshtml.

  15. Dopo l'ultimo Html.ActionLink aggiungere il seguente Html.ActionLink:

    <li>@Html.ActionLink("Add entities", "AddEntities", "Tables")</li>
    
  16. Eseguire l'applicazione e selezionare Aggiungi entità per visualizzare risultati simili allo screenshot seguente:

    Aggiungi entità

    È possibile verificare che l'entità sia stata aggiunta seguendo i passaggi nella sezione Ottenere una singola entità. È possibile anche usare Esplora archivi di Microsoft Azure per visualizzare tutte le entità per le tabelle.

Ottenere una singola entità

Questa sezione illustra come ottenere una singola entità da una tabella usando la chiave di riga e la chiave di partizione dell'entità.

Nota

Questa sezione presuppone che siano stati completati i passaggi descritti in Configurare l'ambiente di sviluppo e che siano stati usati i dati in Aggiungere un batch di entità a una tabella.

  1. Aprire il file TablesController.cs .

  2. Aggiungere un metodo denominato GetSingle che restituisce un ActionResult.

    public ActionResult GetSingle()
    {
        // The code in this section goes here.
    
        return View();
    }
    
  3. Nel metodo ListBlobs recuperare un oggetto CloudStorageAccount che rappresenta le informazioni sull'account di archiviazione. Usare il codice seguente per ottenere la stringa di connessione di archiviazione e le informazioni sull'account di archiviazione dalla configurazione del servizio di Azure: sostituire <nome account di archiviazione> con il nome dell'account di archiviazione Azure a cui si sta accedendo.

    CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
       CloudConfigurationManager.GetSetting("<storage-account-name>_AzureStorageConnectionString"));
    
  4. Ottenere un oggetto CloudTableClient che rappresenta un client del servizio tabelle.

    CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
    
  5. Ottenere un oggetto CloudTable che rappresenta un riferimento alla tabella da cui si stanno recuperando l'entità.

    CloudTable table = tableClient.GetTableReference("TestTable");
    
  6. Creare un oggetto operazione di recupero che accetta un oggetto entità derivato da TableEntity. Il primo parametro è il partitionKey e il secondo è il rowKey. Usando la classe CustomerEntity e i dati presentati nella sezione Aggiungere un batch di entità a una tabella, il frammento di codice seguente esegue una query sulla tabella per un CustomerEntity il cui valore partitionKey sia "Smith" e il cui valore rowKey sia "Ben":

    TableOperation retrieveOperation = TableOperation.Retrieve<CustomerEntity>("Smith", "Ben");
    
  7. Eseguire l'operazione di recupero.

    TableResult result = table.Execute(retrieveOperation);
    
  8. Passare il risultato alla visualizzazione per mostrare i dati ottenuti.

    return View(result);
    
  9. In Esplora soluzioni espandere la cartella Views, fare clic con il pulsante destro del mouse su Tabelle e dal menu di scelta rapida selezionare Aggiungi->Visualizzazione.

  10. Nella finestra di dialogo Aggiungi visualizzazione immettere GetSingle per il nome della visualizzazione e selezionare Aggiungi.

  11. Aprire GetSingle.cshtml e modificarlo in modo che l'aspetto sia simile al frammento di codice seguente:

    @model Microsoft.WindowsAzure.Storage.Table.TableResult
    @{
        ViewBag.Title = "GetSingle";
    }
    
    <h2>Get Single results</h2>
    
    <table border="1">
        <tr>
            <th>HTTP result</th>
            <th>First name</th>
            <th>Last name</th>
            <th>Email</th>
        </tr>
        <tr>
            <td>@Model.HttpStatusCode</td>
            <td>@((Model.Result as StorageAspnet.Models.CustomerEntity).RowKey)</td>
            <td>@((Model.Result as StorageAspnet.Models.CustomerEntity).PartitionKey)</td>
            <td>@((Model.Result as StorageAspnet.Models.CustomerEntity).Email)</td>
        </tr>
    </table>
    
  12. In Esplora soluzioni espandere la cartella Views->Shared e aprire _Layout.cshtml.

  13. Dopo l'ultimo Html.ActionLink aggiungere il seguente Html.ActionLink:

    <li>@Html.ActionLink("Get single", "GetSingle", "Tables")</li>
    
  14. Eseguire l'applicazione e selezionare Get Single per visualizzare risultati simili allo screenshot seguente:

    Get single

Recuperare tutte le entità di una partizione

Come accennato nella sezione Aggiungere un'entità a una tabella, la combinazione di una partizione e una chiave di riga identifica in modo univoco un'entità in una tabella. Le query su entità con la stessa chiave di partizione vengono eseguite più rapidamente di quelle con chiavi di partizione diverse. Questa sezione illustra come eseguire query su una tabella per tutte le entità da una partizione specificata.

Nota

Questa sezione presuppone che siano stati completati i passaggi descritti in Configurare l'ambiente di sviluppo e che siano stati usati i dati in Aggiungere un batch di entità a una tabella.

  1. Aprire il file TablesController.cs .

  2. Aggiungere un metodo denominato GetPartition che restituisce un ActionResult.

    public ActionResult GetPartition()
    {
        // The code in this section goes here.
    
        return View();
    }
    
  3. Nel metodo GetPartition recuperare un oggetto CloudStorageAccount che rappresenta le informazioni sull'account di archiviazione. Usare il codice seguente per ottenere la stringa di connessione di archiviazione e le informazioni sull'account di archiviazione dalla configurazione del servizio di Azure: sostituire <nome account di archiviazione> con il nome dell'account di archiviazione Azure a cui si sta accedendo.

    CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
       CloudConfigurationManager.GetSetting("<storage-account-name>_AzureStorageConnectionString"));
    
  4. Ottenere un oggetto CloudTableClient che rappresenta un client del servizio tabelle.

    CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
    
  5. Ottenere un oggetto CloudTable che rappresenta un riferimento alla tabella da cui si stanno recuperando le entità.

    CloudTable table = tableClient.GetTableReference("TestTable");
    
  6. Creare un'istanza di un oggetto TableQuery specificando la query nella clausola Where. Usando la classe CustomerEntity e i dati presentati nella sezione Aggiungere un batch di entità a una tabella, il frammento di codice seguente esegue una query sulla tabella per tutte le entità in cui il valore PartitionKey (cognome del cliente) sia "Smith":

    TableQuery<CustomerEntity> query = 
        new TableQuery<CustomerEntity>()
        .Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "Smith"));
    
  7. All'interno di un ciclo chiamare il metodo CloudTable.ExecuteQuerySegmented passando l'oggetto query istanziato nel passaggio precedente. Il metodo CloudTable.ExecuteQuerySegmented restituisce un oggetto TableContinuationToken che, quando è null, indica che non ci sono più entità da recuperare. All'interno del ciclo usare un altro ciclo per eseguire un'iterazione sulle entità restituite. Nell'esempio di codice seguente ogni entità restituita viene aggiunta a un elenco. Al termine del ciclo, l'elenco viene passato a una visualizzazione per mostrare i dati ottenuti:

    List<CustomerEntity> customers = new List<CustomerEntity>();
    TableContinuationToken token = null;
    do
    {
        TableQuerySegment<CustomerEntity> resultSegment = table.ExecuteQuerySegmented(query, token);
        token = resultSegment.ContinuationToken;
    
        foreach (CustomerEntity customer in resultSegment.Results)
        {
            customers.Add(customer);
        }
    } while (token != null);
    
    return View(customers);
    
  8. In Esplora soluzioni espandere la cartella Views, fare clic con il pulsante destro del mouse su Tabelle e dal menu di scelta rapida selezionare Aggiungi->Visualizzazione.

  9. Nella finestra di dialogo Aggiungi visualizzazione immettere GetPartition per il nome della visualizzazione e selezionare Aggiungi.

  10. Aprire GetPartition.cshtml e modificarlo in modo che l'aspetto sia simile al frammento di codice seguente:

    @model IEnumerable<StorageAspnet.Models.CustomerEntity>
    @{
        ViewBag.Title = "GetPartition";
    }
    
    <h2>Get Partition results</h2>
    
    <table border="1">
        <tr>
            <th>First name</th>
            <th>Last name</th>
            <th>Email</th>
        </tr>
        @foreach (var customer in Model)
        {
        <tr>
            <td>@(customer.RowKey)</td>
            <td>@(customer.PartitionKey)</td>
            <td>@(customer.Email)</td>
        </tr>
        }
    </table>
    
  11. In Esplora soluzioni espandere la cartella Views->Shared e aprire _Layout.cshtml.

  12. Dopo l'ultimo Html.ActionLink aggiungere il seguente Html.ActionLink:

    <li>@Html.ActionLink("Get partition", "GetPartition", "Tables")</li>
    
  13. Eseguire l'applicazione e selezionare Get Partition per visualizzare risultati simili allo screenshot seguente:

    Get Partition

Eliminare un'entità

Questa sezione illustra come eliminare un'entità da una tabella.

Nota

Questa sezione presuppone che siano stati completati i passaggi descritti in Configurare l'ambiente di sviluppo e che siano stati usati i dati in Aggiungere un batch di entità a una tabella.

  1. Aprire il file TablesController.cs .

  2. Aggiungere un metodo denominato DeleteEntity che restituisce un ActionResult.

    public ActionResult DeleteEntity()
    {
        // The code in this section goes here.
    
        return View();
    }
    
  3. Nel metodo DeleteEntity recuperare un oggetto CloudStorageAccount che rappresenta le informazioni sull'account di archiviazione. Usare il codice seguente per ottenere la stringa di connessione di archiviazione e le informazioni sull'account di archiviazione dalla configurazione del servizio di Azure: sostituire <nome account di archiviazione> con il nome dell'account di archiviazione Azure a cui si sta accedendo.

    CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
       CloudConfigurationManager.GetSetting("<storage-account-name>_AzureStorageConnectionString"));
    
  4. Ottenere un oggetto CloudTableClient che rappresenta un client del servizio tabelle.

    CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
    
  5. Ottenere un oggetto CloudTable che rappresenta un riferimento alla tabella da cui si sta eliminando l'entità.

    CloudTable table = tableClient.GetTableReference("TestTable");
    
  6. Creare un oggetto operazione di eliminazione che accetta un oggetto entità derivato da TableEntity. In questo caso si usa la classe CustomerEntity e ai dati presentati nella sezione Aggiungere un batch di entità a una tabella. Il valore ETag dell'entità deve essere impostato su un valore valido.

    TableOperation deleteOperation = 
        TableOperation.Delete(new CustomerEntity("Smith", "Ben") { ETag = "*" } );
    
  7. Eseguire l'operazione di eliminazione.

    TableResult result = table.Execute(deleteOperation);
    
  8. Passare il risultato alla visualizzazione per mostrare i dati ottenuti.

    return View(result);
    
  9. In Esplora soluzioni espandere la cartella Views, fare clic con il pulsante destro del mouse su Tabelle e dal menu di scelta rapida selezionare Aggiungi->Visualizzazione.

  10. Nella finestra di dialogo Aggiungi visualizzazione immettere DeleteEntity per il nome della visualizzazione e selezionare Aggiungi.

  11. Aprire DeleteEntity.cshtml e modificarlo in modo che l'aspetto sia simile al frammento di codice seguente:

    @model Microsoft.WindowsAzure.Storage.Table.TableResult
    @{
        ViewBag.Title = "DeleteEntity";
    }
    
    <h2>Delete Entity results</h2>
    
    <table border="1">
        <tr>
            <th>First name</th>
            <th>Last name</th>
            <th>HTTP result</th>
        </tr>
        <tr>
            <td>@((Model.Result as StorageAspnet.Models.CustomerEntity).RowKey)</td>
            <td>@((Model.Result as StorageAspnet.Models.CustomerEntity).PartitionKey)</td>
            <td>@Model.HttpStatusCode</td>
        </tr>
    </table>
    
  12. In Esplora soluzioni espandere la cartella Views->Shared e aprire _Layout.cshtml.

  13. Dopo l'ultimo Html.ActionLink aggiungere il seguente Html.ActionLink:

    <li>@Html.ActionLink("Delete entity", "DeleteEntity", "Tables")</li>
    
  14. Eseguire l'applicazione e selezionare Delete entity per visualizzare risultati simili allo screenshot seguente:

    Get single

Passaggi successivi

Per ulteriori opzioni di archiviazione dei dati in Azure, consultare altre guide alle funzionalità.