Začínáme s rozhraním Azure Cosmos DB API pro tabulky a Azure Table Storage s využitím .NET SDKGet started with Azure Cosmos DB Table API and Azure Table storage using the .NET SDK

PLATÍ pro: rozhraní API pro tabulky

Tip

Obsah v tomto článku se vztahuje na službu Azure Table Storage a rozhraní Azure Cosmos DB Table API.The content in this article applies to Azure Table storage and the Azure Cosmos DB Table API. Rozhraní Azure Cosmos DB Table API je nabídka služby Table Storage úrovně Premium, která nabízí tabulky optimalizované pro zvýšení propustnosti, globální distribuci a automatické sekundární indexy.The Azure Cosmos DB Table API is a premium offering for table storage that offers throughput-optimized tables, global distribution, and automatic secondary indexes.

Pomocí Azure Cosmos DB rozhraní API pro tabulky nebo úložiště tabulek Azure můžete ukládat strukturovaná data NoSQL do cloudu a poskytnout tak úložiště klíčů a atributů s návrhem bez schématu.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. Vzhledem k tomu, že Azure Cosmos DB rozhraní API pro tabulky a úložiště tabulek jsou míň schématu, je snadné přizpůsobit data, jak se vyvíjí vaše aplikace.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. K ukládání flexibilních datových sad, například uživatelských dat pro webové aplikace, adresářů, informací o zařízení nebo jiných typů metadat, které vaše služba vyžaduje, můžete použít Azure Cosmos DB rozhraní API pro tabulky nebo úložiště tabulek.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.

Tento kurz popisuje ukázku, která vám ukáže, jak používat Microsoft Azure Cosmos DB knihovny tabulek pro .NET s Azure Cosmos DB rozhraní API pro tabulky a scénáři úložiště tabulek Azure.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. Je nutné použít připojení specifické pro službu Azure.You must use the connection specific to the Azure service. Tyto scénáře jsou prozkoumání pomocí příkladů jazyka C#, které ilustrují vytváření tabulek, vkládání a aktualizaci dat, dotazování dat a odstraňování tabulek.These scenarios are explored using C# examples that illustrate how to create tables, insert/ update data, query data and delete the tables.

PožadavkyPrerequisites

Pro úspěšné dokončení této ukázky potřebujete následující položky:You need the following to complete this sample successfully:

Vytvoření účtu rozhraní Table API služby Azure Cosmos DBCreate an Azure Cosmos DB Table API account

  1. V novém okně prohlížeče se přihlaste k webu Azure Portal.In a new browser window, sign in to the Azure portal.

  2. V nabídce vlevo vyberte vytvořit prostředek.In the left menu, select Create a resource.

    Vytvoření prostředku na portálu Azure Portal

  3. Na stránce Nový vyberte databáze > Azure Cosmos DB.On the New page, select Databases > Azure Cosmos DB.

    Podokno Databáze na webu Azure Portal

  4. Na stránce vytvořit Azure Cosmos DB účet zadejte nastavení pro nový účet Azure Cosmos DB.On the Create Azure Cosmos DB Account page, enter the settings for the new Azure Cosmos DB account.

    NastaveníSetting HodnotaValue PopisDescription
    PředplatnéSubscription Vaše předplatnéYour subscription Vyberte předplatné Azure, které chcete pro tento účet služby Azure Cosmos DB použít.Select the Azure subscription that you want to use for this Azure Cosmos DB account.
    Skupina prostředkůResource Group Vytvořit nový a potom název účtuCreate new, then Account Name Vyberte, že chcete vytvořit novou IP adresu.Select Create new. Pak zadejte nový název skupiny prostředků pro váš účet.Then enter a new resource group name for your account. Pro jednoduchost použijte stejný název jako název účtu Azure Cosmos DB.For simplicity, use the same name as your Azure Cosmos DB account name.
    Account NameAccount Name Jedinečný názevA unique name Zadejte jedinečný název, který identifikuje váš účet služby Azure Cosmos DB.Enter a unique name to identify your Azure Cosmos DB account.

    Název účtu může obsahovat jenom malá písmena, číslice a spojovníky (-) a musí mít délku 3 až 31 znaků.The account name can use only lowercase letters, numbers, and hyphens (-), and must be between 3 and 31 characters long.
    Rozhraní APIAPI TabulkaTable Rozhraní API určuje typ účtu, který se má vytvořit.The API determines the type of account to create. Azure Cosmos DB poskytuje pět rozhraní API: Core (SQL) pro databáze dokumentů, Gremlin pro databáze grafů, MongoDB pro databáze dokumentů, tabulku Azure a Cassandra.Azure Cosmos DB provides five APIs: Core (SQL) for document databases, Gremlin for graph databases, MongoDB for document databases, Azure Table, and Cassandra. Pro každé rozhraní API musíte vytvořit samostatný účet.You must create a separate account for each API.

    Vyberte tabulka Azure, protože v tomto rychlém startu vytváříte tabulku, která funguje s rozhraní API pro tabulky.Select Azure Table, because in this quickstart you are creating a table that works with the Table API.

    Přečtěte si další informace o rozhraní API pro tabulky.Learn more about the Table API.
    UmístěníLocation Oblast nejbližší vašim uživatelůmThe region closest to your users Vyberte zeměpisné umístění, ve kterém chcete účet služby Azure Cosmos DB hostovat.Select a geographic location to host your Azure Cosmos DB account. Použijte umístění, které je vašim uživatelům nejbližší, abyste jim zajistili nejrychlejší přístup k datům.Use the location that's closest to your users to give them the fastest access to the data.
    Režim kapacityCapacity mode Zřízená propustnost nebo bez serveruProvisioned throughput or Serverless Vyberte zřízenou propustnost a vytvořte účet v režimu zřízené propustnosti .Select Provisioned throughput to create an account in provisioned throughput mode. Pokud chcete vytvořit účet v režimu bez serveru , vyberte možnost bez serveru .Select Serverless to create an account in serverless mode.

    Můžete ponechat možnosti pro zápis geografické redundance a více oblastí na Zakázat , abyste se vyhnuli dalším poplatkům, a přeskočíte části síť a značky .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. Vyberte zkontrolovat + vytvořit.Select Review+Create. Po dokončení ověření vyberte vytvořit a vytvořte účet.After the validation is complete, select Create to create the account.

    Stránka nového účtu pro službu Azure Cosmos DB

  6. Vytvoření účtu trvá několik minut.It takes a few minutes to create the account. Zobrazí se zpráva s informací o tom, že probíhá vaše nasazení.You'll see a message that states Your deployment is underway. Počkejte, až se nasazení dokončí, a pak vyberte Přejít k prostředku.Wait for the deployment to finish, and then select Go to resource.

    Podokno oznámení Azure Portal

Vytvoření projektu konzoly .NETCreate a .NET console project

V aplikaci Visual Studio vytvořte novou konzolovou aplikaci .NET.In Visual Studio, create a new .NET console application. Následující kroky ukazují, jak vytvořit konzolovou aplikaci v aplikaci Visual Studio 2019.The following steps show you how to create a console application in Visual Studio 2019. Můžete použít Azure Cosmos DB knihovny tabulek v jakémkoli typu aplikace .NET, včetně cloudové služby Azure nebo webové aplikace a desktopových a mobilních aplikací.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. V této příručce použijeme konzolovou aplikaci kvůli zjednodušení.In this guide, we use a console application for simplicity.

  1. Vyberte soubor > Nový > projekt.Select File > New > Project.

  2. Zvolte Konzolová aplikace (.NET Core) a pak vyberte Další.Choose Console App (.NET Core), and then select Next.

  3. Do pole název projektu zadejte název vaší aplikace, například CosmosTableSamples.In the Project name field, enter a name for your application, such as CosmosTableSamples. (V případě potřeby můžete zadat jiný název.)(You can provide a different name as needed.)

  4. Vyberte Vytvořit.Select Create.

Všechny příklady kódu v této ukázce lze přidat do metody Main () souboru program. cs vaší konzolové aplikace.All code examples in this sample can be added to the Main() method of your console application's Program.cs file.

Instalace požadovaného balíčku NuGetInstall the required NuGet package

K získání balíčku NuGet použijte tento postup:To obtain the NuGet package, follow these steps:

  1. Klikněte v Průzkumníku řešení pravým tlačítkem na projekt a vyberte Spravovat balíčky NuGet.Right-click your project in Solution Explorer and choose Manage NuGet Packages.

  2. Vyhledejte v online Microsoft.Azure.Cosmos.Table režimu Microsoft.Extensions.Configuration , Microsoft.Extensions.Configuration.Json , Microsoft.Extensions.Configuration.Binder a vyberte nainstalovat a nainstalujte Microsoft Azure Cosmos DB knihovnu tabulek.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.

Konfigurace připojovacího řetězce úložištěConfigure your storage connection string

  1. V Azure Portalpřejděte k účtu Azure Cosmos nebo k účtu Table Storage.From the Azure portal, navigate to your Azure Cosmos account or the Table Storage account.

  2. Otevřete okno připojovací řetězec nebo přístupové klávesy .Open the Connection String or Access keys pane. Pomocí tlačítka pro kopírování na pravé straně okna zkopírujte PRIMÁRNÍ PŘIPOJOVACÍ ŘETĚZEC.Use the copy button on the right side of the window to copy the PRIMARY CONNECTION STRING.

    Zobrazení a zkopírování PRIMÁRNÍHO PŘIPOJOVACÍHO ŘETĚZCE v podokně Připojovací řetězec

  3. Pokud chcete nakonfigurovat připojovací řetězec, klikněte pravým tlačítkem ze sady Visual Studio na projekt CosmosTableSamples.To configure your connection string, from visual studio right click on your project CosmosTableSamples.

  4. Vyberte Přidat a poté Nová položka.Select Add and then New Item. Vytvoří nový soubor Settings.js s typem souboru jako konfigurační soubor TypeScript JSON .Create a new file Settings.json with file type as TypeScript JSON Configuration File.

  5. Nahraďte kód v Settings.jssouboru následujícím kódem a přiřaďte k primárnímu připojovacímu řetězci: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. Klikněte pravým tlačítkem na projekt CosmosTableSamples.Right click on your project CosmosTableSamples. Vyberte Přidat, Nová položka a přidejte třídu s názvem appSettings. cs.Select Add, New Item and add a class named AppSettings.cs.

  7. Do souboru AppSettings. cs přidejte následující kód.Add the following code to the AppSettings.cs file. Tento soubor přečte připojovací řetězec z Settings.jsv souboru a přiřadí ho ke konfiguračnímu parametru: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;
        }
    }
}

Analyzovat a ověřit podrobnosti připojeníParse and validate the connection details

  1. Klikněte pravým tlačítkem na projekt CosmosTableSamples.Right click on your project CosmosTableSamples. Vyberte Přidat, Nová položka a přidejte třídu s názvem Common. cs.Select Add, New Item and add a class named Common.cs. Budete psát kód, který ověří podrobnosti připojení a vytvoří tabulku v rámci této třídy.You will write code to validate the connection details and create a table within this class.

  2. Definujte metodu CreateStorageAccountFromConnectionString , jak je znázorněno níže.Define a method CreateStorageAccountFromConnectionString as shown below. Tato metoda analyzuje podrobnosti připojovacího řetězce a ověří, zda jsou platné podrobnosti o názvu účtu a klíči účtu uvedené v souboru Settings.json.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;
            }
    

Vytvoření tabulkyCreate a Table

Třída CloudTableClient vám umožňuje načítat tabulky a entity, které jsou uložené ve službě Table Storage.The CloudTableClient class enables you to retrieve tables and entities stored in Table storage. Vzhledem k tomu, že v účtu Cosmos DB rozhraní API pro tabulky nejsou žádné tabulky, přidejte CreateTableAsync metodu do Common Class. cs pro vytvoření tabulky: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;
}

Pokud se zobrazí chyba "nedostupná výjimka služby 503", je možné, že brána firewall zablokuje požadované porty pro režim připojení.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. Pokud chcete tento problém vyřešit, otevřete požadované porty nebo použijte připojení režimu brány, jak je znázorněno v následujícím kódu: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;

Definovat entituDefine the entity

Entity se mapují na objekty jazyka C# pomocí vlastní třídy odvozené z TableEntity.Entities map to C# objects by using a custom class derived from TableEntity. Když budete chtít do tabulky přidat entitu, vytvořte třídu, která definuje vlastnosti vaší entity.To add an entity to a table, create a class that defines the properties of your entity.

Klikněte pravým tlačítkem na projekt CosmosTableSamples.Right click on your project CosmosTableSamples. Vyberte Přidat, Nová složka a pojmenujte ji jako model.Select Add, New Folder and name it as Model. V rámci složky modelu přidejte třídu s názvem CustomerEntity. cs a přidejte do ní následující kód.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; }
    }
}

Tento kód definuje třídu entity, která používá křestní jméno zákazníka jako klíč řádku a příjmení jako klíč oddílu.This code defines an entity class that uses the customer's first name as the row key and last name as the partition key. V tabulce ji pak jednoznačně identifikuje kombinace klíče oddílu a řádku entity.Together, an entity's partition and row key uniquely identify it in the table. Na entity se stejným klíčem oddílu je možné zadávat dotazy rychleji než entity s různými klíči oddílů, ale pomocí různých klíčů oddílu můžete dosáhnout větší škálovatelnosti paralelních operací.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. Entity, které se mají ukládat do tabulek, musí být podporovaného typu, například odvozené ze třídy TableEntity.Entities to be stored in tables must be of a supported type, for example derived from the TableEntity class. Vlastnosti entity, které chcete uložit do tabulky, musí být veřejné vlastnosti typu a musí podporovat získávání i nastavování hodnot.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. Typ entity navíc musí zveřejňovat konstruktor bez parametrů.Also, your entity type must expose a parameter-less constructor.

Vložení nebo sloučení entityInsert or merge an entity

Následující příklad kódu vytvoří objekt entity a přidá jej do tabulky.The following code example creates an entity object and adds it to the table. Metoda InsertOrMerge v rámci třídy TableOperation se používá k vložení nebo sloučení entity.The InsertOrMerge method within the TableOperation class is used to insert or merge an entity. Pro provedení operace je volána metoda CloudTable.ExecuteAsync .The CloudTable.ExecuteAsync method is called to execute the operation.

Klikněte pravým tlačítkem na projekt CosmosTableSamples.Right click on your project CosmosTableSamples. Vyberte Přidat, Nová položka a přidejte třídu s názvem SamplesUtils. cs.Select Add, New Item and add a class named SamplesUtils.cs. Tato třída ukládá veškerý kód potřebný k provádění operací CRUD u 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;

        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;
    }
}

Získat entitu z oddíluGet an entity from a partition

Entitu můžete získat z oddílu pomocí metody načíst pod třídou TableOperation .You can get entity from a partition by using the Retrieve method under the TableOperation class. Následující příklad kódu získá klíč řádku klíč oddílu, e-mail a telefonní číslo entity zákazníka.The following code example gets the partition key row key, email and phone number of a customer entity. Tento příklad také vytiskne jednotky žádosti spotřebované pro dotazování na entitu.This example also prints out the request units consumed to query for the entity. Chcete-li zadat dotaz na entitu, přidejte následující kód do souboru 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);
        }

        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;
    }
}

Odstranění entityDelete an entity

Entitu můžete po jejím načtení snadno odstranit, a to pomocí stejného vzoru zobrazovaného pro aktualizaci entity.You can easily delete an entity after you have retrieved it by using the same pattern shown for updating an entity. Následující kód načte a odstraní entitu zákazníka.The following code retrieves and deletes a customer entity. Pokud chcete entitu odstranit, přidejte do souboru SamplesUtils. cs následující kód: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);

        if (result.RequestCharge.HasValue)
        {
            Console.WriteLine("Request Charge of Delete Operation: " + result.RequestCharge);
        }

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

Provádění operací CRUD pro ukázková dataExecute the CRUD operations on sample data

Po definování metod pro vytvoření tabulky, vložení nebo sloučení entit spusťte tyto metody pro ukázková data.After you define the methods to create table, insert or merge entities, run these methods on the sample data. Provedete to tak, že kliknete pravým tlačítkem na projekt CosmosTableSamples.To do so, right click on your project CosmosTableSamples. Vyberte Přidat, Nová položka a přidejte třídu s názvem BasicSamples. cs a přidejte do ní následující kód.Select Add, New Item and add a class named BasicSamples.cs and add the following code to it. Tento kód vytvoří tabulku a přidá do ní entity.This code creates a table, adds entities to it.

Pokud nechcete entitu a tabulku na konci projektu odstranit, přikomentujte await table.DeleteIfExistsAsync() SamplesUtils.DeleteEntityAsync(table, customer) metody a z následujícího kódu.If don't want to delete the entity and table at the end of the project, comment the await table.DeleteIfExistsAsync() and SamplesUtils.DeleteEntityAsync(table, customer) methods from the following code. Před odstraněním tabulky je nejlepší tyto metody opatřit poznámkami a ověřit data.It's best to comment out these methods and validate the data before you delete the table.

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();
        }
    }
}

Předchozí kód vytvoří tabulku, která začíná "demo" a vygenerovaný identifikátor GUID se připojí k názvu tabulky.The previous code creates a table that starts with “demo” and the generated GUID is appended to the table name. Pak přidá entitu Customer s křestním jménem a příjmení jako "Harpa Waltera" a později aktualizuje telefonní číslo tohoto uživatele.It then adds a customer entity with first and last name as “Harp Walter” and later updates the phone number of this user.

V tomto kurzu jste vytvořili kód, který provádí základní operace CRUD s daty uloženými v rozhraní API pro tabulkym účtu.In this tutorial, you built code to perform basic CRUD operations on the data stored in Table API account. Můžete také provádět pokročilé operace, jako je například dávkové vkládání dat, dotazování všech dat v rámci oddílu, dotazování na rozsah dat v rámci oddílu, seznam tabulek v účtu, jejichž názvy začínají zadanou předponou.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. Můžete si stáhnout kompletní ukázkový formulář Azure-Cosmos-Table-dotnet-Core-Začínáme s úložištěm GitHub.You can download the complete sample form azure-cosmos-table-dotnet-core-getting-started GitHub repository. Třída AdvancedSamples. cs obsahuje více operací, které můžete s daty provádět.The AdvancedSamples.cs class has more operations that you can perform on the data.

Spuštění projektuRun the project

Z projektu CosmosTableSamples.From your project CosmosTableSamples. Otevřete třídu s názvem program. cs a přidejte do ní následující kód pro volání BasicSamples při spuštění projektu.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();

            AdvancedSamples advancedSamples = new AdvancedSamples();
            advancedSamples.RunSamples().Wait();

            Console.WriteLine();
            Console.WriteLine("Press any key to exit");
            Console.Read();
        }
    }
}

Nyní Sestavte řešení a stisknutím klávesy F5 spusťte projekt.Now build the solution and press F5 to run the project. Při spuštění projektu se zobrazí následující výstup na příkazovém řádku:When the project is run, you will see the following output in the command prompt:

Výstup z příkazového řádku

Pokud se zobrazí chybová zpráva oznamující, že při spuštění projektu nelze najít Settings.jspro soubor, můžete ho vyřešit přidáním následující položky XML do nastavení projektu.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. Klikněte pravým tlačítkem na CosmosTableSamples, vyberte Upravit CosmosTableSamples. csproj a přidejte následující položku:Right click on CosmosTableSamples, select Edit CosmosTableSamples.csproj and add the following itemGroup:

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

Nyní se můžete přihlásit k Azure Portal a ověřit, zda data v tabulce existují.Now you can sign into the Azure portal and verify that the data exists in the table.

Výsledky na portálu

Další krokyNext steps

Teď můžete přejít k dalšímu kurzu a Naučte se migrovat data na účet Azure Cosmos DB rozhraní API pro tabulky.You can now proceed to the next tutorial and learn how to migrate data to Azure Cosmos DB Table API account.