Guida introduttiva: Compilare un'app console .NET per gestire le risorse dell'API SQL di Azure Cosmos DBQuickstart: Build a .NET console app to manage Azure Cosmos DB SQL API resources

Per iniziare a usare la libreria client dell'API SQL di Azure Cosmos DB per .NET,Get started with the Azure Cosmos DB SQL API client library for .NET. seguire i passaggi descritti in questo documento per installare il pacchetto .NET, compilare un'app e provare il codice di esempio per le operazioni CRUD di base sui dati archiviati in 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 è il servizio di database di Microsoft multimodello distribuito a livello globale.Azure Cosmos DB is Microsoft’s globally distributed multi-model database service. È possibile usare Azure Cosmos DB per creare rapidamente database di chiavi/valori, di documenti e a grafo ed eseguire query su di essi.You can use Azure Cosmos DB to quickly create and query key/value, document, and graph databases. Usare la libreria client dell'API SQL di Azure Cosmos DB per .NET per:Use the Azure Cosmos DB SQL API client library for .NET to:

  • Creare un database e un contenitore Azure CosmosCreate an Azure Cosmos database and a container
  • Aggiungere dati di esempio al contenitoreAdd sample data to the container
  • Eseguire query sui datiQuery the data
  • eliminare il databaseDelete the database

Documentazione di riferimento dell'API | Codice sorgente della libreria | Pacchetto (NuGet)API reference documentation | Library source code | Package (NuGet)

PrerequisitiPrerequisites

ConfigurazioneSetting up

Questa sezione illustra la creazione di un account Azure Cosmos e la configurazione di un progetto che usa la libreria client dell'API SQL di Azure Cosmos DB per .NET per gestire le risorse.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. Il codice di esempio descritto in questo articolo crea un database FamilyDatabase e i membri della famiglia (ogni membro della famiglia è un elemento) all'interno del database.The example code described in this article creates a FamilyDatabase database and family members (each family member is an item) within that database. Ogni membro della famiglia ha proprietà come Id, FamilyName, FirstName, LastName, Parents, Children, Address,.Each family member has properties such as Id, FamilyName, FirstName, LastName, Parents, Children, Address,. La proprietà LastName viene usata come chiave di partizione per il contenitore.The LastName property is used as the partition key for the container.

Creare un account Azure CosmosCreate an Azure Cosmos account

Se si usa l'opzione Prova gratuitamente Azure Cosmos DB per creare un account Azure Cosmos, è necessario creare un account Azure Cosmos DB di tipo API SQL.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. È già stato creato automaticamente un account di test Azure Cosmos DB.An Azure Cosmos DB test account is already created for you. Non è necessario creare l'account in modo esplicito, quindi è possibile ignorare questa sezione e passare a quella successiva.You don't have to create the account explicitly, so you can skip this section and move to the next section.

Se si dispone di una propria sottoscrizione di Azure o si è provveduto a creare gratuitamente una sottoscrizione, è necessario creare un account Azure Cosmos in modo esplicito.If you have your own Azure subscription or created a subscription for free, you should create an Azure Cosmos account explicitly. Il codice seguente creerà un account Azure Cosmos con coerenza di sessione.The following code will create an Azure Cosmos account with session consistency. L'account viene replicato in South Central US e North Central US.The account is replicated in South Central US and North Central US.

È possibile usare Azure Cloud Shell per creare l'account Azure Cosmos.You can use Azure Cloud Shell to create the Azure Cosmos account. Azure Cloud Shell è una shell interattiva, autenticata e accessibile tramite browser per la gestione delle risorse di Azure.Azure Cloud Shell is an interactive, authenticated, browser-accessible shell for managing Azure resources. Offre la flessibilità necessaria per scegliere l'esperienza shell più adatta al proprio modo di lavorare, ovvero Bash o PowerShell.It provides the flexibility of choosing the shell experience that best suits the way you work, either Bash or PowerShell. Per questo argomento di avvio rapido, scegliere Bash.For this quickstart, choose Bash mode. Azure Cloud Shell richiede anche un account di archiviazione, che è possibile creare quando richiesto.Azure Cloud Shell also requires a storage account, you can create one when prompted.

Fare clic sul pulsante Prova accanto al codice riportato di seguito, scegliere la modalità Bash, selezionare Crea un account di archiviazione e accedere a 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. Copiare e incollare il codice seguente in Azure Cloud Shell ed eseguirlo.Next copy and paste the following code to Azure cloud shell and run it. Il nome dell'account Azure Cosmos deve essere globalmente univoco, pertanto assicurarsi di aggiornare il valore mysqlapicosmosdb prima di eseguire il comando.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

La creazione dell'account Azure Cosmos richiede un po' di tempo. Al termine dell'operazione, è possibile visualizzare l'output di conferma.The creation of the Azure Cosmos account takes a while, once the operation is successful, you can see the confirmation output. Dopo che il comando viene completato correttamente, accedere al portale di Azure e verificare che sia presente l'account Azure Cosmos con il nome specificato.After the command completes successfully, sign into the Azure portal and verify that the Azure Cosmos account with the specified name exists. È possibile chiudere la finestra di Azure Cloud Shell dopo la creazione della risorsa.You can close the Azure Cloud Shell window after the resource is created.

Creare una nuova app .NETCreate a new .NET app

Creare una nuova applicazione .NET nell'ambiente di sviluppo integrato o nell'editor preferito.Create a new .NET application in your preferred editor or IDE. Aprire il prompt dei comandi di Windows o una finestra del terminale dal computer locale.Open the Windows command prompt or a Terminal window from your local computer. Tutti i comandi delle sezioni successive dovranno essere eseguiti dal prompt dei comandi o dal terminale.You will run all the commands in the next sections from the command prompt or terminal. Eseguire il comando dotnet new riportato di seguito per creare una nuova app denominata todo.Run the following dotnet new command to create a new app with the name todo. Il parametro --langVersion imposta la proprietà LangVersion nel file di progetto creato.The --langVersion parameter sets the LangVersion property in the created project file.

dotnet new console --langVersion 7.1 -n todo

Spostarsi nella cartella dell'app appena creata.Change your directory to the newly created app folder. È possibile compilare l'applicazione con il comando seguente:You can build the application with:

cd todo
dotnet build

L'output previsto al termine della creazione dovrebbe essere simile al seguente: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

Installare il pacchetto di Azure Cosmos DBInstall the Azure Cosmos DB package

Sempre nella directory dell'applicazione, installare la libreria client di Azure Cosmos DB per .NET Core usando il comando 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

Copiare le credenziali dell'account Azure Cosmos dal portale di AzureCopy your Azure Cosmos account credentials from the Azure portal

L'applicazione di esempio deve eseguire l'autenticazione all'account Azure Cosmos.The sample application needs to authenticate to your Azure Cosmos account. Per eseguire l'autenticazione, è necessario passare le credenziali dell'account Azure Cosmos all'applicazione.To authenticate, you should pass the Azure Cosmos account credentials to the application. Ottenere le credenziali dell'account Azure Cosmos seguendo questa procedura:Get your Azure Cosmos account credentials by following these steps:

  1. Accedere al portale di Azure.Sign in to the Azure portal.

  2. Accedere all'account Azure Cosmos.Navigate to your Azure Cosmos account.

  3. Aprire il riquadro Chiavi e copiare l'URI e la CHIAVE PRIMARIA dell'account.Open the Keys pane and copy the URI and PRIMARY KEY of your account. I valori dell'URI e delle chiavi verranno aggiunti a una variabile di ambiente nel passaggio successivo.You will add the URI and keys values to an environment variable in the next step.

Impostare le variabili di ambienteSet the environment variables

Dopo aver copiato l'URI e la CHIAVE PRIMARIA dell'account, salvarli in una nuova variabile di ambiente nel computer locale che esegue l'applicazione.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. Per impostare la variabile di ambiente, aprire una finestra della console ed eseguire il comando seguente.To set the environment variable, open a console window, and run the following command. Assicurarsi di sostituire i valori <Your_Azure_Cosmos_account_URI> e <Your_Azure_Cosmos_account_PRIMARY_KEY>.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>"

Modello a oggettiObject model

Prima di iniziare a compilare l'applicazione, verranno esaminati la gerarchia di risorse in Azure Cosmos DB e il modello a oggetti usato per creare e accedere a queste risorse.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 crea le risorse nell'ordine seguente:The Azure Cosmos DB creates resources in the following order:

  • Account Azure CosmosAzure Cosmos account
  • DatabaseDatabases
  • ContenitoriContainers
  • ItemsItems

Per altre informazioni sulla gerarchia delle diverse entità, vedere l'articolo sull'uso di database, contenitori ed elementi in Azure Cosmos DB.To learn in more about the hierarchy of different entities, see the working with databases, containers, and items in Azure Cosmos DB article. Per interagire con queste risorse, si useranno le classi .NET seguenti:You will use the following .NET classes to interact with these resources:

  • CosmosClient: questa classe fornisce una rappresentazione logica lato client per il servizio Azure Cosmos DB.CosmosClient - This class provides a client-side logical representation for the Azure Cosmos DB service. L'oggetto client viene usato per configurare ed eseguire richieste nel servizio.The client object is used to configure and execute requests against the service.

  • CreateDatabaseIfNotExistsAsync: questo metodo crea (se non esiste) o ottiene (se esiste già) una risorsa database come operazione asincrona.CreateDatabaseIfNotExistsAsync - This method creates (if doesn't exist) or gets (if already exists) a database resource as an asynchronous operation.

  • CreateContainerIfNotExistsAsync: questo metodo crea (se non esiste) o ottiene (se esiste già) un contenitore come operazione asincrona.CreateContainerIfNotExistsAsync- - This method creates (if it doesn't exist) or gets (if it already exists) a container as an asynchronous operation. È possibile controllare il codice di stato della risposta per determinare se il contenitore è stato appena creato (201) o se è stato restituito un contenitore esistente (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: questo metodo crea un elemento nel contenitore.CreateItemAsync - This method creates an item within the container.

  • UpsertItemAsync : questo metodo crea un elemento all'interno del contenitore se non esiste già oppure sostituisce l'elemento se è già esistente.UpsertItemAsync - This method creates an item within the container if it doesn't already exist or replaces the item if it already exists.

  • GetItemQueryIterator : questo metodo crea una query per gli elementi in un contenitore di un database di Azure Cosmos usando un'istruzione SQL contenente valori con parametri.GetItemQueryIterator - This method creates a query for items under a container in an Azure Cosmos database using a SQL statement with parameterized values.

  • DeleteAsync: elimina il database specificato dall'account Azure Cosmos.DeleteAsync - Deletes the specified database from your Azure Cosmos account. Il metodo DeleteAsync elimina solo il database.DeleteAsync method only deletes the database. L'eliminazione dell'istanza di Cosmosclient deve essere eseguita separatamente, nel metodo DeleteDatabaseAndCleanupAsync.Disposing of the Cosmosclient instance should happen separately (which it does in the DeleteDatabaseAndCleanupAsync method.

Esempi di codiceCode examples

Il codice di esempio descritto in questo articolo crea un database relativo alla famiglia in Azure Cosmos DB.The sample code described in this article creates a family database in Azure Cosmos DB. Il database contiene i dettagli della famiglia, ad esempio nome, indirizzo, località e genitori, figli e animali domestici associati.The family database contains family details such as name, address, location, the associated parents, children, and pets. Prima di popolare i dati nell'account Azure Cosmos, definire le proprietà di un elemento della famiglia.Before populating the data to your Azure Cosmos account, define the properties of a family item. Creare una nuova classe denominata Family.cs al livello radice dell'applicazione di esempio e aggiungervi il codice seguente: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; }
    }
}

Aggiungere le direttive using e definire l'oggetto clientAdd the using directives & define the client object

Dalla directory del progetto aprire il file Program.cs nell'editor e aggiungere le direttive using seguenti all'inizio dell'applicazione: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;

Nel file Program.cs aggiungere il codice per leggere le variabili di ambiente impostate nel passaggio precedente.To the Program.cs file, add code to read the environment variables that you have set in the previous step. Definire gli oggetti CosmosClient, Database e Container.Define the CosmosClient, Database, and the Container objects. Aggiungere quindi il codice al metodo principale che chiama il metodo GetStartedDemoAsync in cui si gestiscono le risorse dell'account 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();
        }
    }
}
}

Creare un databaseCreate a database

Definire il metodo CreateDatabaseAsync nella classe program.cs.Define the CreateDatabaseAsync method within the program.cs class. Questo metodo crea FamilyDatabase se non esiste già.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);
}

Creare un contenitoreCreate a container

Definire il metodo CreateContainerAsync nella classe program.cs.Define the CreateContainerAsync method within the program.cs class. Questo metodo crea FamilyContainer se non esiste già.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);
}

Creare un elementoCreate an item

Creare un elemento della famiglia aggiungendo il metodo AddItemsToContainerAsync con il codice seguente.Create a family item by adding the AddItemsToContainerAsync method with the following code. Per creare un elemento, è possibile usare il metodo CreateItemAsync o UpsertItemAsync: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);
}
}

Eseguire una query sugli elementiQuery the items

Dopo aver inserito un elemento, è possibile eseguire una query per ottenere i dettagli della famiglia "Andersen".After inserting an item, you can run a query to get the details of "Andersen" family. Il codice seguente illustra come eseguire la query usando direttamente la query SQL.The following code shows how to execute the query using the SQL query directly. La query SQL per ottenere i dettagli della famiglia "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'. Definire il metodo QueryItemsAsync nella classe program.cs e aggiungervi il codice seguente: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);
        }
    }
}

eliminare il databaseDelete the database

È infine possibile eliminare il database aggiungendo il metodo DeleteDatabaseAndCleanupAsync con il codice seguente: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();
}

Eseguire le operazioni CRUDExecute the CRUD operations

Dopo aver definito tutti i metodi necessari, eseguirli con il metodo GetStartedDemoAsync.After you have defined all the required methods, execute them with in the GetStartedDemoAsync method. Il metodo DeleteDatabaseAndCleanupAsync è impostato come commento in questo codice perché nessuna risorsa viene visualizzata se si esegue tale metodo.The DeleteDatabaseAndCleanupAsync method commented out in this code because you will not see any resources if that method is executed. È possibile rimuovere il commento dopo aver verificato che le risorse di Azure Cosmos DB siano state create nel portale di Azure.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();
}

Dopo aver aggiunto tutti i metodi necessari, salvare il file Program.cs.After you add all the required methods, save the Program.cs file.

Eseguire il codiceRun the code

Successivamente, compilare ed eseguire l'applicazione per creare le risorse di Azure Cosmos DB.Next build and run the application to create the Azure Cosmos DB resources. Assicurarsi di aprire una nuova finestra del prompt dei comandi. Non usare la stessa istanza usata per impostare le variabili di ambienteMake sure to open a new command prompt window, don't use the same instance that you have used to set the environment variables. perché le variabili di ambiente non sono impostate nella finestra aperta corrente.Because the environment variables are not set in the current open window. Per visualizzare gli aggiornamenti, sarà necessario aprire un nuovo prompt dei comandi.You will need to open a new command prompt to see the updates.

dotnet build
dotnet run

Quando si esegue l'applicazione, viene generato l'output seguente.The following output is generated when you run the application. È anche possibile accedere al portale di Azure e verificare che le risorse siano state create: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.

È possibile verificare che i dati vengano creati accedendo al portale di Azure e visualizzando gli elementi necessari nell'account 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.

Pulire le risorseClean up resources

Quando non sono più necessari, è possibile usare l'interfaccia della riga di comando di Azure o Azure PowerShell per rimuovere l'account Azure Cosmos e il gruppo di risorse corrispondente.When no longer needed, you can use the Azure CLI or Azure PowerShell to remove the Azure Cosmos account and the corresponding resource group. Il comando seguente mostra come eliminare il gruppo di risorse usando l'interfaccia della riga di comando di Azure:The following command shows how to delete the resource group by using the Azure CLI:

az group delete -g "myResourceGroup"

Passaggi successiviNext steps

In questo argomento di avvio rapido si è appreso come creare un account Azure Cosmos e come creare un database e un contenitore con un'app .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. È ora possibile importare dati aggiuntivi nell'account Azure Cosmos con le istruzioni incluse nell'articolo seguente.You can now import additional data to your Azure Cosmos account with the instructions int the following article.