Kurz: Vytvoření aplikace konzoly .NET pro správu dat v Azure Cosmos DB účtu rozhraní SQL APITutorial: Build a .NET console app to manage data in Azure Cosmos DB SQL API account

Vítejte v úvodním kurzu Azure Cosmos DB SQL API.Welcome to the Azure Cosmos DB SQL API get started tutorial. Až projdete tímto kurzem, budete mít konzolovou aplikaci, která vytváří prostředky Azure Cosmos DB a dotazuje se na ně.After following this tutorial, you'll have a console application that creates and queries Azure Cosmos DB resources.

V tomto kurzu se používá verze 3,0 nebo novější Azure Cosmos DB .NET SDK.This tutorial uses version 3.0 or later of the Azure Cosmos DB .NET SDK. Můžete pracovat s .NET Framework nebo .NET Core.You can work with .NET Framework or .NET Core.

Tento kurz zahrnuje:This tutorial covers:

  • Vytvoření účtu Azure Cosmos a připojení k němuCreating and connecting to an Azure Cosmos account
  • Konfigurace projektu v aplikaci Visual StudioConfiguring your project in Visual Studio
  • Vytvoření databáze a kontejneruCreating a database and a container
  • Přidání položek do kontejneruAdding items to the container
  • Dotazování kontejneruQuerying the container
  • Provádění operací vytvoření, čtení, aktualizace a odstranění (CRUD) u položkyPerforming create, read, update, and delete (CRUD) operations on the item
  • Odstranění databázeDeleting the database

Nemáte čas?Don't have time? Nevadí!Don't worry! Úplné řešení je k dispozici na GitHubu.The complete solution is available on GitHub. Přejděte do části získání kompletního řešení kurzu , kde najdete rychlé pokyny.Jump to the Get the complete tutorial solution section for quick instructions.

Můžeme začít!Now let's get started!

PožadavkyPrerequisites

Krok 1: Vytvoření účtu služby Azure Cosmos DBStep 1: Create an Azure Cosmos DB account

Vytvořme účet služby Azure Cosmos DB.Let's create an Azure Cosmos DB account. Pokud již máte účet, který chcete použít, přeskočte tuto část.If you already have an account you want to use, skip this section. Chcete-li použít emulátor Azure Cosmos DB, postupujte podle pokynů v Azure Cosmos DB emulátoru a nastavte emulátor.To use the Azure Cosmos DB Emulator, follow the steps at Azure Cosmos DB Emulator to set up the emulator. Potom přejděte ke kroku 2: nastavení projektu sady Visual Studio.Then skip ahead to Step 2: Set up your Visual Studio project.

  1. V nabídce Azure Portal nebo na domovské stráncevyberte vytvořit prostředek.From the Azure portal menu or the Home page, select Create a resource.

  2. Na nové stránce vyhledejte a vyberte Azure Cosmos DB.On the New page, search for and select Azure Cosmos DB.

  3. Na stránce Azure Cosmos DB vyberte vytvořit.On the Azure Cosmos DB page, select Create.

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

    NastaveníSetting HodnotaValue PopisDescription
    PředplatnéSubscription Název předplatnéhoSubscription name Vyberte předplatné Azure, které chcete použít pro tento účet Azure Cosmos.Select the Azure subscription that you want to use for this Azure Cosmos account.
    Skupina prostředkůResource Group Název skupiny prostředkůResource group name Vyberte skupinu prostředků nebo vyberte vytvořit novéa zadejte jedinečný název nové skupiny prostředků.Select a resource group, or select Create new, then enter a unique name for the new resource group.
    Název účtuAccount Name Jedinečný názevA unique name Zadejte název, který identifikuje váš účet Azure Cosmos.Enter a name to identify your Azure Cosmos account. Vzhledem k tomu, že Documents.Azure.com je připojen k názvu, který zadáte k vytvoření identifikátoru URI, použijte jedinečný název.Because documents.azure.com is appended to the name that you provide to create your URI, use a unique name.

    Název může obsahovat jenom malá písmena, číslice a znak spojovníku (-).The name can only contain lowercase letters, numbers, and the hyphen (-) character. Musí mít délku 3-44 znaků.It must be between 3-44 characters in length.
    Rozhraní APIAPI Typ účtu, který se má vytvořitThe type of account to create Vyberte Core (SQL) pro vytvoření databáze dokumentů a dotaz pomocí syntaxe SQL.Select Core (SQL) to create a document database and query by using SQL syntax.

    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) a MongoDB pro data dokumentů, Gremlin pro data grafu, tabulku Azure a Cassandra.Azure Cosmos DB provides five APIs: Core (SQL) and MongoDB for document data, Gremlin for graph data, Azure Table, and Cassandra. V současné době musíte pro každé rozhraní API vytvořit samostatný účet.Currently, you must create a separate account for each API.

    Přečtěte si další informace o rozhraní SQL API.Learn more about the SQL API.
    Použít slevu úrovně FreeApply Free Tier Discount Použít nebo nepoužítApply or Do not apply U Azure Cosmos DB úrovně Free získáte v účtu první 400 RU/s a 5 GB úložiště zdarma.With Azure Cosmos DB free tier, you will get the first 400 RU/s and 5 GB of storage for free in an account. Přečtěte si další informace o bezplatné úrovni.Learn more about free tier.
    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 nejblíže vašim uživatelům, a poskytněte jim tak nejrychlejší přístup k datům.Use the location that is closest to your users to give them the fastest access to the data.
    Typ účtuAccount Type Produkční nebo neprodukčníProduction or Non-Production Vyberte možnost produkce , pokud se účet bude používat pro produkční úlohy.Select Production if the account will be used for a production workload. Vyberte neprodukční , pokud se účet bude používat pro neprodukční, třeba pro vývoj, testování, kontrolu kvality nebo přípravu.Select Non-Production if the account will be used for non-production, e.g. development, testing, QA, or staging. Toto je nastavení značky prostředku Azure, které vystavuje možnosti portálu, ale nemá vliv na příslušný účet Azure Cosmos DB.This is an Azure resource tag setting that tunes the Portal experience but does not affect the underlying Azure Cosmos DB account. Tuto hodnotu můžete kdykoli změnit.You can change this value anytime.

    Poznámka

    V rámci předplatného Azure můžete mít až jednu úroveň bezplatného Azure Cosmos DB účtu a při vytváření účtu musíte souhlasit.You can have up to one free tier Azure Cosmos DB account per Azure subscription and must opt-in when creating the account. Pokud nevidíte možnost použít slevu úrovně Free, znamená to, že v předplatném už je povolený jiný účet s úrovní Free.If you do not see the option to apply the free tier discount, this means another account in the subscription has already been enabled with free tier.

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

  5. Vyberte Zkontrolovat a vytvořit.Select Review + create. Můžete přeskočit oddíly síť a značky .You can skip the Network and Tags sections.

  6. Zkontrolujte nastavení účtu a pak vyberte vytvořit.Review the account settings, and then select Create. Vytvoření účtu trvá několik minut.It takes a few minutes to create the account. Počkejte, než se na stránce portálu zobrazí dokončené vaše nasazení.Wait for the portal page to display Your deployment is complete.

    Podokno Oznámení portálu Azure Portal

  7. Vyberte Přejít k prostředku a přejdete na stránku Azure Cosmos DB účet.Select Go to resource to go to the Azure Cosmos DB account page.

    Stránka Azure Cosmos DB účtu

Krok 2: nastavení projektu sady Visual StudioStep 2: Set up your Visual Studio project

  1. Otevřete Visual Studio a vyberte vytvořit nový projekt.Open Visual Studio and select Create a new project.

  2. V možnosti vytvořit nový projektzvolte Konzolová aplikace (.NET Framework) pro C# a pak vyberte Další.In Create a new project, choose Console App (.NET Framework) for C#, then select Next.

  3. Pojmenujte projekt CosmosGettingStartedTutoriala pak vyberte vytvořit.Name your project CosmosGettingStartedTutorial, and then select Create.

    Konfigurace projektu

  4. V Průzkumník řešeníklikněte pravým tlačítkem myši na novou konzolovou aplikaci, která je v rámci řešení sady Visual Studio, a vyberte možnost Spravovat balíčky NuGet.In the Solution Explorer, right-click your new console application, which is under your Visual Studio solution, and select Manage NuGet Packages.

  5. V okně Správce balíčků NuGetvyberte Procházet a vyhledejte Microsoft. Azure. Cosmos.In the NuGet Package Manager, select Browse and search for Microsoft.Azure.Cosmos. Zvolte Microsoft. Azure. Cosmos a vyberte nainstalovat.Choose Microsoft.Azure.Cosmos and select Install.

    Instalace NuGet pro Azure Cosmos DB klientská sada SDK

    ID balíčku s klientskou knihovnou rozhraní Azure Cosmos DB SQL API je Microsoft Azure Cosmos DB Client Library.The package ID for the Azure Cosmos DB SQL API Client Library is Microsoft Azure Cosmos DB Client Library.

Výborně!Great! Teď když jsme dokončili nastavování, napišme nějaký kód.Now that we finished the setup, let's start writing some code. Dokončený projekt tohoto kurzu najdete v tématu vývoj aplikace konzoly .NET pomocí Azure Cosmos DB.For the completed project of this tutorial, see Developing a .NET console app using Azure Cosmos DB.

Krok 3: Připojení k účtu služby Azure Cosmos DBStep 3: Connect to an Azure Cosmos DB account

  1. Nahraďte odkazy na začátku aplikace v C# v souboru program.cs pomocí těchto odkazů:Replace the references at the beginning of your C# application in the Program.cs file with these references:

    using System;
    using System.Threading.Tasks;
    using System.Configuration;
    using System.Collections.Generic;
    using System.Net;
    using Microsoft.Azure.Cosmos;
    
  2. Do své Program třídy přidejte tyto konstanty a proměnné.Add these constants and variables into your Program class.

    public class Program
    {
        // ADD THIS PART TO YOUR CODE
    
        // The Azure Cosmos DB endpoint for running this sample.
        private static readonly string EndpointUri = "<your endpoint here>";
        // The primary key for the Azure Cosmos account.
        private static readonly string PrimaryKey = "<your primary key>";
    
        // The Cosmos client instance
        private CosmosClient cosmosClient;
    
        // The database we will create
        private Database database;
    
        // The container we will create.
        private Container container;
    
        // The name of the database and container we will create
        private string databaseId = "FamilyDatabase";
        private string containerId = "FamilyContainer";
    }
    

    Poznámka

    Pokud jste obeznámeni s předchozí verzí sady .NET SDK, můžete být obeznámeni se shromažďováním a dokumentems podmínkami.If you're familiar with the previous version of the .NET SDK, you may be familiar with the terms collection and document. Vzhledem k tomu, že Azure Cosmos DB podporuje více modelů rozhraní API, verze 3,0 sady .NET SDK používá obecný pojem kontejner a položka.Because Azure Cosmos DB supports multiple API models, version 3.0 of the .NET SDK uses the generic terms container and item. Kontejner může být kolekce, graf nebo tabulka.A container can be a collection, graph, or table. Položka může být dokument, okraj, vrchol nebo řádek a je obsahem uvnitř kontejneru.An item can be a document, edge/vertex, or row, and is the content inside a container. Další informace najdete v tématu práce s databázemi, kontejnery a položkami v Azure Cosmos DB.For more information, see Work with databases, containers, and items in Azure Cosmos DB.

  3. Otevřete Azure Portal.Open the Azure portal. Vyhledejte účet Azure Cosmos DB a pak vyberte klíče.Find your Azure Cosmos DB account, and then select Keys.

    Získat Azure Cosmos DB klíče z Azure Portal

  4. V program.csnahraďte <your endpoint URL> hodnotou identifikátoru URI.In Program.cs, replace <your endpoint URL> with the value of URI. Nahraďte <your primary key> hodnotou primárního klíče.Replace <your primary key> with the value of PRIMARY KEY.

  5. Pod metodou Main přidejte novou asynchronní úlohu s názvem GetStartedDemoAsync, která vytvoří instanci našeho nového CosmosClient.Below the Main method, add a new asynchronous task called GetStartedDemoAsync, which instantiates our new CosmosClient.

    public static async Task Main(string[] args)
    {
    }
    
    // ADD THIS PART TO YOUR CODE
    /*
        Entry point to call methods that operate on Azure Cosmos DB resources in this sample
    */
    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
    }
    

    GetStartedDemoAsync používáme jako vstupní bod, který volá metody, které pracují s Azure Cosmos DB prostředky.We use GetStartedDemoAsync as the entry point that calls methods that operate on Azure Cosmos DB resources.

  6. Přidejte následující kód pro spuštění asynchronní úlohy GetStartedDemoAsync z metody Main .Add the following code to run the GetStartedDemoAsync asynchronous task from your Main method. Metoda Main zachycuje výjimky a vypisuje je do konzoly.The Main method catches exceptions and writes them to the console.

    public static async Task Main(string[] args)
    {
        try
        {
            Console.WriteLine("Beginning operations...\n");
            Program p = new Program();
            await p.GetStartedDemoAsync();
    
        }
        catch (CosmosException de)
        {
            Exception baseException = de.GetBaseException();
            Console.WriteLine("{0} error occurred: {1}", de.StatusCode, de);
        }
        catch (Exception e)
        {
            Console.WriteLine("Error: {0}", e);
        }
        finally
        {
            Console.WriteLine("End of demo, press any key to exit.");
            Console.ReadKey();
        }
    }
    
  7. Zvolte F5 pro spuštění aplikace.Select F5 to run your application.

    Konzola zobrazí zprávu: konec ukázky, stisknutím libovolné klávesy ukončete.The console displays the message: End of demo, press any key to exit. Tato zpráva potvrdí, že vaše aplikace vytvořila připojení k Azure Cosmos DB.This message confirms that your application made a connection to Azure Cosmos DB. Potom můžete okno konzoly zavřít.You can then close the console window.

Blahopřejeme!Congratulations! Úspěšně jste se připojili k účtu Azure Cosmos DB.You've successfully connected to an Azure Cosmos DB account.

Krok 4: Vytvoření databázeStep 4: Create a database

Databáze je logický kontejner položek rozdělených napříč kontejnery.A database is the logical container of items partitioned across containers. Pomocí metody CreateDatabaseIfNotExistsAsync nebo CreateDatabaseAsync třídy CosmosClient lze vytvořit databázi.Either the CreateDatabaseIfNotExistsAsync or CreateDatabaseAsync method of the CosmosClient class can create a database.

  1. Zkopírujte a vložte CreateDatabaseAsync metodu pod vaší GetStartedDemoAsync metodou.Copy and paste the CreateDatabaseAsync method below your GetStartedDemoAsync method.

    /// <summary>
    /// Create the database if it does not exist
    /// </summary>
    private async Task CreateDatabaseAsync()
    {
        // Create a new database
        this.database = await this.cosmosClient.CreateDatabaseIfNotExistsAsync(databaseId);
        Console.WriteLine("Created Database: {0}\n", this.database.Id);
    }
    

    CreateDatabaseAsyncVytvoří novou databázi s ID FamilyDatabase , pokud ještě neexistuje, která má ID zadané v databaseId poli.CreateDatabaseAsync creates a new database with ID FamilyDatabase if it doesn't already exist, that has the ID specified from the databaseId field.

  2. Zkopírujte a vložte kód níže, kde vytváříte instanci CosmosClient k volání metody metody createdatabaseasync , kterou jste právě přidali.Copy and paste the code below where you instantiate the CosmosClient to call the CreateDatabaseAsync method you just added.

    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
    
        //ADD THIS PART TO YOUR CODE
        await this.CreateDatabaseAsync();
    }
    

    Váš program.cs by teď měl vypadat jako to s vyplněným koncovým bodem a primárním klíčem.Your Program.cs should now look like this, with your endpoint and primary key filled in.

    using System;
    using System.Threading.Tasks;
    using System.Configuration;
    using System.Collections.Generic;
    using System.Net;
    using Microsoft.Azure.Cosmos;
    
    namespace CosmosGettingStartedTutorial
    {
        class Program
        {
            // The Azure Cosmos DB endpoint for running this sample.
            private static readonly string EndpointUri = "<your endpoint here>";
            // The primary key for the Azure Cosmos account.
            private static readonly string PrimaryKey = "<your primary key>";
    
            // The Cosmos client instance
            private CosmosClient cosmosClient;
    
            // The database we will create
            private Database database;
    
            // The container we will create.
            private Container container;
    
            // The name of the database and container we will create
            private string databaseId = "FamilyDatabase";
            private string containerId = "FamilyContainer";
    
            public static async Task Main(string[] args)
            {
                try
                {
                    Console.WriteLine("Beginning operations...");
                    Program p = new Program();
                    await p.GetStartedDemoAsync();
                }
                catch (CosmosException de)
                {
                    Exception baseException = de.GetBaseException();
                    Console.WriteLine("{0} error occurred: {1}\n", de.StatusCode, de);
                }
                catch (Exception e)
                {
                    Console.WriteLine("Error: {0}\n", e);
                }
                finally
                {
                    Console.WriteLine("End of demo, press any key to exit.");
                    Console.ReadKey();
                }
            }
    
            /// <summary>
            /// Entry point to call methods that operate on Azure Cosmos DB resources in this sample
            /// </summary>
            public async Task GetStartedDemoAsync()
            {
                // Create a new instance of the Cosmos Client
                this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
                await this.CreateDatabaseAsync();
            }
    
            /// <summary>
            /// Create the database if it does not exist
            /// </summary>
            private async Task CreateDatabaseAsync()
            {
                // Create a new database
                this.database = await this.cosmosClient.CreateDatabaseIfNotExistsAsync(databaseId);
                Console.WriteLine("Created Database: {0}\n", this.database.Id);
            }
        }
    }
    
  3. Zvolte F5 pro spuštění aplikace.Select F5 to run your application.

    Poznámka

    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římého připojení.If you get a "503 service unavailable exception" error, it's possible that the required ports for direct 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:

      // Create a new instance of the Cosmos Client in Gateway mode
      this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey, new CosmosClientOptions()
             {
                 ConnectionMode = ConnectionMode.Gateway
             });
    

Blahopřejeme!Congratulations! Úspěšně jste vytvořili databázi Azure Cosmos.You've successfully created an Azure Cosmos database.

Krok 5: vytvoření kontejneruStep 5: Create a container

Upozornění

Metoda CreateContainerIfNotExistsAsync vytvoří nový kontejner, který má vliv na ceny.The method CreateContainerIfNotExistsAsync creates a new container, which has pricing implications. Další podrobnosti najdete na naší stránce s cenami.For more details, please visit our pricing page.

Kontejner lze vytvořit pomocí metody CreateContainerIfNotExistsAsync nebo CreateContainerAsync ve CosmosDatabase třídě.A container can be created by using either the CreateContainerIfNotExistsAsync or CreateContainerAsync method in the CosmosDatabase class. Kontejner se skládá z položek (dokumenty JSON, pokud je SQL API) a přidružená aplikační logika na straně serveru v JavaScriptu, například uložené procedury, uživatelsky definované funkce a triggery.A container consists of items (JSON documents if SQL API) and associated server-side application logic in JavaScript, for example, stored procedures, user-defined functions, and triggers.

  1. Zkopírujte a vložte CreateContainerAsync metodu pod vaší CreateDatabaseAsync metodou.Copy and paste the CreateContainerAsync method below your CreateDatabaseAsync method. CreateContainerAsyncVytvoří nový kontejner s ID FamilyContainer , pokud ještě neexistuje, pomocí ID zadaného v containerId poli děleného LastName vlastností.CreateContainerAsync creates a new container with the ID FamilyContainer if it doesn't already exist, by using the ID specified from the containerId field partitioned by LastName property.

    /// <summary>
    /// Create the container if it does not exist. 
    /// Specifiy "/LastName" as the partition key since we're storing family information, to ensure good distribution of requests and storage.
    /// </summary>
    /// <returns></returns>
    private async Task CreateContainerAsync()
    {
        // Create a new container
        this.container = await this.database.CreateContainerIfNotExistsAsync(containerId, "/LastName");
        Console.WriteLine("Created Container: {0}\n", this.container.Id);
    }
    
  2. Zkopírujte a vložte kód níže, kde jste vytvořili instanci CosmosClient k volání metody CreateContainer , kterou jste právě přidali.Copy and paste the code below where you instantiated the CosmosClient to call the CreateContainer method you just added.

    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
        await this.CreateDatabaseAsync();
    
        //ADD THIS PART TO YOUR CODE
        await this.CreateContainerAsync();
    }
    
  3. Zvolte F5 pro spuštění aplikace.Select F5 to run your application.

Blahopřejeme!Congratulations! Úspěšně jste vytvořili kontejner Azure Cosmos.You've successfully created an Azure Cosmos container.

Krok 6: Přidání položek do kontejneruStep 6: Add items to the container

Metoda CreateItemAsync CosmosContainer třídy může vytvořit položku.The CreateItemAsync method of the CosmosContainer class can create an item. Při použití rozhraní SQL API se položky procházejí jako dokumenty, což je uživatelsky definovaný libovolný obsah JSON.When using the SQL API, items are projected as documents, which are user-defined arbitrary JSON content. Nyní můžete vložit položku do kontejneru Azure Cosmos.You can now insert an item into your Azure Cosmos container.

Nejprve vytvoříme Family třídu, která představuje objekty uložené v rámci Azure Cosmos DB v této ukázce.First, let's create a Family class that represents objects stored within Azure Cosmos DB in this sample. Vytvoříme Parent Child Pettaké podtřídy, které jsou použity v rámci Family AddressWe'll also create Parent, Child, Pet, Address subclasses that are used within Family. Položka musí mít serializovanou Id vlastnost jako ve id formátu JSON.The item must have an Id property serialized as id in JSON.

  1. Kliknutím na Ctrl + Shift + A otevřete Přidat novou položku.Select Ctrl+Shift+A to open Add New Item. Přidejte do projektu novou Family.cs třídu.Add a new class Family.cs to your project.

    Snímek obrazovky s přidáním nové třídy Family.cs do projektu

  2. Zkopírujte a vložte Family Parent Child Address třídu,, Family.cs Pet, a do.Copy and paste the Family, Parent, Child, Pet, and Address class into Family.cs.

    using Newtonsoft.Json;
    
    namespace CosmosGettingStartedTutorial
    {
        public class Family
        {
            [JsonProperty(PropertyName = "id")]
            public string Id { get; set; }
            public string LastName { get; set; }
            public Parent[] Parents { get; set; }
            public Child[] Children { get; set; }
            public Address Address { get; set; }
            public bool IsRegistered { get; set; }
            public override string ToString()
            {
                return JsonConvert.SerializeObject(this);
            }
        }
    
        public class Parent
        {
            public string FamilyName { get; set; }
            public string FirstName { get; set; }
        }
    
        public class Child
        {
            public string FamilyName { get; set; }
            public string FirstName { get; set; }
            public string Gender { get; set; }
            public int Grade { get; set; }
            public Pet[] Pets { get; set; }
        }
    
        public class Pet
        {
            public string GivenName { get; set; }
        }
    
        public class Address
        {
            public string State { get; set; }
            public string County { get; set; }
            public string City { get; set; }
        }
    }
    
  3. Zpět v program.cspřidejte AddItemsToContainerAsync metodu za CreateContainerAsync metodu.Back in Program.cs, add the AddItemsToContainerAsync method after your CreateContainerAsync method.

    /// <summary>
    /// Add Family items to the container
    /// </summary>
    private async Task AddItemsToContainerAsync()
    {
        // Create a family object for the Andersen family
        Family andersenFamily = new Family
        {
            Id = "Andersen.1",
            LastName = "Andersen",
            Parents = new Parent[]
            {
                new Parent { FirstName = "Thomas" },
                new Parent { FirstName = "Mary Kay" }
            },
            Children = new Child[]
            {
                new Child
                {
                    FirstName = "Henriette Thaulow",
                    Gender = "female",
                    Grade = 5,
                    Pets = new Pet[]
                    {
                        new Pet { GivenName = "Fluffy" }
                    }
                }
            },
            Address = new Address { State = "WA", County = "King", City = "Seattle" },
            IsRegistered = false
        };
    
        try
        {
            // Read the item to see if it exists.  
            ItemResponse<Family> andersenFamilyResponse = await this.container.ReadItemAsync<Family>(andersenFamily.Id, new PartitionKey(andersenFamily.LastName));
            Console.WriteLine("Item in database with id: {0} already exists\n", andersenFamilyResponse.Resource.Id);
        }
        catch(CosmosException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
        {
            // Create an item in the container representing the Andersen family. Note we provide the value of the partition key for this item, which is "Andersen"
            ItemResponse<Family> andersenFamilyResponse = await this.container.CreateItemAsync<Family>(andersenFamily, new PartitionKey(andersenFamily.LastName));
    
            // Note that after creating the item, we can access the body of the item with the Resource property off the ItemResponse. We can also access the RequestCharge property to see the amount of RUs consumed on this request.
            Console.WriteLine("Created item in database with id: {0} Operation consumed {1} RUs.\n", andersenFamilyResponse.Resource.Id, andersenFamilyResponse.RequestCharge);
        }
    
        // Create a family object for the Wakefield family
        Family wakefieldFamily = new Family
        {
            Id = "Wakefield.7",
            LastName = "Wakefield",
            Parents = new Parent[]
            {
                new Parent { FamilyName = "Wakefield", FirstName = "Robin" },
                new Parent { FamilyName = "Miller", FirstName = "Ben" }
            },
            Children = new Child[]
            {
                new Child
                {
                    FamilyName = "Merriam",
                    FirstName = "Jesse",
                    Gender = "female",
                    Grade = 8,
                    Pets = new Pet[]
                    {
                        new Pet { GivenName = "Goofy" },
                        new Pet { GivenName = "Shadow" }
                    }
                },
                new Child
                {
                    FamilyName = "Miller",
                    FirstName = "Lisa",
                    Gender = "female",
                    Grade = 1
                }
            },
            Address = new Address { State = "NY", County = "Manhattan", City = "NY" },
            IsRegistered = true
        };
    
        try
        {
            // Read the item to see if it exists
            ItemResponse<Family> wakefieldFamilyResponse = await this.container.ReadItemAsync<Family>(wakefieldFamily.Id, new PartitionKey(wakefieldFamily.LastName));
            Console.WriteLine("Item in database with id: {0} already exists\n", wakefieldFamilyResponse.Resource.Id);
        }
        catch(CosmosException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
        {
            // Create an item in the container representing the Wakefield family. Note we provide the value of the partition key for this item, which is "Wakefield"
            ItemResponse<Family> wakefieldFamilyResponse = await this.container.CreateItemAsync<Family>(wakefieldFamily, new PartitionKey(wakefieldFamily.LastName));
    
            // Note that after creating the item, we can access the body of the item with the Resource property off the ItemResponse. We can also access the RequestCharge property to see the amount of RUs consumed on this request.
            Console.WriteLine("Created item in database with id: {0} Operation consumed {1} RUs.\n", wakefieldFamilyResponse.Resource.Id, wakefieldFamilyResponse.RequestCharge);
        }
    }
    

    Kód zkontroluje, že položka se stejným ID ještě neexistuje.The code checks to make sure an item with the same ID doesn't already exist. Vložíme dvě položky, jednu z nich pro rodinu Andersen a rodinu wakefieldů.We'll insert two items, one each for the Andersen Family and the Wakefield Family.

  4. Do GetStartedDemoAsync metody přidejte volání AddItemsToContainerAsync .Add a call to AddItemsToContainerAsync in the GetStartedDemoAsync method.

    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
        await this.CreateDatabaseAsync();
        await this.CreateContainerAsync();
    
        //ADD THIS PART TO YOUR CODE
        await this.AddItemsToContainerAsync();
    }
    
  5. Zvolte F5 pro spuštění aplikace.Select F5 to run your application.

Blahopřejeme!Congratulations! Úspěšně jste vytvořili dvě položky Azure Cosmos.You've successfully created two Azure Cosmos items.

Krok 7: Dotazování prostředků Azure Cosmos DBStep 7: Query Azure Cosmos DB resources

Azure Cosmos DB podporuje bohaté dotazy na dokumenty JSON uložené v jednotlivých kontejnerech.Azure Cosmos DB supports rich queries against JSON documents stored in each container. Další informace najdete v tématu Začínáme s dotazy SQL.For more information, see Getting started with SQL queries. Následující vzorový kód ukazuje, jak spustit dotaz proti položkám, které jsme vložili v předchozím kroku.The following sample code shows how to run a query against the items we inserted in the previous step.

  1. Zkopírujte a vložte QueryItemsAsync metodu po své AddItemsToContainerAsync metodě.Copy and paste the QueryItemsAsync method after your AddItemsToContainerAsync method.

    /// <summary>
    /// Run a query (using Azure Cosmos DB SQL syntax) against the container
    /// </summary>
    private async Task QueryItemsAsync()
    {
        var sqlQueryText = "SELECT * FROM c WHERE c.LastName = 'Andersen'";
    
        Console.WriteLine("Running query: {0}\n", sqlQueryText);
    
        QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText);
        FeedIterator<Family> queryResultSetIterator = this.container.GetItemQueryIterator<Family>(queryDefinition);
    
        List<Family> families = new List<Family>();
    
        while (queryResultSetIterator.HasMoreResults)
        {
            FeedResponse<Family> currentResultSet = await queryResultSetIterator.ReadNextAsync();
            foreach (Family family in currentResultSet)
            {
                families.Add(family);
                Console.WriteLine("\tRead {0}\n", family);
            }
        }
    }
    
  2. Do GetStartedDemoAsync metody přidejte volání QueryItemsAsync .Add a call to QueryItemsAsync in the GetStartedDemoAsync method.

    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
        await this.CreateDatabaseAsync();
        await this.CreateContainerAsync();
        await this.AddItemsToContainerAsync();
    
        //ADD THIS PART TO YOUR CODE
        await this.QueryItemsAsync();
    }
    
  3. Zvolte F5 pro spuštění aplikace.Select F5 to run your application.

Blahopřejeme!Congratulations! Úspěšně jste dotazováni na kontejner Azure Cosmos.You've successfully queried an Azure Cosmos container.

Krok 8: nahrazení položky JSONStep 8: Replace a JSON item

Teď aktualizujeme položku v Azure Cosmos DB.Now, we'll update an item in Azure Cosmos DB. Změníme IsRegistered vlastnost Family a na Grade jednu z podřízených objektů.We'll change the IsRegistered property of the Family and the Grade of one of the children.

  1. Zkopírujte a vložte ReplaceFamilyItemAsync metodu po své QueryItemsAsync metodě.Copy and paste the ReplaceFamilyItemAsync method after your QueryItemsAsync method.

    /// <summary>
    /// Replace an item in the container
    /// </summary>
    private async Task ReplaceFamilyItemAsync()
    {
        ItemResponse<Family> wakefieldFamilyResponse = await this.container.ReadItemAsync<Family>("Wakefield.7", new PartitionKey("Wakefield"));
        var itemBody = wakefieldFamilyResponse.Resource;
        
        // update registration status from false to true
        itemBody.IsRegistered = true;
        // update grade of child
        itemBody.Children[0].Grade = 6;
    
        // replace the item with the updated content
        wakefieldFamilyResponse = await this.container.ReplaceItemAsync<Family>(itemBody, itemBody.Id, new PartitionKey(itemBody.LastName));
        Console.WriteLine("Updated Family [{0},{1}].\n \tBody is now: {2}\n", itemBody.LastName, itemBody.Id, wakefieldFamilyResponse.Resource);
    }
    
  2. Do GetStartedDemoAsync metody přidejte volání ReplaceFamilyItemAsync .Add a call to ReplaceFamilyItemAsync in the GetStartedDemoAsync method.

    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
        await this.CreateDatabaseAsync();
        await this.CreateContainerAsync();
        await this.AddItemsToContainerAsync();
        await this.QueryItemsAsync();
    
        //ADD THIS PART TO YOUR CODE
        await this.ReplaceFamilyItemAsync();
    }
    
  3. Zvolte F5 pro spuštění aplikace.Select F5 to run your application.

Blahopřejeme!Congratulations! Úspěšně jste nahradili položku Azure Cosmos.You've successfully replaced an Azure Cosmos item.

Krok 9: odstranění položkyStep 9: Delete item

Nyní odstraníme položku v Azure Cosmos DB.Now, we'll delete an item in Azure Cosmos DB.

  1. Zkopírujte a vložte DeleteFamilyItemAsync metodu po své ReplaceFamilyItemAsync metodě.Copy and paste the DeleteFamilyItemAsync method after your ReplaceFamilyItemAsync method.

    /// <summary>
    /// Delete an item in the container
    /// </summary>
    private async Task DeleteFamilyItemAsync()
    {
        var partitionKeyValue = "Wakefield";
        var familyId = "Wakefield.7";
    
        // Delete an item. Note we must provide the partition key value and id of the item to delete
        ItemResponse<Family> wakefieldFamilyResponse = await this.container.DeleteItemAsync<Family>(familyId,new PartitionKey(partitionKeyValue));
        Console.WriteLine("Deleted Family [{0},{1}]\n", partitionKeyValue, familyId);
    }
    
  2. Do GetStartedDemoAsync metody přidejte volání DeleteFamilyItemAsync .Add a call to DeleteFamilyItemAsync in the GetStartedDemoAsync method.

    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
        await this.CreateDatabaseAsync();
        await this.CreateContainerAsync();
        await this.AddItemsToContainerAsync();
        await this.QueryItemsAsync();
        await this.ReplaceFamilyItemAsync();
    
        //ADD THIS PART TO YOUR CODE
        await this.DeleteFamilyItemAsync();
    }
    
  3. Zvolte F5 pro spuštění aplikace.Select F5 to run your application.

Blahopřejeme!Congratulations! Úspěšně jste odstranili položku Azure Cosmos.You've successfully deleted an Azure Cosmos item.

Krok 10: Odstranění databázeStep 10: Delete the database

Nyní odstraníme naši databázi.Now we'll delete our database. Odstraněním vytvořené databáze dojde k odebrání databáze a všech podřízených prostředků.Deleting the created database removes the database and all children resources. Mezi prostředky patří kontejnery, položky a jakékoli uložené procedury, uživatelsky definované funkce a triggery.The resources include containers, items, and any stored procedures, user-defined functions, and triggers. Odstraníme také CosmosClient instanci.We also dispose of the CosmosClient instance.

  1. Zkopírujte a vložte DeleteDatabaseAndCleanupAsync metodu po své DeleteFamilyItemAsync metodě.Copy and paste the DeleteDatabaseAndCleanupAsync method after your DeleteFamilyItemAsync method.

    /// <summary>
    /// Delete the database and dispose of the Cosmos Client instance
    /// </summary>
    private async Task DeleteDatabaseAndCleanupAsync()
    {
        DatabaseResponse databaseResourceResponse = await this.database.DeleteAsync();
        // Also valid: await this.cosmosClient.Databases["FamilyDatabase"].DeleteAsync();
    
        Console.WriteLine("Deleted Database: {0}\n", this.databaseId);
    
        //Dispose of CosmosClient
        this.cosmosClient.Dispose();
    }
    
  2. Do GetStartedDemoAsync metody přidejte volání DeleteDatabaseAndCleanupAsync .Add a call to DeleteDatabaseAndCleanupAsync in the GetStartedDemoAsync method.

    /// <summary>
    /// Entry point to call methods that operate on Azure Cosmos DB resources in this sample
    /// </summary>
    public async Task GetStartedDemoAsync()
    {
        // Create a new instance of the Cosmos Client
        this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
        await this.CreateDatabaseAsync();
        await this.CreateContainerAsync();
        await this.AddItemsToContainerAsync();
        await this.QueryItemsAsync();
        await this.ReplaceFamilyItemAsync();
        await this.DeleteFamilyItemAsync();
        await this.DeleteDatabaseAndCleanupAsync();
    }
    
  3. Zvolte F5 pro spuštění aplikace.Select F5 to run your application.

Blahopřejeme!Congratulations! Úspěšně jste odstranili databázi Azure Cosmos.You've successfully deleted an Azure Cosmos database.

Krok 11: Spuštění celé konzolové aplikace jazyka C#!Step 11: Run your C# console application all together!

V aplikaci Visual Studio vyberte F5 a sestavte a spusťte aplikaci v režimu ladění.Select F5 in Visual Studio to build and run the application in debug mode.

V okně konzoly byste měli vidět výstup celé aplikace.You should see the output of your entire app in a console window. Výstup zobrazuje výsledky dotazů, které jsme přidali.The output shows the results of the queries we added. Měl by odpovídat následujícímu ukázkovému textu.It should match the example text below.

Beginning operations...

Created Database: FamilyDatabase

Created Container: FamilyContainer

Created item in database with id: Andersen.1 Operation consumed 11.43 RUs.

Created item in database with id: Wakefield.7 Operation consumed 14.29 RUs.

Running query: SELECT * FROM c WHERE c.LastName = 'Andersen'

        Read {"id":"Andersen.1","LastName":"Andersen","Parents":[{"FamilyName":null,"FirstName":"Thomas"},{"FamilyName":null,"FirstName":"Mary Kay"}],"Children":[{"FamilyName":null,"FirstName":"Henriette Thaulow","Gender":"female","Grade":5,"Pets":[{"GivenName":"Fluffy"}]}],"Address":{"State":"WA","County":"King","City":"Seattle"},"IsRegistered":false}

Updated Family [Wakefield,Wakefield.7].
        Body is now: {"id":"Wakefield.7","LastName":"Wakefield","Parents":[{"FamilyName":"Wakefield","FirstName":"Robin"},{"FamilyName":"Miller","FirstName":"Ben"}],"Children":[{"FamilyName":"Merriam","FirstName":"Jesse","Gender":"female","Grade":6,"Pets":[{"GivenName":"Goofy"},{"GivenName":"Shadow"}]},{"FamilyName":"Miller","FirstName":"Lisa","Gender":"female","Grade":1,"Pets":null}],"Address":{"State":"NY","County":"Manhattan","City":"NY"},"IsRegistered":true}

Deleted Family [Wakefield,Wakefield.7]

Deleted Database: FamilyDatabase

End of demo, press any key to exit.

Blahopřejeme!Congratulations! Dokončili jste tento kurz a máte funkční konzolovou aplikaci jazyka C#!You've completed the tutorial and have a working C# console application!

Získání úplného řešení kurzuGet the complete tutorial solution

Pokud jste neměli dostatek času k dokončení kroků v tomto kurzu, nebo chcete pouze stáhnout ukázky kódu, můžete si ho stáhnout.If you didn't have time to complete the steps in this tutorial, or just want to download the code samples, you can download it.

K sestavení GetStarted řešení potřebujete následující požadavky:To build the GetStarted solution, you need the following prerequisites:

Chcete-li obnovit odkazy na sadu Azure Cosmos DB .NET SDK v aplikaci Visual Studio, klikněte pravým tlačítkem na řešení v Průzkumník řešenía potom vyberte možnost obnovit balíčky NuGet.To restore the references to the Azure Cosmos DB .NET SDK in Visual Studio, right-click the solution in Solution Explorer, and then select Restore NuGet Packages. Dále v souboru App. config aktualizujte hodnoty EndPointUri a PrimaryKey , jak je popsáno v kroku 3: připojení k Azure Cosmos DBmu účtu.Next, in the App.config file, update the EndPointUri and PrimaryKey values as described in Step 3: Connect to an Azure Cosmos DB account.

To je to, jak ho sestavit a vy budete vy.That's it, build it, and you're on your way!

Další krokyNext steps