Aan de slag met Azure Cosmos DB Table-API en Azure Table-opslag met de .NET SDKGet started with Azure Cosmos DB Table API and Azure Table storage using the .NET SDK

Tip

De inhoud in dit artikel geldt voor Azure Table Storage en de tabel-API van Azure Cosmos DB.The content in this article applies to Azure Table storage and the Azure Cosmos DB Table API. De tabel-API van Azure Cosmos DB is een Premium-aanbieding tabelopslag die voor doorvoer geoptimaliseerde tabellen, globale distributie en automatische secundaire indexen biedt.The Azure Cosmos DB Table API is a premium offering for table storage that offers throughput-optimized tables, global distribution, and automatic secondary indexes.

U kunt de Azure Cosmos DB Table-API of Azure-tabel opslag gebruiken om gestructureerde NoSQL-gegevens op te slaan in de Cloud, waarbij u een sleutel/kenmerk opslag oplevert met een schema dat minder hoeft te worden ontworpen.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. Omdat Azure Cosmos DB Table-API en tabel opslag minder schema's zijn, is het eenvoudig om uw gegevens aan te passen aan de ontwikkeling van uw toepassing.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. U kunt Azure Cosmos DB Table-API of de tabel opslag gebruiken voor het opslaan van flexibele gegevens sets, zoals gebruikers gegevens voor webtoepassingen, adres boeken, apparaatgegevens of andere soorten meta gegevens die uw service nodig heeft.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.

In deze zelf studie wordt een voor beeld beschreven waarin wordt uitgelegd hoe u de Microsoft Azure Cosmos DB-tabel bibliotheek voor .net kunt gebruiken met de scenario's voor Azure Cosmos db table-API en Azure-tabel opslag.This tutorial describes a sample that shows you how to use the Microsoft Azure Cosmos DB Table Library for .NET with Azure Cosmos DB Table API and Azure Table storage scenarios. U moet de verbinding die specifiek is voor de Azure-service gebruiken.You must use the connection specific to the Azure service. Deze scenario's worden onderzocht met C#-voor beelden waarin wordt geïllustreerd hoe u tabellen maakt, gegevens invoegt/bijwerkt, gegevens opvraagt en de tabellen verwijdert.These scenarios are explored using C# examples that illustrate how to create tables, insert/ update data, query data and delete the tables.

VereistenPrerequisites

U hebt het volgende nodig voor dit voorbeeld:You need the following to complete this sample successfully:

Een Azure Cosmos DB Table-API-account makenCreate an Azure Cosmos DB Table API account

  1. Meld u in een nieuw browservenster aan bij Azure Portal.In a new browser window, sign in to the Azure portal.

  2. Selecteer in het menu links de optie een resource maken.In the left menu, select Create a resource.

    Een resource maken in de Azure Portal

  3. Selecteer op de pagina Nieuw de optie data bases > Azure Cosmos DB.On the New page, select Databases > Azure Cosmos DB.

    Het deelvenster Databases in Azure Portal

  4. Voer op de pagina Azure Cosmos DB account maken de instellingen voor het nieuwe Azure Cosmos DB-account in.On the Create Azure Cosmos DB Account page, enter the settings for the new Azure Cosmos DB account.

    InstellingSetting WaardeValue BeschrijvingDescription
    AbonnementSubscription Uw abonnementYour subscription Selecteer het Azure-abonnement dat u voor dit Azure Cosmos DB-account wilt gebruiken.Select the Azure subscription that you want to use for this Azure Cosmos DB account.
    ResourcegroepResource Group Nieuwe makenen vervolgens account naamCreate new, then Account Name Selecteer Nieuw maken.Select Create new. Voer vervolgens een nieuwe naam voor de resource groep voor uw account in.Then enter a new resource group name for your account. Gebruik de naam van uw Azure Cosmos DB-account voor eenvoud.For simplicity, use the same name as your Azure Cosmos DB account name.
    AccountnaamAccount Name Een unieke naamA unique name Voer een unieke naam in om uw Azure Cosmos DB-account te identificeren.Enter a unique name to identify your Azure Cosmos DB account.

    De account naam mag alleen kleine letters, cijfers en afbreek streepjes (-) gebruiken en moet tussen de 3 en 31 tekens lang zijn.The account name can use only lowercase letters, numbers, and hyphens (-), and must be between 3 and 31 characters long.
    APIAPI TabelTable De API bepaalt het type te maken account.The API determines the type of account to create. Azure Cosmos DB biedt vijf Api's: core (SQL) voor document databases, Gremlin voor Graph-data bases, MongoDB voor document databases, Azure Table en Cassandra.Azure Cosmos DB provides five APIs: Core (SQL) for document databases, Gremlin for graph databases, MongoDB for document databases, Azure Table, and Cassandra. U moet voor elke API een afzonderlijk account maken.You must create a separate account for each API.

    Selecteer Azure Table, omdat u in deze Snelstartgids een tabel maakt die werkt met de Table-API.Select Azure Table, because in this quickstart you are creating a table that works with the Table API.

    Meer informatie over de Table-API.Learn more about the Table API.
    LocatieLocation De regio het dichtst bij uw gebruikersThe region closest to your users Selecteer een geografische locatie waar u het Azure Cosmos DB-account wilt hosten.Select a geographic location to host your Azure Cosmos DB account. Gebruik de locatie die zich het dichtst bij uw gebruikers bevindt, zodat ze de snelst mogelijke toegang tot de gegevens hebben.Use the location that's closest to your users to give them the fastest access to the data.

    U kunt de schrijf opties voor geo-redundantie en meerdere regio's bij uitschakelen laten staan om extra kosten te voor komen en de secties netwerk en Tags over te slaan.You can leave the Geo-Redundancy and Multi-region Writes options at Disable to avoid additional charges, and skip the Network and Tags sections.

  5. Selecteer Beoordelen en maken.Select Review+Create. Nadat de validatie is voltooid, selecteert u maken om het account te maken.After the validation is complete, select Create to create the account.

    De pagina Nieuw account voor Azure Cosmos DB

  6. Het duurt enkele minuten om het account te maken.It takes a few minutes to create the account. Er wordt een bericht weer gegeven waarin staat dat uw implementatie zich bevindt.You'll see a message that states Your deployment is underway. Wacht tot de implementatie is voltooid en selecteer vervolgens Ga naar resource.Wait for the deployment to finish, and then select Go to resource.

    Het deel venster Azure Portal meldingen

Een .NET-console project makenCreate a .NET console project

Maak in Visual Studio een nieuwe .NET-console toepassing.In Visual Studio, create a new .NET console application. De volgende stappen laten zien hoe u een console toepassing maakt in Visual Studio 2019.The following steps show you how to create a console application in Visual Studio 2019. U kunt de Azure Cosmos DB-tabel bibliotheek gebruiken in elk type .NET-toepassing, waaronder een Azure-Cloud service of web-app, en desktop-en mobiele toepassingen.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. In deze gids gebruiken we een consoletoepassing voor de eenvoud.In this guide, we use a console application for simplicity.

  1. Selecteer bestand > Nieuw > project.Select File > New > Project.

  2. Kies console-app (.net core) en selecteer volgende.Choose Console App (.NET Core), and then select Next.

  3. Voer in het veld project naam een naam in voor uw toepassing, zoals CosmosTableSamples.In the Project name field, enter a name for your application, such as CosmosTableSamples. (U kunt desgewenst een andere naam opgeven.)(You can provide a different name as needed.)

  4. Selecteer Maken.Select Create.

Alle code voorbeelden in dit voor beeld kunnen worden toegevoegd aan de methode Main () van het Program.cs -bestand van uw console toepassing.All code examples in this sample can be added to the Main() method of your console application's Program.cs file.

Het vereiste NuGet-pakket installerenInstall the required NuGet package

Voer de volgende stappen uit om het NuGet-pakket te verkrijgen:To obtain the NuGet package, follow these steps:

  1. Klik met de rechtermuisknop op het project in Solution Explorer en kies NuGet-pakketten beheren.Right-click your project in Solution Explorer and choose Manage NuGet Packages.

  2. Zoek online naar Microsoft.Azure.Cosmos.Table, Microsoft.Extensions.Configuration, Microsoft.Extensions.Configuration.Json Microsoft.Extensions.Configuration.Binder en selecteer installeren om de Microsoft Azure Cosmos DB-tabel bibliotheek te installeren.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.

De opslagverbindingsreeks configurerenConfigure your storage connection string

  1. Ga vanuit het Azure Portalnaar uw Azure Cosmos-account of het Table Storage-account.From the Azure portal, navigate to your Azure Cosmos account or the Table Storage account.

  2. Open de verbindings reeks of het deel venster toegangs sleutels .Open the Connection String or Access keys pane. Gebruik de kopieerknop aan de rechterkant van het venster om de PRIMARY CONNECTION STRING te kopiëren.Use the copy button on the right side of the window to copy the PRIMARY CONNECTION STRING.

    De PRIMARY CONNECTION STRING in het deelvenster Verbindingsreeks weergeven en kopiëren

  3. Als u uw connection string wilt configureren, klikt u in Visual Studio met de rechter muisknop op uw project CosmosTableSamples.To configure your connection string, from visual studio right click on your project CosmosTableSamples.

  4. Selecteer toevoegen en vervolgens Nieuw item.Select Add and then New Item. Maak een nieuwe bestands instellingen. json met het bestands type type script JSON-configuratie bestand.Create a new file Settings.json with file type as TypeScript JSON Configuration File.

  5. Vervang de code in het bestand settings. json door de volgende code en wijs uw primaire connection string toe: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. Klik met de rechter muisknop op uw project CosmosTableSamples.Right click on your project CosmosTableSamples. Selecteer toevoegen, Nieuw item en voeg een klasse toe met de naam AppSettings.cs.Select Add, New Item and add a class named AppSettings.cs.

  7. Voeg de volgende code toe aan het AppSettings.cs-bestand.Add the following code to the AppSettings.cs file. Dit bestand leest de connection string van het bestand settings. json en wijst het toe aan de configuratie parameter: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;
         }
     }
    }
    

De verbindings gegevens parseren en validerenParse and validate the connection details

  1. Klik met de rechter muisknop op uw project CosmosTableSamples.Right click on your project CosmosTableSamples. Selecteer toevoegen, Nieuw item en voeg een klasse toe met de naam common.cs.Select Add, New Item and add a class named Common.cs. U schrijft code voor het valideren van de verbindings gegevens en het maken van een tabel in deze klasse.You will write code to validate the connection details and create a table within this class.

  2. Definieer een methode CreateStorageAccountFromConnectionString zoals hieronder wordt weer gegeven.Define a method CreateStorageAccountFromConnectionString as shown below. Met deze methode worden de connection string gegevens geparseerd en wordt gecontroleerd of de account naam en de gegevens van de account sleutel in het bestand settings. json geldig zijn.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;
       }
   }
}

Een tabel makenCreate a Table

Met behulp van de CloudTableClient-klasse kunt u tabellen en entiteiten ophalen die zijn opgeslagen in de Table Storage.The CloudTableClient class enables you to retrieve tables and entities stored in Table storage. Omdat we geen tabellen hebben in de Cosmos DB Table-API-account, gaan we de CreateTableAsync methode toevoegen aan de klasse common.cs om een tabel te maken: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;
}

Als u de fout melding ' 503-Service niet beschikbaar ' krijgt, is het mogelijk dat de vereiste poorten voor de connectiviteits modus worden geblokkeerd door een firewall.If you get a "503 service unavailable exception" error, it's possible that the required ports for the connectivity mode are blocked by a firewall. Als u dit probleem wilt oplossen, opent u de vereiste poorten of gebruikt u de connectiviteit van de gateway modus, zoals wordt weer gegeven in de volgende code:To fix this issue, either open the required ports or use the gateway mode connectivity as shown in the following code:

tableClient.TableClientConfiguration.UseRestExecutorForCosmosEndpoint = true;

De entiteit definiërenDefine the entity

Entiteiten worden toegewezen aan C#-objecten met behulp van een aangepaste klasse die is afgeleid van TableEntity.Entities map to C# objects by using a custom class derived from TableEntity. Als u een entiteit wilt toevoegen aan een tabel, maakt u een klasse die de eigenschappen van uw entiteit definieert.To add an entity to a table, create a class that defines the properties of your entity.

Klik met de rechter muisknop op uw project CosmosTableSamples.Right click on your project CosmosTableSamples. Selecteer toevoegen, nieuwe map en geef deze de naam model.Select Add, New Folder and name it as Model. Voeg in de map model een klasse toe met de naam CustomerEntity.cs en voeg hieraan de volgende code toe.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; }
    }
}

Deze code definieert een entiteits klasse die de voor naam van de klant als de rij-en achternaam als de partitie sleutel gebruikt.This code defines an entity class that uses the customer's first name as the row key and last name as the partition key. De entiteit wordt in de tabel op unieke wijze geïdentificeerd door diens partitie- en rijsleutel.Together, an entity's partition and row key uniquely identify it in the table. Entiteiten met dezelfde partitie sleutel kunnen sneller worden opgevraagd dan entiteiten met verschillende partitie sleutels, maar het gebruik van verschillende partitie sleutels maakt een grotere schaal baarheid van parallelle bewerkingen mogelijk.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. De entiteiten die u in tabellen wilt opslaan, moeten van een ondersteund type zijn. Ze moeten bijvoorbeeld zijn afgeleid van de TableEntity-klasse.Entities to be stored in tables must be of a supported type, for example derived from the TableEntity class. De entiteitseigenschappen die u in een tabel wilt opslaan, moeten openbare eigenschappen van het type zijn. Bovendien moeten ze zowel het ophalen als het instellen van waarden ondersteunen.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. Ook moet uw entiteitstype een parameterloze constructor bevatten.Also, your entity type must expose a parameter-less constructor.

Een entiteit invoegen of samen voegenInsert or merge an entity

In het volgende code voorbeeld wordt een entiteits object gemaakt en toegevoegd aan de tabel.The following code example creates an entity object and adds it to the table. De methode InsertOrMerge binnen de klasse TableOperation wordt gebruikt om een entiteit in te voegen of samen te voegen.The InsertOrMerge method within the TableOperation class is used to insert or merge an entity. De methode CloudTable. ExecuteAsync wordt aangeroepen om de bewerking uit te voeren.The CloudTable.ExecuteAsync method is called to execute the operation.

Klik met de rechter muisknop op uw project CosmosTableSamples.Right click on your project CosmosTableSamples. Selecteer toevoegen, Nieuw item en voeg een klasse toe met de naam SamplesUtils.cs.Select Add, New Item and add a class named SamplesUtils.cs. In deze klasse wordt alle code opgeslagen die is vereist voor het uitvoeren van ruwe bewerkingen op de entiteiten.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;
     }
 }

Een entiteit uit een partitie ophalenGet an entity from a partition

U kunt de entiteit ophalen uit een partitie met de methode ophalen onder de klasse TableOperation .You can get entity from a partition by using the Retrieve method under the TableOperation class. In het volgende code voorbeeld worden de partitie sleutel, het e-mail adres en het telefoon nummer van een klant entiteit opgehaald.The following code example gets the partition key row key, email and phone number of a customer entity. In dit voor beeld worden ook de verbruikte aanvraag eenheden afgedrukt om een query voor de entiteit uit te kunnen zien.This example also prints out the request units consumed to query for the entity. Als u een query wilt uitvoeren voor een entiteit, voegt u de volgende code toe aan het SamplesUtils.cs -bestand: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;
        }
    }

Een entiteit verwijderenDelete an entity

U kunt een entiteit gemakkelijk verwijderen nadat u deze hebt opgehaald. Hiervoor gebruikt u hetzelfde patroon dat is getoond voor het bijwerken van een entiteit.You can easily delete an entity after you have retrieved it by using the same pattern shown for updating an entity. Met de volgende code wordt een klantentiteit opgehaald en verwijderd.The following code retrieves and deletes a customer entity. Als u een entiteit wilt verwijderen, voegt u de volgende code toe aan het SamplesUtils.cs -bestand: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;
    }
}

De ruwe bewerkingen uitvoeren op voorbeeld gegevensExecute the CRUD operations on sample data

Nadat u de methoden voor het maken van een tabel, het invoegen of samen voegen van een entiteit hebt gedefinieerd, voert u deze methoden uit op de voorbeeld gegevens.After you define the methods to create table, insert or merge entities, run these methods on the sample data. Hiertoe klikt u met de rechter muisknop op uw project CosmosTableSamples.To do so, right click on your project CosmosTableSamples. Selecteer toevoegen, Nieuw item en voeg een klasse toe met de naam BasicSamples.cs en voeg hieraan de volgende code toe.Select Add, New Item and add a class named BasicSamples.cs and add the following code to it. Met deze code wordt een tabel gemaakt waaraan entiteiten worden toegevoegd.This code creates a table, adds entities to it. Als u de entiteit en tabel aan het einde van het project wilt verwijderen, verwijdert u de opmerkingen table.DeleteIfExistsAsync() uit SamplesUtils.DeleteEntityAsync(table, customer) en-methoden uit de volgende code: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();
        }
    }
}

Met de vorige code wordt een tabel gemaakt die begint met ' demo ' en de gegenereerde GUID wordt toegevoegd aan de tabel naam.The previous code creates a table that starts with “demo” and the generated GUID is appended to the table name. Vervolgens wordt een klant entiteit met de voor-en achternaam toegevoegd als ' harp Walter ' en wordt het telefoon nummer van deze gebruiker later bijgewerkt.It then adds a customer entity with first and last name as “Harp Walter” and later updates the phone number of this user.

In deze zelf studie hebt u code gemaakt voor het uitvoeren van elementaire ruwe bewerkingen op de gegevens die zijn opgeslagen in Table-API-account.In this tutorial, you built code to perform basic CRUD operations on the data stored in Table API account. U kunt ook geavanceerde bewerkingen uitvoeren, zoals – batch invoegen van gegevens, het opvragen van alle gegevens in een partitie, het opvragen van een bereik van gegevens in een partitie, het weer geven van tabellen in het account waarvan de namen beginnen met het opgegeven voor voegsel.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. U kunt het volledige voorbeeld formulier downloaden van Azure-Cosmos-Table-DotNet-core-Getting-Started github-opslag plaats.You can download the complete sample form azure-cosmos-table-dotnet-core-getting-started GitHub repository. De klasse AdvancedSamples.cs heeft meer bewerkingen die u kunt uitvoeren op de gegevens.The AdvancedSamples.cs class has more operations that you can perform on the data.

Het project uitvoerenRun the project

Vanuit uw project CosmosTableSamples.From your project CosmosTableSamples. Open de klasse met de naam Program.cs en voeg de volgende code toe voor het aanroepen van BasicSamples wanneer het project wordt uitgevoerd.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();
        }
    }
}

Bouw nu de oplossing en druk op F5 om het project uit te voeren.Now build the solution and press F5 to run the project. Wanneer het project wordt uitgevoerd, wordt de volgende uitvoer weer gegeven in de opdracht prompt:When the project is run, you will see the following output in the command prompt:

Uitvoer vanaf opdracht prompt

Als er een fout bericht wordt weer gegeven met de tekst instellingen. JSON-bestand is niet gevonden bij het uitvoeren van het project, kunt u dit oplossen door de volgende XML-vermelding toe te voegen aan de project instellingen.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. Klik met de rechter muisknop op CosmosTableSamples, selecteer Bewerken CosmosTableSamples. csproj en voeg de volgende itemGroup toe:Right click on CosmosTableSamples, select Edit CosmosTableSamples.csproj and add the following itemGroup:

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

U kunt zich nu aanmelden bij de Azure Portal en controleren of de gegevens in de tabel bestaan.Now you can sign into the Azure portal and verify that the data exists in the table.

Resultaten in Portal

Volgende stappenNext steps

U kunt nu door gaan met de volgende zelf studie en meer informatie over het migreren van gegevens naar Azure Cosmos DB Table-API-account.You can now proceed to the next tutorial and learn how to migrate data to Azure Cosmos DB Table API account.