Kurz: Vytvoření konzolové aplikace .NET pro správu dat v Azure Cosmos DB SQL API

PLATÍ PRO: ROZHRANÍ SQL API

Vítejte v úvodním kurzu Azure Cosmos DB SQL API. Až projdete tímto kurzem, budete mít konzolovou aplikaci, která vytváří prostředky Azure Cosmos DB a dotazuje se na ně.

V tomto kurzu se používá verze 3.0 nebo novější Azure Cosmos DB .NET SDK. Můžete pracovat s .NET Framework nebo .NET Core.

Tento kurz zahrnuje:

  • Vytvoření účtu Služby Azure Cosmos a připojení k účtu Azure Cosmos
  • Konfigurace projektu v Visual Studio
  • Vytvoření databáze a kontejneru
  • Přidání položek do kontejneru
  • Dotazování kontejneru
  • Provádění operací CRUD (vytvoření, čtení, aktualizace a odstranění) u položky
  • Odstranění databáze

Nemáte čas? Ale žádný strach. Úplné řešení je k dispozici na GitHubu. Rychlé pokyny najdete v části Získání kompletního řešení kurzu.

Můžeme začít!

Požadavky

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

Vytvořme účet služby Azure Cosmos DB. Pokud již máte účet, který chcete použít, tuto část přeskočte. Pokud chcete použít emulátor Azure Cosmos DB, postupujte podle pokynů v Azure Cosmos DB emulátoru a nastavte emulátor. Pak přeskočte k kroku 2: Nastavení projektu Visual Studio .

  1. V nabídce Azure Portal nebo na domovské stránce vyberte vytvořit prostředek.

  2. Na nové stránce vyhledejte a vyberte Azure Cosmos DB.

  3. Na stránce Azure Cosmos DB vyberte vytvořit.

  4. Na stránce vytvořit Azure Cosmos DB účet zadejte základní nastavení pro nový účet Azure Cosmos.

    Nastavení Hodnota Popis
    Předplatné Název předplatného Vyberte předplatné Azure, které chcete použít pro tento účet Azure Cosmos.
    Skupina prostředků Název skupiny prostředků Vyberte skupinu prostředků nebo vyberte vytvořit nové a zadejte jedinečný název nové skupiny prostředků.
    Account Name Jedinečný název Zadejte název, který identifikuje váš účet Azure Cosmos. 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.

    Název může obsahovat jenom malá písmena, číslice a znak spojovníku (-). Musí mít délku 3-31 znaků.
    rozhraní API Typ účtu, který se má vytvořit Vyberte Core (SQL) pro vytvoření databáze dokumentů a dotaz pomocí syntaxe SQL.

    Rozhraní API určuje typ účtu, který se má vytvořit. Azure Cosmos DB poskytuje pět rozhraní API: Core (SQL) a MongoDB pro data dokumentů, Gremlin pro data grafu, tabulku Azure a Cassandra. V současné době musíte pro každé rozhraní API vytvořit samostatný účet.

    Přečtěte si další informace o rozhraní SQL API.
    Umístění Oblast nejbližší vašim uživatelům Vyberte zeměpisné umístění, ve kterém chcete účet služby Azure Cosmos DB hostovat. 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.
    Režim kapacity Zřízená propustnost nebo bez serveru Vyberte zřízenou propustnost a vytvořte účet v režimu zřízené propustnosti . Pokud chcete vytvořit účet v režimu bez serveru , vyberte možnost bez serveru .
    Použít Azure Cosmos DB slevu úrovně Free Použít nebo nepoužít U Azure Cosmos DB úrovně Free získáte v účtu první 1000 RU/s a 25 GB úložiště zdarma. Přečtěte si další informace o bezplatné úrovni.

    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. 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.

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

  5. Na kartě globální distribuce nakonfigurujte následující podrobnosti. Pro účely tohoto rychlého startu můžete ponechat výchozí hodnoty:

    Nastavení Hodnota Popis
    Geografická redundance Zakázat Povolte nebo zakažte globální distribuci na účtu spárováním oblasti s oblastí dvojice. Později můžete do svého účtu přidat další oblasti.
    Zápisy do více oblastí Zakázat Funkce pro zápis ve více oblastech vám umožní využít zřízené propustnosti pro vaše databáze a kontejnery po celém světě.

    Poznámka

    Pokud jako režim kapacity vyberete možnost bez serveru , nejsou dostupné následující možnosti:

    • Použít slevu založenou na bezplatné úrovni
    • Geografická redundance
    • Zápisy do více oblastí
  6. Volitelně můžete na následujících kartách nakonfigurovat další podrobnosti:

    • Sítě – konfigurace přístupu z virtuální sítě.
    • Zásady zálohování – nakonfigurujte zásady pravidelného nebo průběžného zálohování.
    • Šifrování – použijte buď klíč spravovaný službou, nebo klíč spravovaný zákazníkem.
    • Značky – značky jsou páry název-hodnota , které umožňují kategorizaci prostředků a zobrazení konsolidované fakturace pomocí stejné značky pro více prostředků a skupin prostředků.
  7. Vyberte Zkontrolovat a vytvořit.

  8. Zkontrolujte nastavení účtu a pak vyberte vytvořit. Vytvoření účtu trvá několik minut. Počkejte, než se na stránce portálu zobrazí dokončené vaše nasazení.

    Podokno Oznámení portálu Azure Portal

  9. Vyberte Přejít k prostředku a přejdete na stránku Azure Cosmos DB účet.

    Stránka Azure Cosmos DB účtu

Krok 2: Nastavení Visual Studio projektu

  1. Otevřete Visual Studio a vyberte Create a new project (Vytvořit nový projekt).

  2. V části Vytvořit nový projekt zvolte Konzolová aplikace (.NET Framework) pro jazyk C# a pak vyberte Další.

  3. Pojmenujte projekt CosmosGettingStartedTutorial a pak vyberte Vytvořit.

    Konfigurace projektu

  4. V Průzkumník řešení klikněte pravým tlačítkem na novou konzolovou aplikaci, která je pod vaším Visual Studio, a vyberte Spravovat balíčky NuGet.

  5. Na webu NuGet Správce balíčků Procházet a vyhledejte Microsoft.Azure.Cosmos. Zvolte Microsoft.Azure.Cosmos a vyberte Nainstalovat.

    Instalace NuGetu pro Azure Cosmos DB Sdk

    ID balíčku s klientskou knihovnou rozhraní Azure Cosmos DB SQL API je Microsoft Azure Cosmos DB Client Library.

Výborně! Teď když jsme dokončili nastavování, napišme nějaký kód. Dokončený projekt tohoto kurzu najdete v tématu Vývoj konzolové aplikace .NET pomocí Azure Cosmos DB.

Krok 3: Připojení k účtu služby Azure Cosmos DB

  1. Nahraďte odkazy na začátku aplikace jazyka C# v souboru Program.cs těmito odkazy:

    using System;
    using System.Threading.Tasks;
    using System.Configuration;
    using System.Collections.Generic;
    using System.Net;
    using Microsoft.Azure.Cosmos;
    
  2. Přidejte tyto konstanty a proměnné do Program třídy .

    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 znáte předchozí verzi sady .NET SDK, možná znáte kolekci termínů a dokument. Protože Azure Cosmos DB více modelů rozhraní API, verze 3.0 sady .NET SDK používá obecné termíny kontejner a položka. Kontejnerem může být kolekce, graf nebo tabulka. Položka může být dokument, hrana/vrchol nebo řádek a je obsah uvnitř kontejneru. Další informace najdete v tématu Práce s databázemi, kontejnerya položkami v Azure Cosmos DB .

  3. Otevřete Azure Portal. Najděte Azure Cosmos DB účet a pak vyberte Klíče.

    Získání Azure Cosmos DB klíčů z Azure Portal

  4. V souboru Program.cs <your endpoint URL> nahraďte hodnotou URI. Nahraďte <your primary key> hodnotou PRIMÁRNÍ KLÍČ.

  5. Pod metodu Main přidejte novou asynchronní úlohu s názvem GetStartedDemoAsync, která vytvoří instanci nové úlohy 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);
    }
    

    Jako vstupní bod, který volá metody, Azure Cosmos DB které pracují s prostředky, používáme GetStartedDemoAsync.

  6. Přidejte následující kód, který spustí asynchronní úlohu GetStartedDemoAsync z metody Main. Metoda Main zachycuje výjimky a vypisuje je do konzoly.

    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. Výběrem klávesy F5 spusťte aplikaci.

    Konzola zobrazí zprávu Konec ukázky a stisknutím libovolné klávesy ji ukončete. Tato zpráva potvrzuje, že vaše aplikace se k této aplikaci Azure Cosmos DB. Potom můžete okno konzoly zavřít.

Gratulujeme! Úspěšně jste se připojili k Azure Cosmos DB účtu.

Krok 4: Vytvoření databáze

Databáze je logický kontejner položek rozdělených napříč kontejnery. Databáze může vytvořit metoda nebo třídy CreateDatabaseIfNotExistsAsync CreateDatabaseAsync CosmosClient.

  1. Zkopírujte a CreateDatabaseAsync vložte metodu pod GetStartedDemoAsync metodu .

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

    CreateDatabaseAsync vytvoří novou databázi s ID , pokud ještě neexistuje, která má FamilyDatabase zadané ID z pole databaseId .

  2. Zkopírujte a vložte kód níže, kde vytvoříte instanci CosmosClient pro volání metody CreateDatabaseAsync, kterou jste právě přidali.

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

    Soubor Program.cs by teď měl vypadat takhle a měl by být vyplněný koncový bod a primární klíč.

    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. Výběrem klávesy F5 spusťte aplikaci.

    Poznámka

    Pokud se zobrazí chyba 503 – Výjimka kvůli nedostupné službě, je možné, že brána firewall blokuje požadované porty pro režim přímého připojení. 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:

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

Gratulujeme! Úspěšně jste vytvořili databázi Azure Cosmos.

Krok 5: Vytvoření kontejneru

Upozornění

Metoda vytvoří CreateContainerIfNotExistsAsync nový kontejner, za který se budou mít vliv na ceny. Další podrobnosti najdete na naší stránce s cenami.

Kontejner lze vytvořit pomocí metody CreateContainerIfNotExistsAsync nebo CreateContainerAsync ve CosmosDatabase třídě . Kontejner se skládá z položek (dokumentů JSON, pokud sql API) a přidružené logiky aplikace na straně serveru v JavaScriptu, například uložených procedur, uživatelem definovaných funkcí a triggerů.

  1. Zkopírujte a CreateContainerAsync vložte metodu pod CreateDatabaseAsync metodu . CreateContainerAsync vytvoří nový kontejner s ID , pokud ještě neexistuje, pomocí ID zadaného z pole FamilyContainer containerId dělené LastName vlastností .

    /// <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 pro volání metody CreateContainer, kterou jste právě přidali.

    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. Výběrem klávesy F5 spusťte aplikaci.

Gratulujeme! Úspěšně jste vytvořili kontejner Azure Cosmos.

Krok 6: Přidání položek do kontejneru

Metoda CreateItemAsync třídy CosmosContainer může vytvořit položku. Při použití rozhraní SQL API se položky promítnou jako dokumenty, což je uživatelem definovaný libovolný obsah JSON. Teď můžete vložit položku do kontejneru Azure Cosmos.

Nejprve vytvoříme třídu, která představuje objekty uložené v Azure Cosmos DB Family této ukázce. Vytvoříme také Parent podtřídy , které se používají v rámci Child Pet Address Family . Položka musí mít vlastnost Id serializovaná jako id ve formátu JSON.

  1. Stisknutím kláves Ctrl+Shift+A otevřete okno Přidat novou položku. Přidejte do projektu Family.cs novou třídu.

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

  2. Zkopírujte a vložte Family třídu , , , a do Parent Child Pet Address 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 souboru Program.cs AddItemsToContainerAsync přidejte metodu za CreateContainerAsync metodu .

    /// <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, jestli položka se stejným ID ještě neexistuje. Vložíme dvě položky, jednu pro rodinu Andersen a rodinu Wakefield .

  4. Přidejte volání AddItemsToContainerAsync do metody GetStartedDemoAsync .

    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. Výběrem klávesy F5 spusťte aplikaci.

Gratulujeme! Úspěšně jste vytvořili dvě položky Azure Cosmos.

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

Azure Cosmos DB podporuje bohaté dotazy na dokumenty JSON uložené v jednotlivých kontejnerech. Další informace najdete v tématu Začínáme s dotazy SQL. Následující ukázkový kód ukazuje, jak spustit dotaz na položky, které jsme vložili v předchozím kroku.

  1. Zkopírujte a QueryItemsAsync vložte metodu za AddItemsToContainerAsync metodu .

    /// <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. Přidejte volání QueryItemsAsync do metody GetStartedDemoAsync .

    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. Výběrem klávesy F5 spusťte aplikaci.

Gratulujeme! Úspěšně jste se dotazoval na kontejner Azure Cosmos.

Krok 8: Nahrazení položky JSON

Teď aktualizujeme položku v Azure Cosmos DB. Změníme vlastnost a jedné IsRegistered Family z Grade dětí.

  1. Zkopírujte a ReplaceFamilyItemAsync vložte metodu za QueryItemsAsync metodu .

    /// <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. Přidejte volání ReplaceFamilyItemAsync do metody GetStartedDemoAsync .

    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. Výběrem klávesy F5 spusťte aplikaci.

Gratulujeme! Úspěšně jste nahradili položku Azure Cosmos.

Krok 9: Odstranění položky

Teď odstraníme položku v Azure Cosmos DB.

  1. Zkopírujte a DeleteFamilyItemAsync vložte metodu za ReplaceFamilyItemAsync metodu .

    /// <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. Přidejte volání DeleteFamilyItemAsync do metody GetStartedDemoAsync .

    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. Výběrem klávesy F5 spusťte aplikaci.

Gratulujeme! Úspěšně jste odstranili položku Azure Cosmos.

Krok 10: Odstranění databáze

Teď databázi odstraníme. Odstraněním vytvořené databáze se odebere databáze a všechny prostředky, které jsou v ní vytvořené. Prostředky zahrnují kontejnery, položky a všechny uložené procedury, uživatelem definované funkce a triggery. Instanci také CosmosClient zbavíme.

  1. Zkopírujte a DeleteDatabaseAndCleanupAsync vložte metodu za DeleteFamilyItemAsync metodu .

    /// <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. Přidejte volání DeleteDatabaseAndCleanupAsync do metody GetStartedDemoAsync .

    /// <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. Výběrem klávesy F5 spusťte aplikaci.

Gratulujeme! Úspěšně jste odstranili databázi Azure Cosmos.

Krok 11: Spuštění celé konzolové aplikace jazyka C#!

Výběrem klávesy F5 Visual Studio sestavíte a spustíte aplikaci v režimu ladění.

V okně konzoly by se měl zobrazit výstup celé aplikace. Výstup zobrazí výsledky dotazů, které jsme přidali. Měla by odpovídat následujícímu příkladu textu.

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.

Gratulujeme! Dokončili jste tento kurz a máte funkční konzolovou aplikaci jazyka C#!

Získání úplného řešení kurzu

Pokud jste neměli čas na dokončení kroků v tomto kurzu nebo si jenom chcete stáhnout ukázky kódu, můžete si ho stáhnout.

K sestavení GetStarted řešení potřebujete následující požadavky:

Pokud chcete obnovit odkazy na sadu Azure Cosmos DB .NET SDK v nástroji Visual Studio, klikněte pravým tlačítkem na řešení v Průzkumník řešení a pak vyberte Obnovit balíčky NuGet. Dále v souboru App.config aktualizujte hodnoty a , jak je popsáno v EndPointUri části Krok PrimaryKey 3:Připojení k Azure Cosmos DB účtu .

To je všechno, sestavte ho a jste na cestě!

Další kroky