Compilare un'app console .NET per gestire i dati in un account API SQL di Azure Cosmos DBBuild a .NET console app to manage data in Azure Cosmos DB SQL API account

Questa è un'esercitazione introduttiva per l'API SQL di Azure Cosmos DB.Welcome to the Azure Cosmos DB SQL API get started tutorial. Dopo aver completato questa esercitazione, si otterrà un'app console che consente di creare e ridefinire le query delle risorse Azure Cosmos DB.After you complete this tutorial, you'll have a console app that creates and queries Azure Cosmos DB resources.

Questa esercitazione illustra come:This tutorial shows you how to:

  • Creare un account Azure Cosmos DB e connettersi a essoCreate an Azure Cosmos DB account and connect to it
  • Configurare una soluzione di Visual StudioConfigure a Visual Studio solution
  • Creare un databaseCreate a database
  • Creare una raccoltaCreate a collection
  • Creare documenti JSONCreate JSON documents
  • Eseguire query sulla raccoltaQuery the collection
  • Aggiornare un documento JSONUpdate a JSON document
  • Eliminare un documentoDelete a document
  • eliminare il databaseDelete the database

PrerequisitiPrerequisites

Visual Studio 2017 con il flusso di lavoro di sviluppo di Azure installato:Visual Studio 2017 with the Azure development workflow installed:

Una sottoscrizione di Azure o un account di prova gratuito di Cosmos DB:An Azure subscription or free Cosmos DB trial account:

Ottenere la soluzione completaGet the completed solution

Se non si ha tempo per completare l'esercitazione o se si vogliono solo gli esempi di codice, è possibile scaricare la soluzione completa da GitHub.If you don't have time to complete the tutorial, or just want the code samples, you can download the complete solution from GitHub.

Per eseguire la soluzione completa scaricata:To run the downloaded complete solution:

  1. Assicurarsi di avere i prerequisiti installati.Make sure you have the Prerequisites installed.
  2. Aprire il file della soluzione GetStarted.sln scaricato in Visual Studio.Open the downloaded GetStarted.sln solution file in Visual Studio.
  3. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto GetStarted e scegliere Gestisci pacchetti NuGet.In Solution Explorer, right-click the GetStarted project, and select Manage NuGet Packages.
  4. Nella scheda NuGet selezionare Ripristina per ripristinare i riferimenti ad Azure Cosmos DB .NET SDK.On the NuGet tab, select Restore to restore the references to the Azure Cosmos DB .NET SDK.
  5. Nel file App.config aggiornare i valori EndpointUrl e PrimaryKey come illustrato nella sezione Connettersi all'account Azure Cosmos DB.In the App.config file, update the EndpointUrl and PrimaryKey values as described in the Connect to the Azure Cosmos DB account section.
  6. Selezionare Debug > Avvia senza eseguire debug o premere CTRL+F5 per compilare ed eseguire l'app.Select Debug > Start Without Debugging or press Ctrl+F5 to build and run the app.

Creare un account Azure Cosmos DBCreate an Azure Cosmos DB account

Seguire queste istruzioni per creare un account Azure Cosmos DB nel portale di Azure.Follow these instructions to create an Azure Cosmos DB account in the Azure portal. Se si ha già un account Azure Cosmos DB da usare, ignorare questo passaggio e passare a Configurare la soluzione di Visual Studio.If you already have an Azure Cosmos DB account to use, skip ahead to Set up the Visual Studio solution.

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

  2. Selezionare Crea una risorsa > Database > Azure Cosmos DB.Select Create a resource > Databases > Azure Cosmos DB.

    Riquadro Database nel portale di Azure

  3. Nella pagina Crea account Cosmos DB immettere le impostazioni base per il nuovo account Azure Cosmos.On the Create Azure Cosmos DB Account page, enter the basic settings for the new Azure Cosmos account.

    ImpostazioneSetting ValoreValue DESCRIZIONEDescription
    SottoscrizioneSubscription Nome della sottoscrizioneSubscription name Selezionare la sottoscrizione di Azure da usare per l'account Azure Cosmos.Select the Azure subscription that you want to use for this Azure Cosmos account.
    Gruppo di risorseResource Group Nome del gruppo di risorseResource group name Selezionare un gruppo di risorse oppure fare clic su Crea nuovo, quindi immettere un nome univoco per il nuovo gruppo di risorse.Select a resource group, or select Create new, then enter a unique name for the new resource group.
    Nome accountAccount Name Immettere un nome univocoEnter a unique name Immettere un nome per identificare l'account Azure Cosmos.Enter a name to identify your Azure Cosmos account. Poiché all'ID fornito viene aggiunto documents.azure.com per creare l'URI, usare un ID univoco.Because documents.azure.com is appended to the ID that you provide to create your URI, use a unique ID.

    L'ID può contenere solo lettere minuscole, numeri e il carattere trattino (-).The ID can only contain lowercase letters, numbers, and the hyphen (-) character. Deve avere una lunghezza compresa tra 3 e 31 caratteri.It must be between 3-31 characters in length.
    APIAPI Core (SQL)Core (SQL) L'API determina il tipo di account da creare.The API determines the type of account to create. Azure Cosmos DB offre cinque API: Core (SQL) e MongoDB per dati dei documenti, Gremlin per i dati dei grafici, Tabelle di Azure e Cassandra.Azure Cosmos DB provides five APIs: Core (SQL) and MongoDB for document data, Gremlin for graph data, Azure Table, and Cassandra. Attualmente, è necessario creare un account separato per ogni API.Currently, you must create a separate account for each API.

    Selezionare Core (SQL) per creare un database di documenti e una query con la sintassi SQL.Select Core (SQL) to create a document database and query by using SQL syntax.

    Altre informazioni sull'API SQL.Learn more about the SQL API.
    LocalitàLocation Selezionare l'area più vicina agli utentiSelect the region closest to your users Selezionare una posizione geografica in cui ospitare l'account Azure Cosmos DB.Select a geographic location to host your Azure Cosmos DB account. Usare la località più vicina agli utenti per offrire loro la massima velocità di accesso ai dati.Use the location that is closest to your users to give them the fastest access to the data.

    Pagina del nuovo account per Azure Cosmos DB

  4. Selezionare Rivedi e crea.Select Review + create. È possibile ignorare le sezioni Rete e Tag.You can skip the Network and Tags sections.

  5. Esaminare le impostazioni dell'account e quindi selezionare Crea.Review the account settings, and then select Create. La creazione dell'account richiede alcuni minuti.It takes a few minutes to create the account. Attendere che la pagina del portale visualizzi La distribuzione è stata completata.Wait for the portal page to display Your deployment is complete.

    Riquadro Notifiche del portale di Azure

  6. Selezionare Vai alla risorsa per passare alla pagina dell'account Azure Cosmos DB.Select Go to resource to go to the Azure Cosmos DB account page.

    Pagina dell'account Azure Cosmos DB

Configurare la soluzione in Visual StudioSet up the Visual Studio solution

  1. In Visual Studio 2017 selezionare File > Nuovo > Progetto.In Visual Studio 2017, select File > New > Project.

  2. Nella finestra di dialogo Nuovo progetto selezionare Visual C# > App console (.NET Framework) , assegnare al progetto il nome AzureCosmosDBApp e quindi fare clic su OK.In the New Project dialog, select Visual C# > Console App (.NET Framework), name your project AzureCosmosDBApp, and then select OK.

    Screenshot della finestra Nuovo progetto

  3. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto AzureCosmosDBApp e scegliere Gestisci pacchetti NuGet.In Solution Explorer, right-click the AzureCosmosDBApp project and select Manage NuGet Packages.

    Menu di scelta rapida del progetto

  4. Nella scheda NuGet selezionare Sfoglia e immettere azure documentdb nella casella di ricerca.On the NuGet tab, select Browse, and enter azure documentdb in the search box.

  5. Trovare e selezionare Microsoft.Azure.DocumentDB e selezionare Installa se non è già installato.Find and select Microsoft.Azure.DocumentDB, and select Install if it's not already installed.

    L'ID pacchetto per la libreria client dell'API SQL di Azure Cosmos DB è Microsoft Azure Cosmos DB Client Library.The package ID for the Azure Cosmos DB SQL API Client Library is Microsoft Azure Cosmos DB Client Library.

    Nota

    Se si usa .NET Core, vedere la documentazione di .NET Core.If you are using .NET Core, please see the .NET Core docs.

    Screenshot del menu di NuGet per l'individuazione di Azure Cosmos DB Client SDK

    Se viene visualizzato un messaggio sull'anteprima delle modifiche alla soluzione, fare clic su OK.If you get a message about previewing changes to the solution, select OK. Se viene visualizzato un messaggio sull'accettazione della licenza, selezionare Accetto.If you get a message about license acceptance, select I accept.

Connettersi all'account Azure Cosmos DBConnect to the Azure Cosmos DB account

Si inizierà ora a scrivere il codice.Now, get started writing some code. Il file Project.cs completo per questa esercitazione è disponibile in GitHub.The complete Project.cs file for this tutorial is in GitHub.

  1. In Esplora soluzioni selezionare Program.cs e nell'editor di codice aggiungere i riferimenti seguenti all'inizio del file:In Solution Explorer, select Program.cs, and in the code editor, add the following references to the beginning of the file:

    using System.Net;
    using Microsoft.Azure.Documents;
    using Microsoft.Azure.Documents.Client;
    using Newtonsoft.Json;
    
  2. Aggiungere quindi le due costanti seguenti e la variabile client a public class Program.Next, add the following two constants and the client variable to public class Program.

    
    public class Program
    {
       private const string EndpointUrl = "<your endpoint URL>";
       private const string PrimaryKey = "<your primary key>";
       private DocumentClient client;
    
  3. L'URL dell'endpoint e la chiave primaria consentono all'app di connettersi all'account Azure Cosmos DB e consentono all'account Azure Cosmos DB di considerare attendibile la connessione.The endpoint URL and primary key allow your app to connect to your Azure Cosmos DB account, and the Azure Cosmos DB account to trust the connection. Copiare le chiavi dal portale di Azure e incollarle nel codice.Copy the keys from the Azure portal, and paste them into your code.

    1. Selezionare Chiavi nel menu di spostamento a sinistra dell'account Azure Cosmos DB.In your Azure Cosmos DB account left navigation, select Keys.

      Visualizzare e copiare le chiavi di accesso nel portale di Azure

    2. In Chiavi di lettura/scrittura copiare il valore URI usando il pulsante di copia a destra e incollarlo in <your endpoint URL> in Program.cs.Under Read-write Keys, copy the URI value using the copy button at the right, and paste it into <your endpoint URL> in Program.cs. Ad esempio: For example:

      private const string EndpointUrl = "https://mysqlapicosmosdb.documents.azure.com:443/";

    3. Copiare il valore CHIAVE PRIMARIA e incollarlo in <your primary key> in Program.cs.Copy the PRIMARY KEY value and paste it into <your primary key> in Program.cs. Ad esempio: For example:

      private const string PrimaryKey = "19ZDNJAiYL26tmnRvoez6hmtIfBGwjun50PWRjNYMC2ig8Ob9hYk7Fq1RYSv8FcIYnh1TdBISvCh7s6yyb0000==";

  4. Dopo il metodo Main aggiungere una nuova attività asincrona denominata GetStartedDemo, che crea un'istanza di un nuovo DocumentClient denominato client.After the Main method, add a new asynchronous task called GetStartedDemo, which instantiates a new DocumentClient called client.

       private async Task GetStartedDemo()
       {
         client = new DocumentClient(new Uri(EndpointUrl), PrimaryKey);
       }
    

    Se si sta usando un oggetto proxy per connettersi ad Azure Cosmos DB, usare invece il seguente blocco di codice per creare l'oggetto DocumentClient.If you are using a proxy object to connect to Azure Cosmos DB, you should instead use the following code block to create the DocumentClient object. L'esempio in questo documento non usa un oggetto proxy, per cui è solo un riferimento:The sample in this document doesn't use a proxy object, so the example below is just for your reference:

    HttpClientHandler handler = new HttpClientHandler()
    {
      Proxy = proxyObject
      UseProxy = true,
    };
    
    //Pass handler to the constructor of DocumentClient.
    DocumentClient client = new DocumentClient(new Uri(EndpointUrl), PrimaryKey, handler);
    
    
  5. Aggiungere il codice seguente al metodo Main per eseguire l'attività GetStartedDemo.Add the following code to the Main method to run the GetStartedDemo task. Il metodo Main rileva le eccezioni e le scrive nella console.The Main method catches exceptions and writes them to the console.

       static void Main(string[] args)
       {
         try
         {
            Program p = new Program();
            p.GetStartedDemo().Wait();
         }
         catch (DocumentClientException de)
         {
            Exception baseException = de.GetBaseException();
            Console.WriteLine($"{de.StatusCode} error occurred: {de.Message}, Message: {baseException.Message}");
         }
         catch (Exception e)
         {
            Exception baseException = e.GetBaseException();
            Console.WriteLine($"Error: {e.Message}, Message: {baseException.Message}");
         }
         finally
         {
            Console.WriteLine("End of demo, press any key to exit.");
            Console.ReadKey();
         }
       }
    
  6. Premere F5 per eseguire l'app.Press F5 to run your app.

  7. Quando viene visualizzato il messaggio End of demo, press any key to exit nella finestra della console, significa che la connessione è stata stabilita.When you see the message End of demo, press any key to exit in the console window, it means the connection was successful. Premere un tasto per chiudere la finestra della console.Press any key to close the console window.

La connessione all'account Azure Cosmos DB è stata stabilita correttamente.You've successfully connected to your Azure Cosmos DB account. Ora si useranno alcune risorse di Azure Cosmos DB.Now, work with some Azure Cosmos DB resources.

Creare un databaseCreate a database

Un database Azure Cosmos DB è il contenitore logico per l'archiviazione di documenti JSON partizionato nelle raccolte.An Azure Cosmos DB database is the logical container of JSON document storage partitioned across collections. Per creare un database, usare il metodo CreateDatabaseIfNotExistsAsync della classe DocumentClient.You create a database by using the CreateDatabaseIfNotExistsAsync method of the DocumentClient class.

  1. Prima di aggiungere il codice per la creazione di un database, aggiungere un metodo helper per la scrittura nella console.Before you add the code for creating a database, add a helper method for writing to the console. Copiare e incollare il metodo WriteToConsoleAndPromptToContinue seguente dopo il metodo GetStartedDemo nel codice.Copy and paste the following WriteToConsoleAndPromptToContinue method after the GetStartedDemo method in your code.

    private void WriteToConsoleAndPromptToContinue(string format, params object[] args)
    {
       Console.WriteLine(format, args);
       Console.WriteLine("Press any key to continue...");
       Console.ReadKey();
    }
    
  2. Copiare e incollare la riga seguente nel metodo GetStartedDemo, dopo la riga client = new DocumentClient(new Uri(EndpointUrl), PrimaryKey);.Copy and paste the following line to your GetStartedDemo method, after the client = new DocumentClient(new Uri(EndpointUrl), PrimaryKey); line. Questo codice crea un database denominato FamilyDB.This code creates a database named FamilyDB.

       await client.CreateDatabaseIfNotExistsAsync(new Database { Id = "FamilyDB" });
    
  3. Premere F5 per eseguire l'app.Press F5 to run your app.

La creazione di un database Azure Cosmos DB è stata completata.You've successfully created an Azure Cosmos DB database. Per visualizzare il database nel portale di Azure, selezionare Esplora dati nel riquadro di spostamento a sinistra dell'account Azure Cosmos DB.You can see the database in the Azure portal by selecting Data Explorer in your Azure Cosmos DB account left navigation.

Creare una raccoltaCreate a collection

Una raccolta è un contenitore di documenti JSON e di logica dell'applicazione JavaScript associata.A collection is a container of JSON documents and associated JavaScript application logic. Per creare una raccolta, usare il metodo CreateDocumentCollectionIfNotExistsAsync della classe DocumentClient.You create a collection by using the CreateDocumentCollectionIfNotExistsAsync method of the DocumentClient class.

Importante

CreateDocumentCollectionIfNotExistsAsync crea una nuova raccolta con velocità effettiva riservata, che presenta implicazioni in termini di prezzi.CreateDocumentCollectionIfNotExistsAsync creates a new collection with reserved throughput, which has pricing implications. Per altre informazioni, visitare la pagina relativa ai prezzi.For more details, visit the pricing page.

  1. Copiare e incollare il codice seguente nel metodo GetStartedDemo, dopo la riga await client.CreateDatabaseIfNotExistsAsync(new Database { Id = "FamilyDB" });.Copy and paste the following code to your GetStartedDemo method after the await client.CreateDatabaseIfNotExistsAsync(new Database { Id = "FamilyDB" }); line. Questo codice crea una raccolta di documenti denominata FamilyCollection.This code creates a document collection named FamilyCollection.

       await client.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri("FamilyDB"), new DocumentCollection { Id = "FamilyCollection" });
    
  2. Premere F5 per eseguire l'app.Press F5 to run your app.

La creazione di una raccolta di documenti di Azure Cosmos DB è stata completata.You've successfully created an Azure Cosmos DB document collection. È possibile visualizzare la raccolta sotto il database FamilyDB in Esplora dati nel portale di Azure.You can see the collection under your FamilyDB database in Data Explorer in the Azure portal.

Creare documenti JSONCreate JSON documents

I documenti sono contenuto JSON arbitrario definito dall'utente.Documents are user-defined, arbitrary JSON content. I documenti devono avere una proprietà ID serializzata come id in JSON.Documents must have an ID property serialized as id in JSON. Per creare i documenti, usare il metodo CreateDocumentAsync della classe DocumentClient.You create documents by using the CreateDocumentAsync method of the DocumentClient class.

Suggerimento

Se sono già disponibili dati da archiviare nel database, è possibile usare lo strumento di migrazione dei dati di Azure Cosmos DB per importarli.If you already have data you'd like to store in your database, you can use the Azure Cosmos DB Data Migration tool to import it.

Il codice seguente crea e inserisce i due documenti nella raccolta di database.The following code creates and inserts two documents into your database collection. Prima si creano una classe Family e le sottoclassi Parent, Child, Pet e Address da usare in Family.First, you create a Family class, and Parent, Child, Pet, and Address subclasses to use within Family. Si crea quindi un metodo CreateFamilyDocumentIfNotExists e infine si creano e si inseriscono due documenti.Then, you create a CreateFamilyDocumentIfNotExists method, and then create and insert two documents.

  1. Copiare e incollare le classi Family, Parent, Child, Pet e Address seguenti dopo il metodo WriteToConsoleAndPromptToContinue nel codice.Copy and paste the following Family, Parent, Child, Pet, and Address classes after the WriteToConsoleAndPromptToContinue method in your code.

     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; }
     }
    
  2. Copiare e incollare il metodo CreateFamilyDocumentIfNotExists seguente dopo la classe Address appena aggiunta.Copy and paste the following CreateFamilyDocumentIfNotExists method after the Address class you just added.

     private async Task CreateFamilyDocumentIfNotExists(string databaseName, string collectionName, Family family)
     {
         try
         {
             await client.ReadDocumentAsync(UriFactory.CreateDocumentUri(databaseName, collectionName, family.Id));
             WriteToConsoleAndPromptToContinue($"Found {family.Id}");
         }
         catch (DocumentClientException de)
         {
             if (de.StatusCode == HttpStatusCode.NotFound)
             {
                 await client.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(databaseName, collectionName), family);
                 WriteToConsoleAndPromptToContinue($"Created Family {family.Id}");
             }
             else
             {
                 throw;
             }
         }
     }
    
  3. Copiare e incollare il codice seguente alla fine del metodo GetStartedDemo, dopo la riga await client.CreateDocumentCollectionIfNotExistsAsync.Copy and paste the following code at the end of your GetStartedDemo method, after the await client.CreateDocumentCollectionIfNotExistsAsync line. Questo codice crea e inserisce due documenti, rispettivamente per le famiglie Andersen e Wakefield.This code creates and inserts two documents, one each for the Andersen and Wakefield families.

     Family andersenFamily = new Family
     {
         Id = "AndersenFamily",
         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 = true
     };
    
     await CreateFamilyDocumentIfNotExists("FamilyDB", "FamilyCollection", andersenFamily);
    
     Family wakefieldFamily = new Family
     {
         Id = "WakefieldFamily",
         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 = false
     };
    
     await CreateFamilyDocumentIfNotExists("FamilyDB", "FamilyCollection", wakefieldFamily);
    
  4. Premere F5 per eseguire l'app.Press F5 to run your app.

La creazione di due documenti di Azure Cosmos DB è stata completata.You've successfully created two Azure Cosmos DB documents. È possibile visualizzare i documenti sotto il database FamilyDB e la raccolta FamilyCollection in Esplora dati nel portale di Azure.You can see the documents under your FamilyDB database and FamilyCollection collection in Data Explorer in the Azure portal.

Diagramma che illustra la relazione gerarchica tra l'account, il database online, la raccolta e i documenti

Eseguire query sulle risorse di Azure Cosmos DBQuery Azure Cosmos DB resources

Azure Cosmos DB supporta query complesse sui documenti JSON archiviati nelle raccolte.Azure Cosmos DB supports rich queries against JSON documents stored in collections. L'esempio di codice seguente usa la sintassi SQL di Azure Cosmos DB e LINQ per eseguire una query sui documenti di esempio.The following sample code uses LINQ and Azure Cosmos DB SQL syntax to run a query against the sample documents.

  1. Copiare e incollare il metodo ExecuteSimpleQuery seguente dopo il metodo CreateFamilyDocumentIfNotExists nel codice.Copy and paste the following ExecuteSimpleQuery method after the CreateFamilyDocumentIfNotExists method in your code.

     private void ExecuteSimpleQuery(string databaseName, string collectionName)
     {
         // Set some common query options.
         FeedOptions queryOptions = new FeedOptions { MaxItemCount = -1 };
    
         // Find the Andersen family by its LastName.
         IQueryable<Family> familyQuery = client.CreateDocumentQuery<Family>(
             UriFactory.CreateDocumentCollectionUri(databaseName, collectionName), queryOptions)
             .Where(f => f.LastName == "Andersen");
    
         // Execute the query synchronously. 
         // You could also execute it asynchronously using the IDocumentQuery<T> interface.
         Console.WriteLine("Running LINQ query...");
         foreach (Family family in familyQuery)
         {
             Console.WriteLine($"\tRead {family}");
         }
    
         // Now execute the same query using direct SQL.
         IQueryable<Family> familyQueryInSql = client.CreateDocumentQuery<Family>(
             UriFactory.CreateDocumentCollectionUri(databaseName, collectionName),
             "SELECT * FROM Family WHERE Family.LastName = 'Andersen'",
             queryOptions);
    
         Console.WriteLine("Running direct SQL query...");
         foreach (Family family in familyQueryInSql)
         {
             Console.WriteLine($"\tRead {family}");
         }
    
         Console.WriteLine("Press any key to continue ...");
         Console.ReadKey();
     }
    
  2. Copiare e incollare il codice seguente alla fine del metodo GetStartedDemo, dopo la riga await CreateFamilyDocumentIfNotExists("FamilyDB", "FamilyCollection", wakefieldFamily);.Copy and paste the following code at the end of your GetStartedDemo method, after the await CreateFamilyDocumentIfNotExists("FamilyDB", "FamilyCollection", wakefieldFamily); line.

       ExecuteSimpleQuery("FamilyDB", "FamilyCollection");
    
  3. Premere F5 per eseguire l'app.Press F5 to run your app.

La query precedente restituisce l'elemento completo per la famiglia Andersen.The preceding query returns the complete item for the Andersen family. L'esecuzione di una query in una raccolta di Azure Cosmos DB è stata completata.You've successfully queried against an Azure Cosmos DB collection.

Il diagramma seguente illustra il modo in cui la sintassi di query SQL di Azure Cosmos DB viene chiamata nella raccolta.The following diagram illustrates how the Azure Cosmos DB SQL query syntax calls against the collection. La stessa logica si applica alla query LINQ.The same logic applies to the LINQ query.

Diagramma che illustra l'ambito e il significato della query usata nell'esercitazione su NoSQL per creare un'applicazione console C#

La parola chiave FROM nella query SQL è facoltativa perché le query di Azure Cosmos DB sono già limitate a una singola raccolta.The FROM keyword in the SQL query is optional, because Azure Cosmos DB queries are already scoped to a single collection. È possibile effettuare lo swapping di FROM Families f con FROM root r o qualsiasi altro nome di variabile scelto.You can swap FROM Families f with FROM root r, or any other variable name you choose. Azure Cosmos DB dedurrà che Families, root o il nome della variabile scelto, si riferisce alla raccolta attuale.Azure Cosmos DB will infer that Families, root, or the variable name you choose refers to the current collection.

Aggiornare un documento JSONUpdate a JSON document

L'API SQL di Azure Cosmos DB supporta l'aggiornamento e la sostituzione di documenti JSON.Azure Cosmos DB SQL API supports updating and replacing JSON documents.

  1. Copiare e incollare il metodo ReplaceFamilyDocument seguente dopo il metodo ExecuteSimpleQuery nel codice.Copy and paste the following ReplaceFamilyDocument method after the ExecuteSimpleQuery method in your code.

     private async Task ReplaceFamilyDocument(string databaseName, string collectionName, string familyName, Family updatedFamily)
     {
        await client.ReplaceDocumentAsync(UriFactory.CreateDocumentUri(databaseName, collectionName, familyName), updatedFamily);
        WriteToConsoleAndPromptToContinue($"Replaced Family {familyName}");
     }
    
  2. Copiare e incollare il codice seguente alla fine del metodo GetStartedDemo, dopo la riga ExecuteSimpleQuery("FamilyDB", "FamilyCollection");.Copy and paste the following code at the end of your GetStartedDemo method, after the ExecuteSimpleQuery("FamilyDB", "FamilyCollection"); line. Il codice aggiorna i dati in uno dei documenti e quindi esegue di nuovo la query per visualizzare il documento modificato.The code updates the data in one of the documents, and then runs the query again to show the changed document.

    // Update the Grade of the Andersen Family child
    andersenFamily.Children[0].Grade = 6;
    await ReplaceFamilyDocument("FamilyDB", "FamilyCollection", "AndersenFamily", andersenFamily);
    ExecuteSimpleQuery("FamilyDB", "FamilyCollection");
    
  3. Premere F5 per eseguire l'app.Press F5 to run your app.

L'output della query indica che l'elemento Grade per il figlio della famiglia Andersen è stato aggiornato da 5 a 6.The query output shows that the Grade for the Andersen Family's child updated from 5 to 6. L'aggiornamento e la sostituzione di un documento di Azure Cosmos DB sono stati completati.You've successfully updated and replaced an Azure Cosmos DB document.

Eliminare un documento JSONDelete a JSON document

L'API SQL di Azure Cosmos DB supporta l'eliminazione di documenti JSON.Azure Cosmos DB SQL API supports deleting JSON documents.

  1. Copiare e incollare il metodo DeleteFamilyDocument seguente dopo il metodo ReplaceFamilyDocument.Copy and paste the following DeleteFamilyDocument method after the ReplaceFamilyDocument method.

     private async Task DeleteFamilyDocument(string databaseName, string collectionName, string documentName)
     {
         await client.DeleteDocumentAsync(UriFactory.CreateDocumentUri(databaseName, collectionName, documentName));
         Console.WriteLine($"Deleted Family {documentName}");
     }
    
  2. Copiare e incollare il codice seguente alla fine del metodo GetStartedDemo, dopo la seconda riga ExecuteSimpleQuery("FamilyDB", "FamilyCollection");.Copy and paste the following code at the end of your GetStartedDemo method, after the second ExecuteSimpleQuery("FamilyDB", "FamilyCollection"); line.

    await DeleteFamilyDocument("FamilyDB", "FamilyCollection", "AndersenFamily");
    
  3. Premere F5 per eseguire l'app.Press F5 to run your app.

L'eliminazione di un documento di Azure Cosmos DB è stata completata.You've successfully deleted an Azure Cosmos DB document.

Eliminare il databaseDelete the database

Eliminare il database creato per rimuoverlo con tutte le risorse figlio, inclusi la raccolta e i documenti.Delete the database you created to remove it and all its child resources, including the collection and documents.

  1. Copiare e incollare il codice seguente alla fine del metodo GetStartedDemo, dopo la riga await DeleteFamilyDocument("FamilyDB", "FamilyCollection", "AndersenFamily");.Copy and paste the following code at the end of your GetStartedDemo method, after the await DeleteFamilyDocument("FamilyDB", "FamilyCollection", "AndersenFamily"); line.

    // Clean up - delete the database
    await client.DeleteDatabaseAsync(UriFactory.CreateDatabaseUri("FamilyDB"));
    
  2. Premere F5 per eseguire l'app.Press F5 to run your app.

L'eliminazione del database Azure Cosmos DB è stata completata.You've successfully deleted the Azure Cosmos DB database. In Esplora dati per l'account Azure Cosmos DB è possibile verificare che il database FamilyDB è stato eliminato.You can see in the Data Explorer for your Azure Cosmos DB account that the FamilyDB database is deleted.

Eseguire l'intera app console C#Run the entire C# console app

Premere F5 in Visual Studio per compilare ed eseguire l'app console C# completa in modalità di debug.Press F5 in Visual Studio to build and run the complete C# console app in debug mode. Nella finestra della console verrà visualizzato l'output seguente:You should see the following output in the console window:

Created Family AndersenFamily
Press any key to continue ...
 Created Family WakefieldFamily
Press any key to continue ...
 Running LINQ query...
        Read {"id":"AndersenFamily","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":true}
Running direct SQL query...
        Read {"id":"AndersenFamily","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":true}
Press any key to continue ...
 Replaced Family AndersenFamily
Press any key to continue ...
 Running LINQ query...
        Read {"id":"AndersenFamily","LastName":"Andersen","Parents":[{"FamilyName":null,"FirstName":"Thomas"},{"FamilyName":null,"FirstName":"Mary Kay"}],"Children":[{"FamilyName":null,"FirstName":"Henriette Thaulow","Gender":"female","Grade":6,"Pets":[{"GivenName":"Fluffy"}]}],"Address":{"State":"WA","County":"King","City":"Seattle"},"IsRegistered":true}
Running direct SQL query...
        Read {"id":"AndersenFamily","LastName":"Andersen","Parents":[{"FamilyName":null,"FirstName":"Thomas"},{"FamilyName":null,"FirstName":"Mary Kay"}],"Children":[{"FamilyName":null,"FirstName":"Henriette Thaulow","Gender":"female","Grade":6,"Pets":[{"GivenName":"Fluffy"}]}],"Address":{"State":"WA","County":"King","City":"Seattle"},"IsRegistered":true}
Press any key to continue ...
 Deleted Family AndersenFamily
End of demo, press any key to exit.

Congratulazioni!Congratulations! Ora che l'esercitazione è stata completata, si dispone di un'app console C# funzionante che crea, esegue query, aggiorna ed elimina le risorse di Azure Cosmos DB.You've completed the tutorial, and have a working C# console app that creates, queries, updates, and deletes Azure Cosmos DB resources.

Passaggi successiviNext steps