Bien démarrer avec l’API Table d’Azure Cosmos DB et le stockage Table Azure à l’aide du SDK .NETGet started with Azure Cosmos DB Table API and Azure Table storage using the .NET SDK

Conseil

Dans cet article, le contenu s’applique au stockage Table Azure et à l’API Azure Cosmos DB Table.The content in this article applies to Azure Table storage and the Azure Cosmos DB Table API. L’API Azure Cosmos DB Table est une offre premium de stockage de tables proposant des tables optimisées pour le débit, la distribution globale et les index secondaires automatiques.The Azure Cosmos DB Table API is a premium offering for table storage that offers throughput-optimized tables, global distribution, and automatic secondary indexes.

Vous pouvez utiliser l’API Table d’Azure Cosmos DB ou le stockage Table Azure pour stocker des données NoSQL structurées dans le cloud, en fournissant un magasin de clés/attributs avec une conception sans schéma.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. Comme l’API Table d’Azure Cosmos DB et le stockage Table Azure présentent une conception sans schéma, il est facile d’adapter vos données en fonction des besoins de votre application.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. Vous pouvez utiliser l’API Table d’Azure Cosmos DB et le stockage Table Azure pour stocker des jeux de données flexibles, comme des données utilisateur pour des applications web, des carnets d’adresses, des informations sur les appareils ou d’autres types de métadonnées requis par votre service.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.

Ce tutoriel décrit un exemple qui montre comment utiliser la bibliothèque Microsoft Azure Cosmos DB Table pour .NET dans des scénarios utilisant l’API Table d’Azure Cosmos DB et le stockage Table 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. Vous devez utiliser la connexion propre au service Azure.You must use the connection specific to the Azure service. Ces scénarios sont explorés à l’aide d’exemples en C# qui montrent comment créer des tables, ajouter ou mettre à jour des données, interroger des données et supprimer des tables.These scenarios are explored using C# examples that illustrate how to create tables, insert/ update data, query data and delete the tables.

PrérequisPrerequisites

Vous aurez besoin des éléments suivants pour suivre cet exemple :You need the following to complete this sample successfully:

Créer un compte d’API de table Azure Cosmos DBCreate an Azure Cosmos DB Table API account

  1. Dans une nouvelle fenêtre du navigateur, connectez-vous au portail Azure.In a new browser window, sign in to the Azure portal.

  2. Dans le volet de navigation gauche, sélectionnez Créer une ressource.In the left navigation pane, select Create a resource. Sélectionnez Bases de données, puis Azure Cosmos DB.Select Databases and then select Azure Cosmos DB.

    Capture d’écran du portail Azure, mettant en surbrillance l’option Plus de services et Azure Cosmos DB

  3. Dans la page Créer un compte Azure Cosmos DB, entrez les paramètres du nouveau compte Azure Cosmos DB :On the Create Azure Cosmos DB Account page, enter the settings for the new Azure Cosmos DB account:

    ParamètreSetting ValeurValue DescriptionDescription
    SubscriptionSubscription Votre abonnementYour subscription Sélectionnez l’abonnement Azure que vous souhaitez utiliser pour ce compte Azure Cosmos DB.Select the Azure subscription that you want to use for this Azure Cosmos DB account.
    Groupe de ressourcesResource Group CréationCreate new

    Entrez ensuite le même nom unique que celui fourni dans l’IDThen enter the same unique name as provided in ID
    Sélectionnez Créer nouveau.Select Create new. Entrez ensuite le nom du nouveau groupe de ressources pour votre compte.Then enter a new resource group name for your account. Pour rester simple, utilisez le même nom que celui de votre ID.For simplicity, use the same name as your ID.
    Nom du compteAccount Name Entrez un nom uniqueEnter a unique name Entrez un nom unique pour identifier votre compte Azure Cosmos DB.Enter a unique name to identify your Azure Cosmos DB account.

    L’ID peut uniquement utiliser des lettres minuscules, des chiffres et le caractère de trait d’union (-).The ID can use only lowercase letters, numbers, and the hyphen (-) character. Il doit comprendre entre 3 et 31 caractères.It must be between 3 and 31 characters long.
    APIAPI table AzureAzure Table L’API détermine le type de compte à créer.The API determines the type of account to create. Azure Cosmos DB fournit cinq API : Core(SQL) pour les bases de données orientées document, Gremlin pour les bases de données de graphe, MongoDB pour les bases de données de document, Table Azure et Cassandra.Azure Cosmos DB provides five APIs: Core(SQL) for document databases, Gremlin for graph databases, MongoDB for document databases, Azure Table, and Cassandra. Actuellement, vous devez créer un compte distinct pour chaque API.Currently, you must create a separate account for each API.

    Sélectionnez Table Azure, car ce guide de démarrage rapide vous permet de créer une table qui fonctionne avec l’API Table.Select Azure Table because in this quickstart you're creating a table that works with the Table API.

    Découvrez plus d’informations sur l’API Table.Learn more about the Table API.
    LocationLocation Sélectionner la région la plus proche de vos utilisateursSelect the region closest to your users Sélectionnez la zone géographique dans laquelle héberger votre compte Azure Cosmos DB.Select a geographic location to host your Azure Cosmos DB account. Utilisez l’emplacement le plus proche de vos utilisateurs pour leur donner l’accès le plus rapide aux données.Use the location that's closest to your users to give them the fastest access to data.

    Vous pouvez laisser les options Géoredondance et Écritures multirégions avec leur valeur par défaut (Désactiver) pour éviter des frais d’unités de requête supplémentaires.You can leave the Geo-Redundancy and Multi-region Writes options at their default values (Disable) to avoid additional RU charges. Vous pouvez ignorer les sections Réseau et Balises.You can skip the Network and Tags sections.

  4. Sélectionnez Vérifier + créer.Select Review+Create. Une fois la validation terminée, sélectionnez Créer pour créer le compte.After the validation is complete, select Create to create the account.

    Page de nouveau compte pour Azure Cosmos DB

  5. La création du compte prend quelques minutes.It takes a few minutes to create the account. Un message vous indique que Votre déploiement est en cours.You'll see a message that states Your deployment is underway. Attendez la fin du déploiement, puis sélectionnez Accéder à la ressource.Wait for the deployment to finish and then select Go to resource.

    Volet Notifications du portail Azure

Créer un projet de console .NETCreate a .NET console project

Dans Visual Studio, créez une application console .NET.In Visual Studio, create a new .NET console application. Les étapes suivantes vous montrent comment créer une application console dans Visual Studio 2019.The following steps show you how to create a console application in Visual Studio 2019. Vous pouvez utiliser la bibliothèque Azure Cosmos DB Table dans n’importe quel type d’application .NET, y compris un service cloud Azure, une application web, une application de bureau ou une application mobile.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. Dans ce guide, nous utilisons une application console pour plus de simplicité.In this guide, we use a console application for simplicity.

  1. Sélectionnez Fichier > Nouveau > Projet.Select File > New > Project.

  2. Choisissez Application console (.NET Core) , puis sélectionnez Suivant.Choose Console App (.NET Core), and then select Next.

  3. Dans le champ Nom de projet, entrez un nom pour votre application, tel que CosmosTableSamples.In the Project name field, enter a name for your application, such as CosmosTableSamples. Vous pouvez fournir un autre nom.(You can provide a different name as needed.)

  4. Sélectionnez Create (Créer).Select Create.

Tous les exemples de code figurant dans cette démonstration peuvent être ajoutés à la méthode Main() dans le fichier Program.cs de votre application console.All code examples in this sample can be added to the Main() method of your console application's Program.cs file.

Installer le package NuGet nécessaireInstall the required NuGet package

Pour obtenir le package NuGet, effectuez les étapes suivantes :To obtain the NuGet package, follow these steps:

  1. Cliquez avec le bouton droit sur votre projet dans l’Explorateur de solutions, puis sélectionnez Gérer les packages NuGet.Right-click your project in Solution Explorer and choose Manage NuGet Packages.

  2. Recherchez en ligne Microsoft.Azure.Cosmos.Table, Microsoft.Extensions.Configuration, Microsoft.Extensions.Configuration.Json, Microsoft.Extensions.Configuration.Binder, puis sélectionnez Installer pour installer la bibliothèque Microsoft Azure Cosmos DB Table.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.

Configurer votre chaîne de connexion de stockageConfigure your storage connection string

  1. À partir du Portail Azure, accédez à votre compte Azure Cosmos ou au compte Stockage Table.From the Azure portal, navigate to your Azure Cosmos account or the Table Storage account.

  2. Ouvrez le volet Chaîne de connexion ou Clés d’accès.Open the Connection String or Access keys pane. Utilisez les boutons de copie sur le côté droit de la fenêtre pour copier la CHAÎNE DE CONNEXION PRINCIPALE.Use the copy button on the right side of the window to copy the PRIMARY CONNECTION STRING.

    Afficher et copier la CHAÎNE DE CONNEXION PRINCIPALE dans le volet Chaîne de connexion

  3. Pour configurer votre chaîne de connexion, à partir de Visual Studio, cliquez avec le bouton droit sur votre projet CosmosTableSamples.To configure your connection string, from visual studio right click on your project CosmosTableSamples.

  4. Sélectionnez Ajouter, puis Nouvel élément.Select Add and then New Item. Créez un fichier Settings.json avec le type de fichier config JSON TypeScript.Create a new file Settings.json with file type as TypeScript JSON Configuration File.

  5. Remplacez le code dans le fichier Settings.json par le code suivant et affectez la chaîne de connexion 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. Cliquez avec le bouton droit sur votre projet CosmosTableSamples.Right click on your project CosmosTableSamples. Sélectionnez Ajouter, Nouvel élément et ajoutez une classe nommée AppSettings.cs.Select Add, New Item and add a class named AppSettings.cs.

  7. Ajoutez le code suivant au fichier AppSettings.cs.Add the following code to the AppSettings.cs file. Ce fichier lit la chaîne de connexion contenue dans le fichier Settings.json et l’affecte au paramètre de configuration :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;
         }
     }
    }
    

Analyser et valider les informations de connexionParse and validate the connection details

  1. Cliquez avec le bouton droit sur votre projet CosmosTableSamples.Right click on your project CosmosTableSamples. Sélectionnez Ajouter, Nouvel élément et ajoutez une classe nommée Common.cs.Select Add, New Item and add a class named Common.cs. Vous allez écrire le code qui valide les informations de connexion et crée une table au sein de cette classe.You will write code to validate the connection details and create a table within this class.

  2. Définissez une méthode CreateStorageAccountFromConnectionString comme indiqué ci-dessous.Define a method CreateStorageAccountFromConnectionString as shown below. Cette méthode analyse les informations de la chaîne de connexion et vérifie que le nom et la clé du compte fournis dans le fichier « Settings.json » sont corrects.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.

using System;

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

   public class Common
   {
       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;
       }
   }
}

Créer une tableCreate a Table

La classe CloudTableClient vous permet de récupérer des tables et entités stockées dans Table Storage.The CloudTableClient class enables you to retrieve tables and entities stored in Table storage. Étant donné qu’il n’y a pas de tables dans le compte d’API Table Cosmos DB, nous allons en créer une en ajoutant la méthode CreateTableAsync à la classe Common.cs :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;
}

Définir l’entitéDefine the entity

Les entités mappent vers les objets C# en utilisant une classe personnalisée dérivée d’une TableEntity.Entities map to C# objects by using a custom class derived from TableEntity. Pour ajouter une entité à une table, créez une classe définissant les propriétés de votre entité.To add an entity to a table, create a class that defines the properties of your entity.

Cliquez avec le bouton droit sur votre projet CosmosTableSamples.Right click on your project CosmosTableSamples. Sélectionnez Ajouter, Nouveau dossier et nommez le dossier Model (Modèle).Select Add, New Folder and name it as Model. Dans le dossier Model, ajoutez une classe nommée CustomerEntity.cs et ajoutez-y le code suivant.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; }
    }
}

Ce code définit une classe d’entité où le prénom et le nom de famille du client sont utilisés en tant que clé de ligne et clé de partition, respectivement.This code defines an entity class that uses the customer's first name as the row key and last name as the partition key. Ensemble, les clés de partition et de ligne d’une entité l’identifient de façon unique dans la table.Together, an entity's partition and row key uniquely identify it in the table. Les requêtes sur des entités ayant la même clé de partition sont plus rapides que celles effectuées sur des entités qui n’ont pas la même, mais l’utilisation de clés de partition différentes améliore la scalabilité des opérations parallèles.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. Les entités à stocker dans des tables doivent être d’un type pris en charge, par exemple dérivé de la classe TableEntity.Entities to be stored in tables must be of a supported type, for example derived from the TableEntity class. Les propriétés de l’entité à stocker dans une table doivent être des propriétés publiques du type et prendre en charge la récupération et la définition de valeurs.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. De plus, le type d’entité doit exposer un constructeur sans paramètre.Also, your entity type must expose a parameter-less constructor.

Insérer ou fusionner une entitéInsert or merge an entity

L’exemple de code suivant crée un objet entité et l’ajoute à la table.The following code example creates an entity object and adds it to the table. La méthode InsertOrMerge dans la classe TableOperation s’utilise pour insérer ou fusionner une entité.The InsertOrMerge method within the TableOperation class is used to insert or merge an entity. La méthode CloudTable.ExecuteAsync est appelée pour exécuter l’opération.The CloudTable.ExecuteAsync method is called to execute the operation.

Cliquez avec le bouton droit sur votre projet CosmosTableSamples.Right click on your project CosmosTableSamples. Sélectionnez Ajouter, Nouvel élément et ajoutez une classe nommée SamplesUtils.cs.Select Add, New Item and add a class named SamplesUtils.cs. Cette classe stocke tout le code requis pour effectuer des opérations CRUD sur les entités.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;
     }
 }

Obtenir une entité à partir d’une partitionGet an entity from a partition

Vous pouvez obtenir une entité à partir d’une partition en utilisant la méthode Retrieve dans la classe TableOperation.You can get entity from a partition by using the Retrieve method under the TableOperation class. L’exemple de code suivant obtient la clé de ligne de la clé de partition, l’e-mail et le numéro de téléphone d’une entité client.The following code example gets the partition key row key, email and phone number of a customer entity. Cet exemple affiche également les unités de requête consommées pour obtenir l’entité.This example also prints out the request units consumed to query for the entity. Pour rechercher une entité, ajoutez le code suivant au fichier 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;
        }
    }

Suppression d’une entitéDelete an entity

Il est facile de supprimer une entité après l’avoir récupérée. Il suffit pour cela d’utiliser la procédure suivie pour la mise à jour d’une entité.You can easily delete an entity after you have retrieved it by using the same pattern shown for updating an entity. Le code suivant extrait et supprime une entité de client.The following code retrieves and deletes a customer entity. Pour supprimer une entité, ajoutez le code suivant au fichier 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;
    }
}

Exécuter les opérations CRUD sur les exemples de donnéesExecute the CRUD operations on sample data

Après avoir défini les méthodes pour créer une table et ajouter ou fusionner des entités, exécutez-les sur les exemples de données.After you define the methods to create table, insert or merge entities, run these methods on the sample data. Pour ce faire, cliquez avec le bouton droit sur votre projet CosmosTableSamples.To do so, right click on your project CosmosTableSamples. Sélectionnez Ajouter, Nouvel élément et ajoutez une classe nommée BasicSamples.cs, puis ajoutez-y le code suivant.Select Add, New Item and add a class named BasicSamples.cs and add the following code to it. Ce code crée une table et y ajoute des entités.This code creates a table, adds entities to it. Si vous souhaitez supprimer l’entité et la table à la fin du projet, supprimez les commentaires des méthodes table.DeleteIfExistsAsync() et SamplesUtils.DeleteEntityAsync(table, customer) dans le code suivant :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();
        }
    }
}

Le code précédent crée une table dont le nom est composé du préfixe « demo », suivi du GUID généré.The previous code creates a table that starts with “demo” and the generated GUID is appended to the table name. Il ajoute ensuite une entité client avec le nom « Harp » et le prénom « Walter », puis met à jour le numéro de téléphone de cet utilisateur.It then adds a customer entity with first and last name as “Harp Walter” and later updates the phone number of this user.

Dans ce tutoriel, vous avez créé le code nécessaire pour effectuer des opérations CRUD de base sur les données stockées dans un compte d’API Table.In this tutorial, you built code to perform basic CRUD operations on the data stored in Table API account. Vous pouvez aussi effectuer diverses opérations avancées, par exemple, ajouter des données par lot, interroger toutes les données d’une partition, interroger une plage de données d’une partition et lister les tables du compte dont les noms commencent par le préfixe spécifié.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. Vous pouvez télécharger l’exemple complet à partir du dépôt azure-cosmos-table-dotnet-core-getting-started sur GitHub.You can download the complete sample form azure-cosmos-table-dotnet-core-getting-started GitHub repository. La classe AdvancedSamples.cs permet d’effectuer davantage d’opérations sur les données.The AdvancedSamples.cs class has more operations that you can perform on the data.

Exécuter le projetRun the project

À partir de votre projet CosmosTableSamples.From your project CosmosTableSamples. Ouvrez la classe nommée Program.cs et ajoutez-lui le code suivant pour appeler BasicSamples quand le projet s’exécute.Open the class named Program.cs and add the following code to it for calling BasicSamples when the project runs.

using System;

namespace CosmosTableSamples
{
    class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Azure Cosmos Table Samples");
            BasicSamples basicSamples = new BasicSamples();
            basicSamples.RunSamples().Wait();
           
            Console.WriteLine();
            Console.WriteLine("Press any key to exit");
            Console.Read();
        }
    }
}

Maintenant, générez la solution et appuyez sur F5 pour exécuter le projet.Now build the solution and press F5 to run the project. Après l’exécution du projet, vous voyez la sortie suivante dans l’invite de commandes :When the project is run, you will see the following output in the command prompt:

Sortie de l’invite de commandes

Si vous voyez une erreur indiquant qu’un fichier Settings.json n’a pas été trouvé pendant l’exécution du projet, vous pouvez la résoudre en ajoutant l’entrée XML suivante dans les paramètres du projet.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. Cliquez avec le bouton droit sur CosmosTableSamples, sélectionnez Modifier CosmosTableSamples.csproj et ajoutez l’élément itemGroup suivant :Right click on CosmosTableSamples, select Edit CosmosTableSamples.csproj and add the following itemGroup:

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

Vous pouvez maintenant vous connecter au portail Azure et vérifier que les données existent bien dans la table.Now you can sign into the Azure portal and verify that the data exists in the table.

Résultats dans le portail

Étapes suivantesNext steps

Vous pouvez maintenant passer au tutoriel suivant pour découvrir comment migrer les données vers un compte d’API Table Azure Cosmos DB.You can now proceed to the next tutorial and learn how to migrate data to Azure Cosmos DB Table API account.