Zelf studie: een .NET-console-app maken voor het beheren van gegevens in Azure Cosmos DB SQL-API-accountTutorial: Build a .NET console app to manage data in Azure Cosmos DB SQL API account

Welkom bij de zelf studie de Azure Cosmos DB SQL API aan de slag.Welcome to the Azure Cosmos DB SQL API get started tutorial. Wanneer u deze zelfstudie hebt voltooid, beschikt u over een consoletoepassing waarmee u Azure Cosmos DB-resources kunt maken en er query's op kunt uitvoeren.After following this tutorial, you'll have a console application that creates and queries Azure Cosmos DB resources.

In deze zelf studie wordt versie 3,0 of hoger van de Azure Cosmos db .NET SDKgebruikt.This tutorial uses version 3.0 or later of the Azure Cosmos DB .NET SDK. U kunt werken met .NET Framework of .net core.You can work with .NET Framework or .NET Core.

In deze zelfstudie komt het volgende aan bod:This tutorial covers:

  • Een Azure Cosmos-account maken en verbindenCreating and connecting to an Azure Cosmos account
  • Uw project configureren in Visual StudioConfiguring your project in Visual Studio
  • Een database en een container makenCreating a database and a container
  • Items toevoegen aan de containerAdding items to the container
  • Een query uitvoeren op de containerQuerying the container
  • Maken, lezen, bijwerken en verwijderen (ruwe) bewerkingen op het item uitvoerenPerforming create, read, update, and delete (CRUD) operations on the item
  • De database verwijderenDeleting the database

Hebt u geen tijd?Don't have time? Geen probleem.Don't worry! De volledige oplossing is beschikbaar via GitHub.The complete solution is available on GitHub. Ga naar de sectie De volledige zelfstudieoplossing ophalen voor beknopte instructies.Jump to the Get the complete tutorial solution section for quick instructions.

Tijd om aan de slag te gaan.Now let's get started!

VereistenPrerequisites

Stap 1: een Azure Cosmos DB-account makenStep 1: Create an Azure Cosmos DB account

Begin met het maken van een Azure Cosmos DB-account.Let's create an Azure Cosmos DB account. Als u al een account hebt dat u wilt gebruiken, kunt u deze sectie overs Laan.If you already have an account you want to use, skip this section. Als u de Azure Cosmos DB-emulator wilt gebruiken, volgt u de stappen op Azure Cosmos DB-emulator om de emulator in te stellen.To use the Azure Cosmos DB Emulator, follow the steps at Azure Cosmos DB Emulator to set up the emulator. Ga vervolgens verder met stap 2: uw Visual Studio-project instellen.Then skip ahead to Step 2: Set up your Visual Studio project.

  1. Selecteer vanuit het menu van Azure Portal of op de startpagina de optie Een resource maken.From the Azure portal menu or the Home page, select Create a resource.

  2. Zoek op de pagina Nieuw naar Azure Cosmos DB en selecteer dit.On the New page, search for and select Azure Cosmos DB.

  3. Selecteer op de pagina Azure Cosmos DB Maken.On the Azure Cosmos DB page, select Create.

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

    InstellingSetting WaardeValue BeschrijvingDescription
    AbonnementSubscription AbonnementsnaamSubscription name Selecteer het Azure-abonnement dat u voor dit Azure Cosmos-account wilt gebruiken.Select the Azure subscription that you want to use for this Azure Cosmos account.
    ResourcegroepResource Group Naam van de resourcegroepResource group name Selecteer een resourcegroep of selecteer Nieuwe maken en voer vervolgens een unieke naam in voor de nieuwe resourcegroep.Select a resource group, or select Create new, then enter a unique name for the new resource group.
    AccountnaamAccount Name Een unieke naamA unique name Voer een naam in om uw Azure Cosmos-account te identificeren.Enter a name to identify your Azure Cosmos account. Gebruik een unieke naam omdat documents.azure.com is toegevoegd aan de naam die u hebt opgegeven om uw URI te maken.Because documents.azure.com is appended to the name that you provide to create your URI, use a unique name.

    De naam mag alleen kleine letters, cijfers en het koppelteken (-) bevatten.The name can only contain lowercase letters, numbers, and the hyphen (-) character. De naam moet tussen de 3 en 44 tekens lang zijn.It must be between 3-44 characters in length.
    APIAPI Het type account dat moet worden gemaaktThe type of account to create Selecteer Core(SQL) om een documentdatabase en query's aan te maken met SQL-syntaxis.Select Core (SQL) to create a document database and query by using SQL syntax.

    De API bepaalt het type te maken account.The API determines the type of account to create. Azure Cosmos DB heeft vijf API's: Core (SQL) en MongoDB voor documentgegevens, Gremlin voor grafiekgegevens, Azure Table en Cassandra.Azure Cosmos DB provides five APIs: Core (SQL) and MongoDB for document data, Gremlin for graph data, Azure Table, and Cassandra. Op dit moment moet u voor elke API een afzonderlijk account maken.Currently, you must create a separate account for each API.

    Meer informatie over de SQL-API.Learn more about the SQL API.
    Korting voor gratis lagen toepassenApply Free Tier Discount Toepassen of niet toepassenApply or Do not apply Met de gratis laag van Azure Cosmos DB ontvangt u de eerste 400 RU/s en 5 GB aan opslagruimte gratis in een account.With Azure Cosmos DB free tier, you will get the first 400 RU/s and 5 GB of storage for free in an account. Meer informatie over de gratis laag.Learn more about free tier.
    LocatieLocation De regio het dichtst bij uw gebruikersThe region closest to your users Selecteer een geografische locatie waar u het Azure Cosmos DB-account wilt hosten.Select a geographic location to host your Azure Cosmos DB account. Gebruik de locatie die zich het dichtst bij uw gebruikers bevindt, zodat ze de snelst mogelijke toegang tot de gegevens hebben.Use the location that is closest to your users to give them the fastest access to the data.
    AccounttypeAccount Type Productie of niet-productieProduction or Non-Production Selecteer Productie als het account wordt gebruikt voor een productie-werkbelasting.Select Production if the account will be used for a production workload. Selecteer Niet-productie als het account wordt gebruikt voor niet-productie, zoals ontwikkeling, testing, QA of fasering.Select Non-Production if the account will be used for non-production, e.g. development, testing, QA, or staging. Dit is een resourcetag-instelling in Azure die de portal-ervaring afstemt, maar geen invloed heeft op het onderliggende Azure Cosmos DB-account.This is an Azure resource tag setting that tunes the Portal experience but does not affect the underlying Azure Cosmos DB account. U kunt deze waarde op elk gewenst moment wijzigen.You can change this value anytime.

    Notitie

    U kunt per Azure-abonnement maximaal één gratis laag voor het Azure Cosmos DB-account hebben, en u moet zich aanmelden wanneer u het account maakt.You can have up to one free tier Azure Cosmos DB account per Azure subscription and must opt-in when creating the account. Als u de optie voor het toepassen van de korting voor gratis lagen niet ziet, betekent dit dat er al een ander account in het abonnement is ingeschakeld met een gratis laag.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.

    De pagina Nieuw account voor Azure Cosmos DB

  5. Selecteer Controleren + maken.Select Review + create. U kunt de secties Netwerk en Tags overslaan.You can skip the Network and Tags sections.

  6. Controleer de accountinstellingen en selecteer vervolgens Maken.Review the account settings, and then select Create. Het duurt een paar minuten om het account te maken.It takes a few minutes to create the account. Wacht tot de portal-pagina Uw implementatie is voltooid weergeeft.Wait for the portal page to display Your deployment is complete.

    Het deelvenster Meldingen in Azure Portal

  7. Selecteer Ga naar resource om naar de Azure Cosmos DB-accountpagina te gaan.Select Go to resource to go to the Azure Cosmos DB account page.

    De Azure Cosmos DB-accountpagina

Stap 2: uw Visual Studio-project instellenStep 2: Set up your Visual Studio project

  1. Open Visual Studio en selecteer een nieuw project maken.Open Visual Studio and select Create a new project.

  2. Kies in een nieuw project maken deoptie console-app (.NET Framework) voor C# en selecteer vervolgens volgende.In Create a new project, choose Console App (.NET Framework) for C#, then select Next.

  3. Geef uw project de naam CosmosGettingStartedTutorialen selecteer vervolgens maken.Name your project CosmosGettingStartedTutorial, and then select Create.

    Het project configureren

  4. Klik in de Solution Explorermet de rechter muisknop op uw nieuwe console toepassing. Deze bevindt zich onder uw Visual Studio-oplossing en selecteer NuGet-pakketten beheren.In the Solution Explorer, right-click your new console application, which is under your Visual Studio solution, and select Manage NuGet Packages.

  5. Selecteer in de NuGet-pakket manager Bladeren en zoek naar micro soft. Azure. Cosmos.In the NuGet Package Manager, select Browse and search for Microsoft.Azure.Cosmos. Kies micro soft. Azure. Cosmos en selecteer installeren.Choose Microsoft.Azure.Cosmos and select Install.

    NuGet voor Azure Cosmos DB-client-SDK installeren

    De pakket-id voor de Azure Cosmos DB SQL-API-clientbibliotheek is Microsoft Azure Cosmos DB-clientbibliotheek.The package ID for the Azure Cosmos DB SQL API Client Library is Microsoft Azure Cosmos DB Client Library.

Goed gedaan.Great! De configuratie is voltooid en u kunt nu aan de slag met het schrijven van code.Now that we finished the setup, let's start writing some code. Zie een .net-console-App ontwikkelen met Azure Cosmos DBvoor het voltooide project van deze zelf studie.For the completed project of this tutorial, see Developing a .NET console app using Azure Cosmos DB.

Stap 3: verbinding maken met een Azure Cosmos DB-accountStep 3: Connect to an Azure Cosmos DB account

  1. Vervang de verwijzingen aan het begin van uw C#-toepassing in het Program.cs -bestand door de volgende verwijzingen: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. Voeg deze constanten en variabelen toe aan Program uw klasse.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";
    }
    

    Notitie

    Als u bekend bent met de vorige versie van de .NET SDK, kunt u bekend zijn met de verzameling en het documentvan de voor waarden.If you're familiar with the previous version of the .NET SDK, you may be familiar with the terms collection and document. Omdat Azure Cosmos DB meerdere API-modellen ondersteunt, gebruikt versie 3,0 van de .NET SDK de algemene voor waarden container en item.Because Azure Cosmos DB supports multiple API models, version 3.0 of the .NET SDK uses the generic terms container and item. Een container kan een verzameling, grafiek of tabel zijn.A container can be a collection, graph, or table. Een item kan een document, Edge/vertex of rij zijn en is de inhoud in een container.An item can be a document, edge/vertex, or row, and is the content inside a container. Zie werken met data bases, containers en items in azure Cosmos DBvoor meer informatie.For more information, see Work with databases, containers, and items in Azure Cosmos DB.

  3. Open de Azure Portal.Open the Azure portal. Zoek uw Azure Cosmos DB-account en selecteer vervolgens sleutels.Find your Azure Cosmos DB account, and then select Keys.

    Azure Cosmos DB sleutels van Azure Portal ophalen

  4. Vervang Program.cs <your endpoint URL> in Program.cs door de waarde van URI.In Program.cs, replace <your endpoint URL> with the value of URI. Vervang <your primary key> door de waarde van de primaire sleutel.Replace <your primary key> with the value of PRIMARY KEY.

  5. Voeg onder de methode Main een nieuwe asynchrone taak toe met de naam GetStartedDemoAsync, waarmee een nieuw CosmosClientexemplaar wordt gemaakt.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);
    }
    

    We gebruiken GetStartedDemoAsync als het invoer punt dat methoden aanroept die op Azure Cosmos DB resources werken.We use GetStartedDemoAsync as the entry point that calls methods that operate on Azure Cosmos DB resources.

  6. Voeg de volgende code toe om de asynchrone taak GetStartedDemoAsync uit te voeren vanuit de methode Main.Add the following code to run the GetStartedDemoAsync asynchronous task from your Main method. Uitzonderingen worden door de methode Main onderschept en naar de console geschreven.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. Selecteer F5 om de toepassing uit te voeren.Select F5 to run your application.

    In de console wordt het volgende bericht weer gegeven: einde van demo, druk op een wille keurige toets om af te sluiten.The console displays the message: End of demo, press any key to exit. Dit bericht bevestigt dat uw toepassing een verbinding heeft gemaakt met Azure Cosmos DB.This message confirms that your application made a connection to Azure Cosmos DB. U kunt vervolgens het consolevenster sluiten.You can then close the console window.

Gefeliciteerd!Congratulations! U hebt verbinding gemaakt met een Azure Cosmos DB-account.You've successfully connected to an Azure Cosmos DB account.

Stap 4: een database makenStep 4: Create a database

Een database is de logische container voor items die zijn gepartitioneerd in containers.A database is the logical container of items partitioned across containers. U kunt CreateDatabaseIfNotExistsAsync een CreateDatabaseAsync data base maken met de or-methode van de CosmosClient -klasse.Either the CreateDatabaseIfNotExistsAsync or CreateDatabaseAsync method of the CosmosClient class can create a database.

  1. Kopieer en plak de CreateDatabaseAsync methode onder uw GetStartedDemoAsync methode.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);
    }
    

    CreateDatabaseAsyncHiermee maakt u een nieuwe Data FamilyDatabase Base met id als deze nog niet bestaat, met de id die databaseId is opgegeven in het veld.CreateDatabaseAsync creates a new database with ID FamilyDatabase if it doesn't already exist, that has the ID specified from the databaseId field.

  2. Kopieer en plak de onderstaande code, waarbij u de CosmosClient maakt om de CreateDatabaseAsync -methode aan te roepen die u zojuist hebt toegevoegd.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();
    }
    

    Uw Program.cs moet er nu als volgt uitzien, waarbij uw eind punt en de primaire sleutel zijn ingevuld.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. Selecteer F5 om de toepassing uit te voeren.Select F5 to run your application.

    Notitie

    Als u de fout melding ' 503-Service niet beschikbaar ' krijgt, is het mogelijk dat de vereiste poorten voor de directe connectiviteits modus worden geblokkeerd door een firewall.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. Als u dit probleem wilt oplossen, opent u de vereiste poorten of gebruikt u de connectiviteit van de gateway modus, zoals wordt weer gegeven in de volgende code:To fix this issue, either open the required ports or use the gateway mode connectivity as shown in the following code:

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

Gefeliciteerd!Congratulations! U hebt een Azure Cosmos-data base gemaakt.You've successfully created an Azure Cosmos database.

Stap 5: een container makenStep 5: Create a container

Waarschuwing

De- CreateContainerIfNotExistsAsync methode maakt een nieuwe container met prijs implicaties.The method CreateContainerIfNotExistsAsync creates a new container, which has pricing implications. Ga naar onze pagina met prijzenvoor meer informatie.For more details, please visit our pricing page.

Een container kan worden gemaakt met behulp van de CreateContainerIfNotExistsAsync -of CreateContainerAsync - CosmosDatabase methode in de-klasse.A container can be created by using either the CreateContainerIfNotExistsAsync or CreateContainerAsync method in the CosmosDatabase class. Een container bestaat uit items (JSON-documenten als SQL-API) en de bijbehorende toepassings logica aan de server zijde in Java script, bijvoorbeeld opgeslagen procedures, door de gebruiker gedefinieerde functies en triggers.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. Kopieer en plak de CreateContainerAsync methode onder uw CreateDatabaseAsync methode.Copy and paste the CreateContainerAsync method below your CreateDatabaseAsync method. CreateContainerAsyncHiermee wordt een nieuwe container met de FamilyContainer id gemaakt als deze nog niet bestaat, met behulp van de containerId id die is opgegeven LastName in het veld gepartitioneerd door van de eigenschap.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. Kopieer de onderstaande code en plak deze waar u de CosmosClient hebt geïnstantieerd om de methode CreateContainer aan te roepen die u zojuist hebt toegevoegd.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. Selecteer F5 om de toepassing uit te voeren.Select F5 to run your application.

Gefeliciteerd!Congratulations! U hebt een Azure Cosmos-container gemaakt.You've successfully created an Azure Cosmos container.

Stap 6: items toevoegen aan de containerStep 6: Add items to the container

De methode CreateItemAsync van de CosmosContainer klasse kan een item maken.The CreateItemAsync method of the CosmosContainer class can create an item. Bij gebruik van de SQL-API worden items geprojecteerd als documenten, die door de gebruiker gedefinieerde wille keurige JSON-inhoud zijn.When using the SQL API, items are projected as documents, which are user-defined arbitrary JSON content. U kunt nu een item invoegen in de Azure Cosmos-container.You can now insert an item into your Azure Cosmos container.

Eerst gaan we een Family klasse maken die objecten vertegenwoordigt die zijn opgeslagen in azure Cosmos db in dit voor beeld.First, let's create a Family class that represents objects stored within Azure Cosmos DB in this sample. We maken Parent Child Petook subklassen die in Familyworden gebruikt. AddressWe'll also create Parent, Child, Pet, Address subclasses that are used within Family. Het item moet een Id eigenschap hebben die is geserialiseerd id als in JSON.The item must have an Id property serialized as id in JSON.

  1. Selecteer CTRL + SHIFT + A om Nieuw item toevoegente openen.Select Ctrl+Shift+A to open Add New Item. Voeg een nieuwe klasse Family.cs toe aan uw project.Add a new class Family.cs to your project.

    Scherm opname van het toevoegen van een nieuwe Family.cs-klasse aan het project

  2. Kopieer en plak de Family, Parent Child,, Peten Address -klasse in Family.cs.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. Voeg na de CreateContainerAsync methode terug in AddItemsToContainerAsync Program.csde methode toe.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);
        }
    }
    

    Met de code wordt gecontroleerd of er al een item met dezelfde ID bestaat.The code checks to make sure an item with the same ID doesn't already exist. Er worden twee items ingevoegd, één voor de familie en de Wakefield-serie.We'll insert two items, one each for the Andersen Family and the Wakefield Family.

  4. Voeg een aanroep naar AddItemsToContainerAsync toe in de methode GetStartedDemoAsync.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. Selecteer F5 om de toepassing uit te voeren.Select F5 to run your application.

Gefeliciteerd!Congratulations! U hebt twee Azure Cosmos-items gemaakt.You've successfully created two Azure Cosmos items.

Stap 7: query's uitvoeren op Azure Cosmos DB-resourcesStep 7: Query Azure Cosmos DB resources

Azure Cosmos DB biedt ondersteuning voor uitgebreide query's voor de JSON-documenten die in elke container zijn opgeslagen.Azure Cosmos DB supports rich queries against JSON documents stored in each container. Zie aan de slag met SQL-query'svoor meer informatie.For more information, see Getting started with SQL queries. In de volgende voorbeeldcode ziet u hoe u een query uitvoert voor de items die u in de vorige stap hebt ingevoegd.The following sample code shows how to run a query against the items we inserted in the previous step.

  1. Kopieer en plak de QueryItemsAsync -methode na AddItemsToContainerAsync uw methode.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. Voeg een aanroep naar QueryItemsAsync toe in de methode GetStartedDemoAsync.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. Selecteer F5 om de toepassing uit te voeren.Select F5 to run your application.

Gefeliciteerd!Congratulations! U hebt een query uitgevoerd op een Azure Cosmos-container.You've successfully queried an Azure Cosmos container.

Stap 8: een JSON-item vervangenStep 8: Replace a JSON item

Nu gaan we een item bijwerken in Azure Cosmos DB.Now, we'll update an item in Azure Cosmos DB. We wijzigen de IsRegistered eigenschap van de Family en Grade van de onderliggende items.We'll change the IsRegistered property of the Family and the Grade of one of the children.

  1. Kopieer en plak de ReplaceFamilyItemAsync -methode na QueryItemsAsync uw methode.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. Voeg een aanroep naar ReplaceFamilyItemAsync toe in de methode GetStartedDemoAsync.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. Selecteer F5 om de toepassing uit te voeren.Select F5 to run your application.

Gefeliciteerd!Congratulations! U hebt een Azure Cosmos-item vervangen.You've successfully replaced an Azure Cosmos item.

Stap 9: item verwijderenStep 9: Delete item

Nu gaan we een item verwijderen uit Azure Cosmos DB.Now, we'll delete an item in Azure Cosmos DB.

  1. Kopieer en plak de DeleteFamilyItemAsync -methode na ReplaceFamilyItemAsync uw methode.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. Voeg een aanroep naar DeleteFamilyItemAsync toe in de methode GetStartedDemoAsync.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. Selecteer F5 om de toepassing uit te voeren.Select F5 to run your application.

Gefeliciteerd!Congratulations! U hebt een Azure Cosmos-item verwijderd.You've successfully deleted an Azure Cosmos item.

Stap 10: de database verwijderenStep 10: Delete the database

Nu gaan we onze data base verwijderen.Now we'll delete our database. Als u de gemaakte data base verwijdert, worden de data base en alle onderliggende resources verwijderd.Deleting the created database removes the database and all children resources. De resources omvatten containers, items en eventuele opgeslagen procedures, door de gebruiker gedefinieerde functies en triggers.The resources include containers, items, and any stored procedures, user-defined functions, and triggers. We verwijderen ook het CosmosClient exemplaar.We also dispose of the CosmosClient instance.

  1. Kopieer en plak de DeleteDatabaseAndCleanupAsync -methode na DeleteFamilyItemAsync uw methode.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. Voeg een aanroep naar DeleteDatabaseAndCleanupAsync toe in de methode GetStartedDemoAsync.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. Selecteer F5 om de toepassing uit te voeren.Select F5 to run your application.

Gefeliciteerd!Congratulations! U hebt een Azure Cosmos-data base verwijderd.You've successfully deleted an Azure Cosmos database.

Stap 11: uw C#-consoletoepassing volledig uitvoerenStep 11: Run your C# console application all together!

Druk in Visual Studio op F5 en compileer en voer de toepassing uit in de foutopsporingsmodus.Select F5 in Visual Studio to build and run the application in debug mode.

Als het goed is, wordt de uitvoer van de volledige app in een consolevenster weergegeven.You should see the output of your entire app in a console window. In de uitvoer ziet u de resultaten van de query's die we hebben toegevoegd.The output shows the results of the queries we added. Dit moet overeenkomen met de onderstaande voorbeeld tekst.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.

Gefeliciteerd!Congratulations! U hebt de zelfstudie voltooid en beschikt nu over een werkende C#-consoletoepassing.You've completed the tutorial and have a working C# console application!

De volledige zelfstudieoplossing ophalenGet the complete tutorial solution

Als u geen tijd hebt gehad om de stappen in deze zelf studie uit te voeren of als u alleen de code voorbeelden wilt downloaden, kunt u deze downloaden.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.

U hebt de GetStarted volgende vereisten nodig om de oplossing te bouwen:To build the GetStarted solution, you need the following prerequisites:

Als u de verwijzingen naar de Azure Cosmos DB .NET SDK in Visual Studio wilt herstellen, klikt u met de rechter muisknop op de oplossing in Solution Exploreren selecteert u vervolgens NuGet-pakketten herstellen.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. Werk vervolgens in het bestand app. config de EndPointUri en PrimaryKey -waarden bij, zoals beschreven in stap 3: verbinding maken met een Azure Cosmos DB-account.Next, in the App.config file, update the EndPointUri and PrimaryKey values as described in Step 3: Connect to an Azure Cosmos DB account.

Dat is alles, bouw nu de oplossing. Succes!That's it, build it, and you're on your way!

Volgende stappenNext steps