Introduzione all'API Tabella di Azure Cosmos DB e all'archiviazione tabelle con .NET SDKGet started with Azure Cosmos DB Table API and Azure Table storage using the .NET SDK

Suggerimento

Il contenuto di questo articolo è applicabile al servizio di archiviazione tabelle di Azure e all'API Tabelle di Azure Cosmos DB.The content in this article applies to Azure Table storage and the Azure Cosmos DB Table API. L'API Tabelle di Azure Cosmos DB è un'offerta Premium per il servizio di archiviazione tabelle, che include tabelle con ottimizzazione per la velocità effettiva, distribuzione globale e indici secondari automatici.The Azure Cosmos DB Table API is a premium offering for table storage that offers throughput-optimized tables, global distribution, and automatic secondary indexes.

È possibile usare l'API Tabella di Azure Cosmos DB o l'archiviazione tabelle di Azure per archiviare dati NoSQL strutturati nel cloud, fornendo un archivio di chiavi/attributi con una progettazione senza schema.You can use the Azure Cosmos DB Table API or Azure Table storage to store structured NoSQL data in the cloud, providing a key/attribute store with a schema less design. Dato che l'API Tabella di Azure Cosmos DB e l'archiviazione tabelle sono senza schema, è facile adattare i dati con il variare delle esigenze dell'applicazione.Because Azure Cosmos DB Table API and Table storage are schema less, it's easy to adapt your data as the needs of your application evolve. È possibile usare l'API Tabella di Azure Cosmos DB o l'archiviazione tabelle per archiviare set di dati flessibili, ad esempio i dati utente per le applicazioni Web, le rubriche, le informazioni sui dispositivi o altri tipi di metadati richiesti dal servizio.You can use Azure Cosmos DB Table API or the Table storage to store flexible datasets such as user data for web applications, address books, device information, or other types of metadata your service requires.

Questa esercitazione descrive un esempio che illustra come usare la libreria di tabelle Microsoft Azure Cosmos DB per .NET con l'API Tabella di Azure Cosmos DB e l'archiviazione tabelle di Azure.This tutorial describes a sample that shows you how to use the Microsoft Azure Cosmos DB Table Library for .NET with Azure Cosmo DB Table API and Azure Table storage scenarios. È necessario usare la connessione specifica per il servizio di Azure.You must use the connection specific to the Azure service. Questi scenari vengono esaminati usando esempi C# che illustrano come creare tabelle, inserire/aggiornare i dati, eseguire query sui dati ed eliminare le tabelle.These scenarios are explored using C# examples that illustrate how to create tables, insert/ update data, query data and delete the tables.

PrerequisitiPrerequisites

Per completare correttamente l'esempio sono necessari gli elementi seguenti:You need the following to complete this sample successfully:

Creare un account per l'API di tabella di Azure Cosmos DBCreate an Azure Cosmos DB Table API account

  1. In una nuova finestra del browser accedere al portale di Azure.In a new browser window, sign in to the Azure portal.

  2. Nel riquadro di spostamento sinistro selezionare Crea una risorsa.In the left navigation pane, select Create a resource. Selezionare Database e quindi Azure Cosmos DB.Select Databases and then select Azure Cosmos DB.

    Screenshot del portale di Azure in cui sono evidenziati Altri servizi e Azure Cosmos DB

  3. Nella pagina Crea account Azure Cosmos DB immettere le impostazioni per il nuovo account Azure Cosmos DB:On the Create Azure Cosmos DB Account page, enter the settings for the new Azure Cosmos DB account:

    ImpostazioneSetting ValoreValue DESCRIZIONEDescription
    SottoscrizioneSubscription Sottoscrizione in usoYour subscription Selezionare la sottoscrizione di Azure da usare per l'account Azure Cosmos DB.Select the Azure subscription that you want to use for this Azure Cosmos DB account.
    Gruppo di risorseResource Group Creare un nuovo gruppo di risorseCreate new

    Immettere quindi lo stesso nome univoco specificato in IDThen enter the same unique name as provided in ID
    Selezionare Crea nuovo.Select Create new. Immettere quindi il nome di un nuovo gruppo di risorse per l'account.Then enter a new resource group name for your account. Per semplicità, usare lo stesso nome usato come ID.For simplicity, use the same name as your ID.
    Nome accountAccount Name Immettere un nome univocoEnter a unique name Immettere un nome univoco per identificare l'account Azure Cosmos DB.Enter a unique name to identify your Azure Cosmos DB account.

    L'ID può contenere solo lettere minuscole, numeri e il carattere trattino (-).The ID can use only lowercase letters, numbers, and the hyphen (-) character. Deve essere composto da un numero di caratteri compreso tra 3 e 31.It must be between 3 and 31 characters long.
    APIAPI tabella di AzureAzure Table L'API determina il tipo di account da creare.The API determines the type of account to create. Azure Cosmos DB offre cinque API: Core (SQL) per i database di documenti, Gremlin per i database a grafo, MongoDB per i database di documenti, Tabella di Azure e Cassandra.Azure Cosmos DB provides five APIs: Core(SQL) for document databases, Gremlin for graph databases, MongoDB for document databases, Azure Table, and Cassandra. Attualmente, è necessario creare un account separato per ogni API.Currently, you must create a separate account for each API.

    Selezionare Tabella di Azure perché in questo argomento di avvio rapido si crea una tabella che funziona con l'API Tabella.Select Azure Table because in this quickstart you're creating a table that works with the Table API.

    Altre informazioni sull'API Tabella.Learn more about the Table API.
    LocalitàLocation Selezionare l'area più vicina agli utentiSelect the region closest to your users Selezionare una posizione geografica in cui ospitare l'account Azure Cosmos DB.Select a geographic location to host your Azure Cosmos DB account. Usare la località più vicina agli utenti per offrire loro la massima velocità di accesso ai dati.Use the location that's closest to your users to give them the fastest access to data.

    È possibile lasciare i valori predefiniti (Disabilita) per le opzioni Ridondanza geografica e Scritture in più aree per evitare ulteriori addebiti di UR.You can leave the Geo-Redundancy and Multi-region Writes options at their default values (Disable) to avoid additional RU charges. È possibile ignorare le sezioni Rete e Tag.You can skip the Network and Tags sections.

  4. Selezionare Rivedi+Crea.Select Review+Create. Dopo aver completato la convalida, selezionare Crea per creare l'account.After the validation is complete, select Create to create the account.

    Pagina del nuovo account per Azure Cosmos DB

  5. La creazione dell'account richiede alcuni minuti.It takes a few minutes to create the account. Verrà visualizzato il messaggio La distribuzione è in corso.You'll see a message that states Your deployment is underway. Attendere il completamento della distribuzione e quindi selezionare Vai alla risorsa.Wait for the deployment to finish and then select Go to resource.

    Riquadro Notifiche del portale di Azure

Creare un progetto di console .NETCreate a .NET console project

In Visual Studio creare una nuova applicazione console .NET.In Visual Studio, create a new .NET console application. La procedura seguente illustra come creare un'applicazione console in Visual Studio 2019.The following steps show you how to create a console application in Visual Studio 2019. È possibile usare la libreria di tabelle di Azure Cosmos DB in qualsiasi tipo di applicazione .NET, ad esempio un servizio cloud o un'app Web di Azure, nonché in applicazioni desktop e per dispositivi mobili.You can use the Azure Cosmos DB Table Library in any type of .NET application, including an Azure cloud service or web app, and desktop and mobile applications. Per semplicità, in questa guida si usa un'applicazione console.In this guide, we use a console application for simplicity.

  1. Selezionare File > Nuovo > Progetto.Select File > New > Project.

  2. Scegliere App console (.NET Core), quindi selezionare Avanti.Choose Console App (.NET Core), and then select Next.

  3. Nel campo Nome progetto immettere un nome per l'applicazione, ad esempio CosmosTableSamples.In the Project name field, enter a name for your application, such as CosmosTableSamples. (È possibile immettere un nome diverso in base alle esigenze).(You can provide a different name as needed.)

  4. Selezionare Create.Select Create.

Tutti gli esempi di codice in questo esempio possono essere aggiunti al metodo Main() del file Program.cs dell'applicazione console.All code examples in this sample can be added to the Main() method of your console application's Program.cs file.

Installare il pacchetto NuGet necessarioInstall the required NuGet package

Per ottenere il pacchetto NuGet, seguire questa procedura:To obtain the NuGet package, follow these steps:

  1. Fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni e scegliere Gestisci pacchetti NuGet.Right-click your project in Solution Explorer and choose Manage NuGet Packages.

  2. Cercare online Microsoft.Azure.Cosmos.Table, Microsoft.Extensions.Configuration, Microsoft.Extensions.Configuration.Json, Microsoft.Extensions.Configuration.Binder e selezionare Install (Installa) per installare la libreria di tabelle Microsoft Azure Cosmos DB.Search online for Microsoft.Azure.Cosmos.Table, Microsoft.Extensions.Configuration, Microsoft.Extensions.Configuration.Json, Microsoft.Extensions.Configuration.Binder and select Install to install the Microsoft Azure Cosmos DB Table Library.

Configurare la stringa di connessione di archiviazioneConfigure your storage connection string

  1. Dal portale di Azure passare all'account Azure Cosmos o all'account di archiviazione tabelle.From the Azure portal, navigate to your Azure Cosmos account or the Table Storage account.

  2. Aprire il riquadro Stringa di connessione oppure Chiavi di accesso.Open the Connection String or Access keys pane. Usare il pulsante di copia sul lato destro della finestra per copiare la STRINGA DI CONNESSIONE PRIMARIA.Use the copy button on the right side of the window to copy the PRIMARY CONNECTION STRING.

    Visualizzare e copiare la STRINGA DI CONNESSIONE PRIMARIA nel riquadro Stringa di connessione

  3. Per configurare la stringa di connessione, in Visual Studio fare clic con il pulsante destro del mouse sul progetto CosmosTableSamples.To configure your connection string, from visual studio right click on your project CosmosTableSamples.

  4. Scegliere Aggiungi e quindi Nuovo elemento.Select Add and then New Item. Creare un nuovo file Settings.json con tipo File di configurazione JSON per TypeScript.Create a new file Settings.json with file type as TypeScript JSON Configuration File.

  5. Sostituire il codice nel file Settings.json con il codice seguente e assegnare la stringa di connessione principale:Replace the code in Settings.json file with the following code and assign your primary connection string:

    {
    "StorageConnectionString": <Primary connection string of your Azure Cosmos DB account>
    }
    
  6. Fare clic con il pulsante destro del mouse sul progetto CosmosTableSamples.Right click on your project CosmosTableSamples. Scegliere Aggiungi, Nuovo elemento e aggiungere una classe denominata AppSettings.cs.Select Add, New Item and add a class named AppSettings.cs.

  7. Aggiungere il codice seguente al file AppSettings.cs.Add the following code to the AppSettings.cs file. Questo file legge la stringa di connessione dal file Settings.json e la assegna al parametro di configurazione:This file reads the connection string from Settings.json file and assigns it to the configuration parameter:

    namespace CosmosTableSamples
    {
     using Microsoft.Extensions.Configuration;
     public class AppSettings
     {
         public string StorageConnectionString { get; set; }
         public static AppSettings LoadAppSettings()
         {
             IConfigurationRoot configRoot = new ConfigurationBuilder()
                 .AddJsonFile("Settings.json")
                 .Build();
             AppSettings appSettings = configRoot.Get<AppSettings>();
             return appSettings;
         }
     }
    }
    

Analizzare e convalidare i dettagli della connessioneParse and validate the connection details

  1. Fare clic con il pulsante destro del mouse sul progetto CosmosTableSamples.Right click on your project CosmosTableSamples. Scegliere Aggiungi, Nuovo elemento e aggiungere una classe denominata Common.cs.Select Add, New Item and add a class named Common.cs. Si scriverà il codice per convalidare i dettagli della connessione e creare una tabella in questa classe.You will write code to validate the connection details and create a table within this class.

  2. Definire un metodo CreateStorageAccountFromConnectionString come mostrato di seguito.Define a method CreateStorageAccountFromConnectionString as shown below. Questo metodo analizzerà i dettagli della stringa di connessione e verificherà che il nome dell'account e i dettagli delle chiavi dell'account specificati nel file "Settings.json" siano validi.This method will parse the connection string details and validate that the account name and account key details provided in the "Settings.json" file are valid.

    public static CloudStorageAccount CreateStorageAccountFromConnectionString(string storageConnectionString)
     {
             CloudStorageAccount storageAccount;
             try
             {
                 storageAccount = CloudStorageAccount.Parse(storageConnectionString);
             }
             catch (FormatException)
             {
                 Console.WriteLine("Invalid storage account information provided. Please confirm the AccountName and AccountKey are valid in the app.config file - then restart the application.");
                 throw;
             }
             catch (ArgumentException)
             {
                 Console.WriteLine("Invalid storage account information provided. Please confirm the AccountName and AccountKey are valid in the app.config file - then restart the sample.");
                 Console.ReadLine();
                 throw;
             }
    
             return storageAccount;
         }
    

Creare una tabellaCreate a Table

La classe CloudTableClient consente di recuperare le tabelle e le entità archiviate nell'archivio tabelle.The CloudTableClient class enables you to retrieve tables and entities stored in Table storage. Dato che non sono presenti tabelle nell'account API Tabella di Cosmos DB, si aggiungerà il metodo CreateTableAsync alla classe Common.cs per creare una tabella:Because we don’t have any tables in the Cosmos DB Table API account, let’s add the CreateTableAsync method to the Common.cs class to create a table:

public static async Task<CloudTable> CreateTableAsync(string tableName)
  {
    string storageConnectionString = AppSettings.LoadAppSettings().StorageConnectionString;

    // Retrieve storage account information from connection string.
    CloudStorageAccount storageAccount = CreateStorageAccountFromConnectionString(storageConnectionString);

    // Create a table client for interacting with the table service
    CloudTableClient tableClient = storageAccount.CreateCloudTableClient(new TableClientConfiguration());

    Console.WriteLine("Create a Table for the demo");

    // Create a table client for interacting with the table service 
    CloudTable table = tableClient.GetTableReference(tableName);
    if (await table.CreateIfNotExistsAsync())
    {
      Console.WriteLine("Created Table named: {0}", tableName);
    }
    else
    {
      Console.WriteLine("Table {0} already exists", tableName);
    }

    Console.WriteLine();
    return table;
}

Definire l'entitàDefine the entity

Per eseguire il mapping di entità a oggetti C#, viene utilizzata una classe personalizzata derivata da TableEntity.Entities map to C# objects by using a custom class derived from TableEntity. Per aggiungere un'entità a una classe, creare una classe che definisca le proprietà dell'entità.To add an entity to a table, create a class that defines the properties of your entity.

Fare clic con il pulsante destro del mouse sul progetto CosmosTableSamples.Right click on your project CosmosTableSamples. Scegliere Aggiungi, Nuova cartella e assegnare il nome Model.Select Add, New Folder and name it as Model. All'interno della cartella Model aggiungere una classe denominata CustimerEntity.cs e aggiungere il codice seguente alla classe.Within the Model folder add a class named CustomerEntity.cs and add the following code to it.

namespace CosmosTableSamples.Model
{
    using Microsoft.Azure.Cosmos.Table;
    public class CustomerEntity : TableEntity
    {
        public CustomerEntity()
        {
        }

        public CustomerEntity(string lastName, string firstName)
        {
            PartitionKey = lastName;
            RowKey = firstName;
        }

        public string Email { get; set; }
        public string PhoneNumber { get; set; }
    }
}

Questo codice consente di definire una classe di entità che usa il nome e il cognome del cliente rispettivamente come chiave di riga e chiave di partizione.This code defines an entity class that uses the customer's first name as the row key and last name as the partition key. La partizione e la chiave di riga di un'entità consentono di identificare in modo univoco l'entità nella tabella.Together, an entity's partition and row key uniquely identify it in the table. 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.Entities with the same partition key can be queried faster than entities with different partition keys but using diverse partition keys allows for greater scalability of parallel operations. Le entità da archiviare nelle tabelle devono essere di un tipo supportato, ad esempio derivato dalla classe TableEntity.Entities to be stored in tables must be of a supported type, for example derived from the TableEntity class. Le proprietà dell'entità da archiviare in una tabella devono essere proprietà pubbliche del tipo e supportare sia l'ottenimento che l'impostazione di valori.Entity properties you'd like to store in a table must be public properties of the type, and support both getting and setting of values. Il tipo di entità deve inoltre esporre un costruttore senza parametri.Also, your entity type must expose a parameter-less constructor.

Inserire o unire un'entitàInsert or merge an entity

Il codice di esempio seguente crea un oggetto entità e lo aggiunge alla tabella.The following code example creates an entity object and adds it to the table. Il metodo InsertOrMerge nella classe TableOperation viene usato per inserire o unire un'entità.The InsertOrMerge method within the TableOperation class is used to insert or merge an entity. Il metodo CloudTable.ExecuteAsync viene chiamato per eseguire l'operazione.The CloudTable.ExecuteAsync method is called to execute the operation.

Fare clic con il pulsante destro del mouse sul progetto CosmosTableSamples.Right click on your project CosmosTableSamples. Scegliere Aggiungi, Nuovo elemento e aggiungere una classe denominata SamplesUtils.cs.Select Add, New Item and add a class named SamplesUtils.cs. Questa classe archivia tutto il codice richiesto per eseguire operazioni CRUD sulle entità.This class stores all the code required to perform CRUD operations on the entities.

public static async Task<CustomerEntity> InsertOrMergeEntityAsync(CloudTable table, CustomerEntity entity)
    {
      if (entity == null)
    {
       throw new ArgumentNullException("entity");
    }
    try
    {
       // Create the InsertOrReplace table operation
       TableOperation insertOrMergeOperation = TableOperation.InsertOrMerge(entity);

       // Execute the operation.
       TableResult result = await table.ExecuteAsync(insertOrMergeOperation);
       CustomerEntity insertedCustomer = result.Result as CustomerEntity;
        
        // Get the request units consumed by the current operation. RequestCharge of a TableResult is only applied to Azure CosmoS DB 
        if (result.RequestCharge.HasValue)
          {
            Console.WriteLine("Request Charge of InsertOrMerge Operation: " + result.RequestCharge);
          }

        return insertedCustomer;
        }
        catch (StorageException e)
        {
          Console.WriteLine(e.Message);
          Console.ReadLine();
          throw;
        }
    }

Ottenere un'entità da una partizioneGet an entity from a partition

È possibile ottenere entità da una partizione usando il metodo Retrieve nella classe TableOperation.You can get entity from a partition by using the Retrieve method under the TableOperation class. Il codice di esempio seguente ottiene la chiave di partizione, la chiave di riga l'indirizzo e-mail e il numero di telefono di un'entità cliente.The following code example gets the partition key row key, email and phone number of a customer entity. Questo esempio stampa anche le unità richiesta utilizzate per eseguire query per l'entità.This example also prints out the request units consumed to query for the entity. Per eseguire query per l'entità, aggiungere il codice seguente al file SamplesUtils.cs:To query for an entity, append the following code to SamplesUtils.cs file:

public static async Task<CustomerEntity> RetrieveEntityUsingPointQueryAsync(CloudTable table, string partitionKey, string rowKey)
    {
      try
      {
        TableOperation retrieveOperation = TableOperation.Retrieve<CustomerEntity>(partitionKey, rowKey);
        TableResult result = await table.ExecuteAsync(retrieveOperation);
        CustomerEntity customer = result.Result as CustomerEntity;
        if (customer != null)
        {
          Console.WriteLine("\t{0}\t{1}\t{2}\t{3}", customer.PartitionKey, customer.RowKey, customer.Email, customer.PhoneNumber);
        }

        // Get the request units consumed by the current operation. RequestCharge of a TableResult is only applied to Azure CosmoS DB 
        if (result.RequestCharge.HasValue)
        {
           Console.WriteLine("Request Charge of Retrieve Operation: " + result.RequestCharge);
        }

        return customer;
        }
        catch (StorageException e)
        {
           Console.WriteLine(e.Message);
           Console.ReadLine();
           throw;
        }
    }

Eliminare un'entitàDelete an entity

Per eliminare facilmente un'entità dopo averla recuperata, è possibile usare lo stesso modello illustrato per aggiornare un'entità.You can easily delete an entity after you have retrieved it by using the same pattern shown for updating an entity. Il codice seguente consente di recuperare ed eliminare un'entità customer.The following code retrieves and deletes a customer entity. Per eliminare un'entità, aggiungere il codice seguente al file SamplesUtils.cs:To delete an entity, append the following code to SamplesUtils.cs file:

public static async Task DeleteEntityAsync(CloudTable table, CustomerEntity deleteEntity)
   {
     try
     {
        if (deleteEntity == null)
     {
        throw new ArgumentNullException("deleteEntity");
     }

    TableOperation deleteOperation = TableOperation.Delete(deleteEntity);
    TableResult result = await table.ExecuteAsync(deleteOperation);

    // Get the request units consumed by the current operation. RequestCharge of a TableResult is only applied to Azure CosmoS DB 
    if (result.RequestCharge.HasValue)
    {
       Console.WriteLine("Request Charge of Delete Operation: " + result.RequestCharge);
    }

    }
    catch (StorageException e)
    {
        Console.WriteLine(e.Message);
        Console.ReadLine();
        throw;
    }
}

Eseguire le operazioni CRUD sui dati di esempioExecute the CRUD operations on sample data

Dopo aver definito i metodi per creare tabelle e inserire o unire entità, eseguire questi metodi sui dati di esempio.After you define the methods to create table, insert or merge entities, run these methods on the sample data. A tale scopo, fare clic con il pulsante destro del mouse sul progetto CosmosTableSamples.To do so, right click on your project CosmosTableSamples. Selezionare Aggiungi, Nuovo elemento e aggiungere una classe denominata BasicSamples.cs, quindi aggiungere il codice seguente alla classe.Select Add, New Item and add a class named BasicSamples.cs and add the following code to it. Questo codice crea una tabella e aggiunge entità al suo interno.This code creates a table, adds entities to it. Se si vuole eliminare l'entità e la tabella alla fine del progetto, rimuovere i commenti dai metodi table.DeleteIfExistsAsync() e SamplesUtils.DeleteEntityAsync(table, customer) nel codice seguente:If you wish to delete the entity and table at the end of the project remove the comments from table.DeleteIfExistsAsync() and SamplesUtils.DeleteEntityAsync(table, customer) methods from the following code:

using System;
namespace CosmosTableSamples
{
    using System.Threading.Tasks;
    using Microsoft.Azure.Cosmos.Table;
    using Model;

    class BasicSamples
    {
        public async Task RunSamples()
        {
            Console.WriteLine("Azure Cosmos DB Table - Basic Samples\n");
            Console.WriteLine();

            string tableName = "demo" + Guid.NewGuid().ToString().Substring(0, 5);

            // Create or reference an existing table
            CloudTable table = await Common.CreateTableAsync(tableName);

            try
            {
                // Demonstrate basic CRUD functionality 
                await BasicDataOperationsAsync(table);
            }
            finally
            {
                // Delete the table
                // await table.DeleteIfExistsAsync();
            }
        }

        private static async Task BasicDataOperationsAsync(CloudTable table)
        {
            // Create an instance of a customer entity. See the Model\CustomerEntity.cs for a description of the entity.
            CustomerEntity customer = new CustomerEntity("Harp", "Walter")
            {
                Email = "Walter@contoso.com",
                PhoneNumber = "425-555-0101"
            };

            // Demonstrate how to insert the entity
            Console.WriteLine("Insert an Entity.");
            customer = await SamplesUtils.InsertOrMergeEntityAsync(table, customer);

            // Demonstrate how to Update the entity by changing the phone number
            Console.WriteLine("Update an existing Entity using the InsertOrMerge Upsert Operation.");
            customer.PhoneNumber = "425-555-0105";
            await SamplesUtils.InsertOrMergeEntityAsync(table, customer);
            Console.WriteLine();

            // Demonstrate how to Read the updated entity using a point query 
            Console.WriteLine("Reading the updated Entity.");
            customer = await SamplesUtils.RetrieveEntityUsingPointQueryAsync(table, "Harp", "Walter");
            Console.WriteLine();

            // Demonstrate how to Delete an entity
            //Console.WriteLine("Delete the entity. ");
            //await SamplesUtils.DeleteEntityAsync(table, customer);
            //Console.WriteLine();
        }
    }
}

Il codice precedente crea una tabella che inizia con "demo" e il GUID generato viene aggiunto al nome della tabella.The previous code creates a table that starts with “demo” and the generated GUID is appended to the table name. Aggiunge quindi un'entità cliente con nome e cognome "Harp Walter" e in seguito aggiorna il numero di telefono di questo utente.It then adds a customer entity with first and last name as “Harp Walter” and later updates the phone number of this user.

In questa esercitazione è stato compilato il codice per eseguire operazioni CRUD di base sui dati archiviati nell'account API Tabella.In this tutorial, you built code to perform basic CRUD operations on the data stored in Table API account. È anche possibile eseguire operazioni avanzate quali inserimento di dati in batch, query su tutti i dati all'interno di una partizione, query su un intervallo di dati all'interno di una partizione, elencare le tabelle nell'account i cui nomi iniziano con il prefisso specificato.You can also perform advanced operations such as – batch inserting data, query all the data within a partition, query a range of data within a partition, Lists tables in the account whose names begin with the specified prefix. È possibile scaricare l'esempio completo dal repository GitHub azure-cosmos-table-dotnet-core-getting-started.You can download the complete sample form azure-cosmos-table-dotnet-core-getting-started GitHub repository. La classe AdvancedSamples.cs ha più operazioni che è possibile eseguire sui dati.The AdvancedSamples.cs class has more operations that you can perform on the data.

Eseguire il progettoRun the project

Compilare ora la soluzione e premere F5 per eseguire il progetto.Now build the solution and press F5 to run the project. Quando viene eseguito il progetto, nel prompt dei comandi verrà visualizzato l'output seguente:When the project is run, you will see the following output in the command prompt:

Output del prompt dei comandi

Se viene visualizzato un errore che indica che non è stato trovato il file Settings.json durante l'esecuzione del progetto, è possibile risolvere il problema aggiungendo la voce XML seguente alle impostazioni del progetto.If you receive an error that says Settings.json file can’t be found when running the project, you can resolve it by adding the following XML entry to the project settings. Fare clic con il pulsante destro del mouse su CosmosTableSamples, scegliere il comando di modifica di CosmosTableSamples.csproj e aggiungere l'elemento itemGroup seguente:Right click on CosmosTableSamples, select Edit CosmosTableSamples.csproj and add the following itemGroup:

  <ItemGroup>
    <None Update="Settings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
  </ItemGroup>

Ora è possibile accedere al portale di Azure e verificare che i dati siano presenti nella tabella.Now you can sign into the Azure portal and verify that the data exists in the table.

Risultati nel portale

Passaggi successiviNext steps

È ora possibile passare all'esercitazione successiva per informazioni su come eseguire la migrazione dei dati all'account API Tabella di Azure Cosmos DB.You can now proceed to the next tutorial and learn how to migrate data to Azure Cosmos DB Table API account.