Szybki start: Tworzenie aplikacji konsolowej .NET do zarządzania Azure Cosmos DB zasobów interfejsu API SQLQuickstart: Build a .NET console app to manage Azure Cosmos DB SQL API resources

Wprowadzenie do Azure Cosmos DB biblioteki klienta interfejsu API SQL dla platformy .NET.Get started with the Azure Cosmos DB SQL API client library for .NET. Wykonaj kroki opisane w tym dokumencie, aby zainstalować pakiet .NET, skompilować aplikację i wypróbować przykładowy kod dla podstawowych operacji CRUD na danych przechowywanych w Azure Cosmos DB.Follow the steps in this doc to install the .NET package, build an app, and try out the example code for basic CRUD operations on the data stored in Azure Cosmos DB.

Azure Cosmos DB to rozproszona globalnie wielomodelowa usługa bazy danych firmy Microsoft.Azure Cosmos DB is Microsoft’s globally distributed multi-model database service. Za pomocą Azure Cosmos DB można szybko tworzyć i badać bazy danych kluczy/wartości, dokumentów i grafów.You can use Azure Cosmos DB to quickly create and query key/value, document, and graph databases. Użyj Azure Cosmos DB biblioteki klienta interfejsu API SQL dla platformy .NET, aby:Use the Azure Cosmos DB SQL API client library for .NET to:

  • Tworzenie bazy danych i kontenera usługi Azure CosmosCreate an Azure Cosmos database and a container
  • Dodawanie przykładowych danych do konteneraAdd sample data to the container
  • Wykonywanie zapytań na danychQuery the data
  • Usuwanie bazy danychDelete the database

| Pakietkodu źródłowego biblioteki dokumentacji interfejsu API (NuGet) | API reference documentation | Library source code | Package (NuGet)

Wymagania wstępnePrerequisites

KonfigurowanieSetting up

Ta sekcja zawiera szczegółowe instrukcje dotyczące tworzenia konta usługi Azure Cosmos oraz konfigurowania projektu korzystającego z Azure Cosmos DB biblioteki klienta interfejsu API SQL dla platformy .NET do zarządzania zasobami.This section walks you through creating an Azure Cosmos account and setting up a project that uses Azure Cosmos DB SQL API client library for .NET to manage resources. Przykładowy kod opisany w tym artykule tworzy FamilyDatabase bazę danych i członków rodziny (każdy członek rodziny jest elementem) w tej bazie danych.The example code described in this article creates a FamilyDatabase database and family members (each family member is an item) within that database. Każdy członek rodziny ma właściwości, takie Id, FamilyName, FirstName, LastName, Parents, Children, Address,jak.Each family member has properties such as Id, FamilyName, FirstName, LastName, Parents, Children, Address,. LastName Właściwość jest używana jako klucz partycji dla kontenera.The LastName property is used as the partition key for the container.

Utwórz konto usługi Azure CosmosCreate an Azure Cosmos account

Jeśli używasz opcji wypróbuj Azure Cosmos DB bezpłatnie , aby utworzyć konto usługi Azure Cosmos, musisz utworzyć konto Azure Cosmos DB typu SQL API.If you use the Try Azure Cosmos DB for free option to create an Azure Cosmos account, you must create an Azure Cosmos DB account of type SQL API. Konto testowe Azure Cosmos DB zostało już utworzone.An Azure Cosmos DB test account is already created for you. Nie musisz jawnie tworzyć konta, więc możesz pominąć tę sekcję i przejść do następnej sekcji.You don't have to create the account explicitly, so you can skip this section and move to the next section.

Jeśli masz własną subskrypcję platformy Azure lub masz subskrypcję bezpłatnie, należy utworzyć konto usługi Azure Cosmos jawnie.If you have your own Azure subscription or created a subscription for free, you should create an Azure Cosmos account explicitly. Poniższy kod utworzy konto usługi Azure Cosmos z spójnością sesji.The following code will create an Azure Cosmos account with session consistency. Konto jest replikowane w South Central US i. North Central USThe account is replicated in South Central US and North Central US.

Za pomocą Azure Cloud Shell można utworzyć konto usługi Azure Cosmos.You can use Azure Cloud Shell to create the Azure Cosmos account. Azure Cloud Shell to interaktywna, uwierzytelniona powłoka dostępna dla przeglądarki służąca do zarządzania zasobami platformy Azure.Azure Cloud Shell is an interactive, authenticated, browser-accessible shell for managing Azure resources. Zapewnia ona elastyczność wybierania środowiska powłoki, które najlepiej odpowiada pracy, bash lub PowerShell.It provides the flexibility of choosing the shell experience that best suits the way you work, either Bash or PowerShell. Na potrzeby tego przewodnika Szybki Start wybierz tryb bash .For this quickstart, choose Bash mode. Azure Cloud Shell również wymaga konta magazynu, można je utworzyć po wyświetleniu monitu.Azure Cloud Shell also requires a storage account, you can create one when prompted.

Wybierz przycisk Wypróbuj obok poniższego kodu, wybierz tryb bash wybierz pozycję Utwórz konto magazynu i zaloguj się do Cloud Shell.Select the Try It button next to the following code, choose Bash mode select create a storage account and login to Cloud Shell. Następnie skopiuj Poniższy kod i wklej go do usługi Azure Cloud Shell i uruchom go.Next copy and paste the following code to Azure cloud shell and run it. Nazwa konta usługi Azure Cosmos musi być globalnie unikatowa, pamiętaj o zaktualizowaniu mysqlapicosmosdb wartości przed uruchomieniem polecenia.The Azure Cosmos account name must be globally unique, make sure to update the mysqlapicosmosdb value before you run the command.


# Set variables for the new SQL API account, database, and container
resourceGroupName='myResourceGroup'
location='southcentralus'

# The Azure Cosmos account name must be globally unique, make sure to update the `mysqlapicosmosdb` value before you run the command
accountName='mysqlapicosmosdb'

# Create a resource group
az group create \
    --name $resourceGroupName \
    --location $location

# Create a SQL API Cosmos DB account with session consistency and multi-master enabled
az cosmosdb create \
    --resource-group $resourceGroupName \
    --name $accountName \
    --kind GlobalDocumentDB \
    --locations regionName="South Central US" failoverPriority=0 --locations regionName="North Central US" failoverPriority=1 \
    --default-consistency-level "Session" \
    --enable-multiple-write-locations true

Tworzenie konta usługi Azure Cosmos zajmuje trochę czasu, po pomyślnym zakończeniu operacji można zobaczyć dane wyjściowe potwierdzenia.The creation of the Azure Cosmos account takes a while, once the operation is successful, you can see the confirmation output. Po pomyślnym zakończeniu wykonywania polecenia Zaloguj się do Azure Portal i sprawdź, czy istnieje konto usługi Azure Cosmos o określonej nazwie.After the command completes successfully, sign into the Azure portal and verify that the Azure Cosmos account with the specified name exists. Po utworzeniu zasobu możesz zamknąć okno Azure Cloud Shell.You can close the Azure Cloud Shell window after the resource is created.

Tworzenie nowej aplikacji platformy .NETCreate a new .NET app

Utwórz nową aplikację platformy .NET w preferowanym edytorze lub środowisku IDE.Create a new .NET application in your preferred editor or IDE. Otwórz wiersz polecenia systemu Windows lub okno terminalu na komputerze lokalnym.Open the Windows command prompt or a Terminal window from your local computer. Wszystkie polecenia zostaną uruchomione w następnych sekcjach z poziomu wiersza polecenia lub terminalu.You will run all the commands in the next sections from the command prompt or terminal. Uruchom następujące polecenie dotnet New, aby utworzyć nową aplikację o nazwie todo.Run the following dotnet new command to create a new app with the name todo. Parametr--langVersion ustawia właściwość LangVersion w utworzonym pliku projektu.The --langVersion parameter sets the LangVersion property in the created project file.

dotnet new console --langVersion 7.1 -n todo

Zmień katalog na nowo utworzony folder aplikacji.Change your directory to the newly created app folder. Aplikację można skompilować przy użyciu:You can build the application with:

cd todo
dotnet build

Oczekiwane dane wyjściowe kompilacji powinny wyglądać następująco:The expected output from the build should look something like this:

  Restore completed in 100.37 ms for C:\Users\user1\Downloads\CosmosDB_Samples\todo\todo.csproj.
  todo -> C:\Users\user1\Downloads\CosmosDB_Samples\todo\bin\Debug\netcoreapp2.2\todo.dll
  todo -> C:\Users\user1\Downloads\CosmosDB_Samples\todo\bin\Debug\netcoreapp2.2\todo.Views.dll

Build succeeded.
    0 Warning(s)
    0 Error(s)

Time Elapsed 00:00:34.17

Instalowanie pakietu Azure Cosmos DBInstall the Azure Cosmos DB package

Nadal w katalogu aplikacji Zainstaluj Azure Cosmos DBą bibliotekę kliencką dla platformy .NET Core za pomocą polecenia dotnet Add Package.While still in the application directory, install the Azure Cosmos DB client library for .NET Core by using the dotnet add package command.

dotnet add package Microsoft.Azure.Cosmos

Skopiuj poświadczenia konta usługi Azure Cosmos z Azure PortalCopy your Azure Cosmos account credentials from the Azure portal

Przykładowa aplikacja wymaga uwierzytelnienia na koncie usługi Azure Cosmos.The sample application needs to authenticate to your Azure Cosmos account. Aby przeprowadzić uwierzytelnianie, należy przekazać poświadczenia konta usługi Azure Cosmos do aplikacji.To authenticate, you should pass the Azure Cosmos account credentials to the application. Uzyskaj poświadczenia konta usługi Azure Cosmos, wykonując następujące czynności:Get your Azure Cosmos account credentials by following these steps:

  1. Zaloguj się w witrynie Azure Portal.Sign in to the Azure portal.

  2. Przejdź do swojego konta usługi Azure Cosmos.Navigate to your Azure Cosmos account.

  3. Otwórz okienko klucze i skopiuj Identyfikator URI i klucz podstawowy konta.Open the Keys pane and copy the URI and PRIMARY KEY of your account. W następnym kroku dodasz wartości identyfikatora URI i kluczy do zmiennej środowiskowej.You will add the URI and keys values to an environment variable in the next step.

Ustawianie zmiennych środowiskowychSet the environment variables

Po skopiowaniu identyfikatora URI i klucza podstawowego konta Zapisz je w nowej zmiennej środowiskowej na maszynie lokalnej, na której działa aplikacja.After you have copied the URI and PRIMARY KEY of your account, save them to a new environment variable on the local machine running the application. Aby ustawić zmienną środowiskową, Otwórz okno konsoli i uruchom następujące polecenie.To set the environment variable, open a console window, and run the following command. Pamiętaj, aby zastąpić <Your_Azure_Cosmos_account_URI> wartości <Your_Azure_Cosmos_account_PRIMARY_KEY> i.Make sure to replace <Your_Azure_Cosmos_account_URI> and <Your_Azure_Cosmos_account_PRIMARY_KEY> values.

WindowsWindows

setx EndpointUrl "<Your_Azure_Cosmos_account_URI>"
setx PrimaryKey "<Your_Azure_Cosmos_account_PRIMARY_KEY>"

LinuxLinux

export EndpointUrl = "<Your_Azure_Cosmos_account_URI>"
export PrimaryKey = "<Your_Azure_Cosmos_account_PRIMARY_KEY>"

MacOSMacOS

export EndpointUrl = "<Your_Azure_Cosmos_account_URI>"
export PrimaryKey = "<Your_Azure_Cosmos_account_PRIMARY_KEY>"

Model obiektówObject model

Przed rozpoczęciem tworzenia aplikacji Przyjrzyjmy się hierarchii zasobów w Azure Cosmos DB i modelu obiektów używanym do tworzenia tych zasobów i uzyskiwania do nich dostępu.Before you start building the application, let's look into the hierarchy of resources in Azure Cosmos DB and the object model used to create and access these resources. Azure Cosmos DB tworzy zasoby w następującej kolejności:The Azure Cosmos DB creates resources in the following order:

  • Konto usługi Azure CosmosAzure Cosmos account
  • Bazy danychDatabases
  • ContainersContainers
  • ElementyItems

Aby dowiedzieć się więcej o hierarchii różnych jednostek, zobacz Praca z bazami danych, kontenerami i elementami w Azure Cosmos DB artykule.To learn in more about the hierarchy of different entities, see the working with databases, containers, and items in Azure Cosmos DB article. Do korzystania z tych zasobów będziesz używać następujących klas platformy .NET:You will use the following .NET classes to interact with these resources:

  • CosmosClient — Ta klasa udostępnia logiczną reprezentację po stronie klienta dla usługi Azure Cosmos DB.CosmosClient - This class provides a client-side logical representation for the Azure Cosmos DB service. Obiekt klienta służy do konfigurowania i wykonywania żądań dotyczących usługi.The client object is used to configure and execute requests against the service.

  • CreateDatabaseIfNotExistsAsync — ta metoda tworzy (jeśli nie istnieje) lub pobiera (jeśli już istnieje) zasób bazy danych jako operację asynchroniczną.CreateDatabaseIfNotExistsAsync - This method creates (if doesn't exist) or gets (if already exists) a database resource as an asynchronous operation.

  • CreateContainerIfNotExistsAsync— ta metoda tworzy (jeśli nie istnieje) lub pobiera (jeśli już istnieje) kontener jako operację asynchroniczną.CreateContainerIfNotExistsAsync- - This method creates (if it doesn't exist) or gets (if it already exists) a container as an asynchronous operation. Możesz sprawdzić kod stanu z odpowiedzi, aby określić, czy kontener został nowo utworzony (201) czy został zwrócony istniejący kontener (200).You can check the status code from the response to determine whether the container was newly created (201) or an existing container was returned (200).

  • CreateItemAsync — ta metoda tworzy element w kontenerze.CreateItemAsync - This method creates an item within the container.

  • UpsertItemAsync — ta metoda tworzy element w kontenerze, jeśli jeszcze nie istnieje, lub zastępuje element, jeśli już istnieje.UpsertItemAsync - This method creates an item within the container if it doesn't already exist or replaces the item if it already exists.

  • GetItemQueryIterator — ta metoda tworzy zapytanie dla elementów w kontenerze w bazie danych Azure Cosmos przy użyciu instrukcji SQL z wartościami sparametryzowane.GetItemQueryIterator - This method creates a query for items under a container in an Azure Cosmos database using a SQL statement with parameterized values.

  • DeleteAsync — usuwa określoną bazę danych z konta usługi Azure Cosmos.DeleteAsync - Deletes the specified database from your Azure Cosmos account. DeleteAsyncMetoda usuwa tylko bazę danych.DeleteAsync method only deletes the database. Cosmosclient Usuwanie wystąpienia powinno nastąpić oddzielnie (które wykonuje Metoda DeleteDatabaseAndCleanupAsync.Disposing of the Cosmosclient instance should happen separately (which it does in the DeleteDatabaseAndCleanupAsync method.

Przykłady koduCode examples

Przykładowy kod opisany w tym artykule tworzy bazę danych rodziny w Azure Cosmos DB.The sample code described in this article creates a family database in Azure Cosmos DB. Baza danych rodziny zawiera szczegóły rodziny, takie jak nazwa, adres, lokalizacja, skojarzone elementy nadrzędne, dzieci i zwierzęta domowe.The family database contains family details such as name, address, location, the associated parents, children, and pets. Przed zapełnieniem danych na koncie usługi Azure Cosmos Zdefiniuj właściwości elementu rodziny.Before populating the data to your Azure Cosmos account, define the properties of a family item. Utwórz nową klasę o nazwie Family.cs na poziomie głównym aplikacji przykładowej i Dodaj do niej następujący kod:Create a new class named Family.cs at the root level of your sample application and add the following code to it:

using Newtonsoft.Json;

namespace todo
{
    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; }
        // The ToString() method is used to format the output, it's used for demo purpose only. It's not required by Azure Cosmos DB
        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; }
    }
}

Dodawanie dyrektyw using & Definiowanie obiektu klientaAdd the using directives & define the client object

W katalogu projektu Otwórz Program.cs plik w edytorze i Dodaj następujące dyrektywy using w górnej części aplikacji:From the project directory, open the Program.cs file in your editor and add the following using directives at the top of your application:


using System;
using System.Threading.Tasks;
using System.Configuration;
using System.Collections.Generic;
using System.Net;
using Microsoft.Azure.Cosmos;

W pliku program.cs Dodaj kod, aby odczytać zmienne środowiskowe, które zostały ustawione w poprzednim kroku.To the Program.cs file, add code to read the environment variables that you have set in the previous step. Zdefiniuj obiekty, Databasei. CosmosClient ContainerDefine the CosmosClient, Database, and the Container objects. Następnie Dodaj kod do metody Main, która wywołuje metodę GetStartedDemoAsync służącą do zarządzania zasobami kont usługi Azure Cosmos.Next add code to the main method that calls the GetStartedDemoAsync method where you manage Azure Cosmos account resources.

namespace todo
{
public class Program
{

    /// The Azure Cosmos DB endpoint for running this GetStarted sample.
    private string EndpointUrl = Environment.GetEnvironmentVariable("EndpointUrl");

    /// The primary key for the Azure DocumentDB account.
    private string PrimaryKey = Environment.GetEnvironmentVariable("PrimaryKey");

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

Tworzenie bazy danychCreate a database

CreateDatabaseAsync Zdefiniuj metodęprogram.cs w klasie.Define the CreateDatabaseAsync method within the program.cs class. Ta metoda tworzy, FamilyDatabase Jeśli jeszcze nie istnieje.This method creates the FamilyDatabase if it doesn't already exist.

private async Task CreateDatabaseAsync()
{
    // Create a new database
    this.database = await this.cosmosClient.CreateDatabaseIfNotExistsAsync(databaseId);
    Console.WriteLine("Created Database: {0}\n", this.database.Id);
}

Tworzenie konteneraCreate a container

CreateContainerAsync Zdefiniuj metodęprogram.cs w klasie.Define the CreateContainerAsync method within the program.cs class. Ta metoda tworzy, FamilyContainer Jeśli jeszcze nie istnieje.This method creates the FamilyContainer if it doesn't already exist.

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

Utwórz elementCreate an item

Utwórz element rodziny poprzez dodanie AddItemsToContainerAsync metody do następującego kodu.Create a family item by adding the AddItemsToContainerAsync method with the following code. Możesz użyć metod lub CreateItemAsync UpsertItemAsync , aby utworzyć element:You can use the CreateItemAsync or UpsertItemAsync methods to create an item:

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. ReadItemAsync will throw an exception if the item does not exist and return status code 404 (Not found).
    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);
}
}

Zbadaj elementyQuery the items

Po wstawieniu elementu można uruchomić zapytanie w celu uzyskania szczegółów rodziny "Andersen".After inserting an item, you can run a query to get the details of "Andersen" family. Poniższy kod przedstawia sposób wykonywania zapytania bezpośrednio przy użyciu zapytania SQL.The following code shows how to execute the query using the SQL query directly. Zapytanie SQL, aby uzyskać szczegółowe informacje dotyczące rodziny "Anderson": SELECT * FROM c WHERE c.LastName = 'Andersen'.The SQL query to get the "Anderson" family details is: SELECT * FROM c WHERE c.LastName = 'Andersen'. QueryItemsAsync Zdefiniuj metodęprogram.cs w klasie i Dodaj do niej następujący kod:Define the QueryItemsAsync method within the program.cs class and add the following code to it:

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

Usuwanie bazy danychDelete the database

Na koniec można usunąć bazę danych, dodając DeleteDatabaseAndCleanupAsync do niej następujący kod:Finally you can delete the database adding the DeleteDatabaseAndCleanupAsync method with the following code:

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

Wykonywanie operacji CRUDExecute the CRUD operations

Po zdefiniowaniu wszystkich wymaganych metod wykonaj je za pomocą GetStartedDemoAsync metody.After you have defined all the required methods, execute them with in the GetStartedDemoAsync method. DeleteDatabaseAndCleanupAsync Metoda z komentarzem w tym kodzie, ponieważ nie będą wyświetlane żadne zasoby, jeśli ta metoda jest wykonywana.The DeleteDatabaseAndCleanupAsync method commented out in this code because you will not see any resources if that method is executed. Po zweryfikowaniu, że Azure Cosmos DB zasoby zostały utworzone w Azure Portal, można usunąć z niego komentarz.You can uncomment it after validating that your Azure Cosmos DB resources were created in the Azure portal.

public async Task GetStartedDemoAsync()
{
    // Create a new instance of the Cosmos Client
    this.cosmosClient = new CosmosClient(EndpointUrl, PrimaryKey);
    await this.CreateDatabaseAsync();
    await this.CreateContainerAsync();
    await this.AddItemsToContainerAsync();
    await this.QueryItemsAsync();
}

Po dodaniu wszystkich wymaganych metod Zapisz Program.cs plik.After you add all the required methods, save the Program.cs file.

Uruchamianie koduRun the code

Następnie Skompiluj i uruchom aplikację, aby utworzyć zasoby Azure Cosmos DB.Next build and run the application to create the Azure Cosmos DB resources. Upewnij się, że otwarto nowe okno wiersza polecenia, nie używaj tego samego wystąpienia, które było używane do ustawiania zmiennych środowiskowych.Make sure to open a new command prompt window, don't use the same instance that you have used to set the environment variables. Ponieważ zmienne środowiskowe nie są ustawione w bieżącym otwartym oknie.Because the environment variables are not set in the current open window. Aby wyświetlić aktualizacje, należy otworzyć nowy wiersz polecenia.You will need to open a new command prompt to see the updates.

dotnet build
dotnet run

Po uruchomieniu aplikacji generowane są następujące dane wyjściowe.The following output is generated when you run the application. Możesz również zalogować się do Azure Portal i sprawdzić, czy zasoby są tworzone:You can also sign into the Azure portal and validate that the resources are created:

Created Database: FamilyDatabase

Created Container: FamilyContainer

Created item in database with id: Andersen.1 Operation consumed 11.62 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}

End of demo, press any key to exit.

Możesz sprawdzić, czy dane zostały utworzone, logując się do Azure Portal i zobacz wymagane elementy na koncie usługi Azure Cosmos.You can validate that the data is created by signing into the Azure portal and see the required items in your Azure Cosmos account.

Oczyszczanie zasobówClean up resources

Gdy nie jest już potrzebne, możesz użyć interfejsu wiersza polecenia platformy Azure lub Azure PowerShell, aby usunąć konto usługi Azure Cosmos i odpowiednią grupę zasobów.When no longer needed, you can use the Azure CLI or Azure PowerShell to remove the Azure Cosmos account and the corresponding resource group. Następujące polecenie pokazuje, jak usunąć grupę zasobów przy użyciu interfejsu wiersza polecenia platformy Azure:The following command shows how to delete the resource group by using the Azure CLI:

az group delete -g "myResourceGroup"

Następne krokiNext steps

W tym przewodniku szybki start przedstawiono sposób tworzenia konta usługi Azure Cosmos, tworzenia bazy danych i kontenera przy użyciu aplikacji platformy .NET Core.In this quickstart, you learned how to create an Azure Cosmos account, create a database and a container using a .NET Core app. Teraz możesz zaimportować dodatkowe dane do konta usługi Azure Cosmos za pomocą instrukcji int w następującym artykule.You can now import additional data to your Azure Cosmos account with the instructions int the following article.