Oktatóanyag: .NET-konzolalkalmazás létrehozása adatok kezeléséhez az Azure Cosmos DB SQL API-fiókban

Cikk
08/06/2022
19 perc alatt elolvasható

A KÖVETKEZŐKRE VONATKOZIK: SQL API

Üdvözöljük az Azure Cosmos DB SQL API első lépéseket ismertető oktatóanyagában. Az oktatóanyag lépéseinek követésével egy olyan konzolalkalmazást készít, amely Azure Cosmos DB-erőforrásokat hoz létre és kérdez le.

Ez az oktatóanyag az Azure Cosmos DB .NET SDK és a .NET 6 3.0-s vagy újabb verzióját használja.

Ez az oktatóanyag az alábbiakkal foglalkozik:

Azure Cosmos-fiók létrehozása és csatlakoztatása
A projekt konfigurálása a Visual Studióban
Adatbázis és tároló létrehozása
Elemek hozzáadása a tárolóhoz
A tároló lekérdezése
Létrehozási, olvasási, frissítési és törlési (CRUD) műveletek végrehajtása az elemen
Adatbázis törlése

Nincs elég ideje? Ne aggódjon! A teljes megoldás elérhető a GitHubon. Gyors útmutatásért ugorjon a Teljes oktatóanyag megoldásának lekérése szakaszra .

Most pedig lássunk neki!

Előfeltételek

Aktív Azure-fiók. Ha még nincs fiókja, létrehozhat egy ingyenes fiókot.

Az Azure Cosmos DB ingyenesen, Azure-előfizetés nélkül, kötelezettségvállalás nélkül is kipróbálható. Másik lehetőségként létrehozhat egy ingyenes szintű Azure Cosmos DB-fiókot, amely az első 1000 RU/s-t és 25 GB tárterületet ingyenesen tárolja. Az Azure Cosmos DB emulátort a következő URI-val is használhatja https://localhost:8081: . Az emulátorhoz használandó kulcsért tekintse meg a kérések hitelesítésével kapcsolatos témakört.

A legújabb Visual Studio az Azure fejlesztési számítási feladattal. Az ingyenesVisual Studio Community IDE használatbavételéhez. Engedélyezze az Azure-fejlesztési számítási feladatot a Visual Studio beállítása során.

1. lépés: Azure Cosmos DB-fiók létrehozása

Hozzunk létre egy Azure Cosmos DB-fiókot. Ha már van egy használni kívánt fiókja, hagyja ki ezt a szakaszt. Az Azure Cosmos DB Emulator használatához kövesse az Azure Cosmos DB Emulator lépéseit az emulátor beállításához. Ezután ugorjon a 2. lépésre: A Visual Studio-projekt beállítása.

A Azure Portal menüben vagy a kezdőlapon válassza az Erőforrás létrehozása lehetőséget.
Az Új lapon keresse meg és válassza ki az Azure Cosmos DB-t.
Az API kiválasztása lapon válassza a Létrehozás lehetőséget a Core (SQL) – Javaslat szakaszban. Az Azure Cosmos DB öt API-t biztosít: Core (SQL) és MongoDB dokumentumadatokhoz, Gremlin gráfadatokhoz, Azure Table és Cassandra. Jelenleg minden API-hoz külön fiókot kell létrehoznia. További információ az SQL API-ról.

Az Azure Cosmos DB-fiók létrehozása lapon adja meg az új Azure Cosmos-fiók alapvető beállításait.

Beállítás	Érték	Leírás
Előfizetés	Előfizetés neve	Válassza ki az Azure Cosmos-fiókhoz használni kívánt Azure-előfizetést.
Erőforráscsoport	Erőforráscsoport neve	Jelöljön ki egy erőforráscsoportot, vagy válassza az Új létrehozása lehetőséget, majd adjon meg egy egyedi nevet az új erőforráscsoportnak.
Fiók neve	Egyedi név	Adjon meg egy nevet az Azure Cosmos-fiók azonosításához. Mivel a documents.azure.com hozzá lesz fűzve az URI létrehozásához megadott névhez, használjon egyedi nevet. A név csak kisbetűket, számokat és kötőjelet (-) tartalmazhat. 3–44 karakter hosszúságúnak kell lennie.
Hely	A felhasználókhoz legközelebb eső régió	Válassza ki az Azure Cosmos DB-fiókot üzemeltetéséhez használni kívánt földrajzi helyet. Használja a felhasználókhoz legközelebbi helyet, hogy a lehető leggyorsabb hozzáférést biztosítsa számukra az adatokhoz.
Kapacitásmód	Kiosztott átviteli sebesség vagy kiszolgáló nélküli	A kiosztott átviteli sebesség kiválasztásával hozzon létre egy fiókot kiosztott átviteli módban. Kiszolgáló nélküli módban a kiszolgáló nélküli fiók létrehozásához válassza a Kiszolgáló nélküli lehetőséget.
Az Azure Cosmos DB ingyenes szintű kedvezményének alkalmazása	Alkalmaz vagy Nincs alkalmazva	Az Azure Cosmos DB ingyenes szintjével az első 1000 RU/s és 25 GB tárterület ingyenesen érhető el egy fiókban. További információ az ingyenes szintről.

Megjegyzés

Azure-előfizetésenként legfeljebb egy ingyenes szintű Azure Cosmos DB-fiókkal rendelkezhet, és a fiók létrehozásakor be kell azt állítania. Ha nem látja az ingyenes szintű kedvezmény alkalmazásának lehetőségét, az azt jelenti, hogy az előfizetés egy másik fiókja már engedélyezve van az ingyenes szinttel.

Az Azure Cosmos DB új fiók lapja

A Globális terjesztés lapon konfigurálja az alábbi adatokat. Ebben a rövid útmutatóban meghagyhatja az alapértelmezett értékeket:

Beállítás	Érték	Leírás
Georedundancia	Letiltás	A globális terjesztés engedélyezéséhez vagy letiltásához párosítsa a régiót egy párrégióval. Később további régiókat is hozzáadhat a fiókjához.
Többrégiós írók	Letiltás	A többrégiós írási képesség lehetővé teszi, hogy kihasználja a kiosztott átviteli sebességet az adatbázisok és tárolók számára világszerte.

Megjegyzés

A következő beállítások nem érhetők el, ha a Kiszolgáló nélkülikapacitás módot választja:

Az ingyenes szint árengedményének alkalmazása
Georedundancia
Többrégiós írók

Igény szerint további részleteket is konfigurálhat az alábbi lapokon:
- Hálózatkezelés – Virtuális hálózatról való hozzáférés konfigurálása.
- Biztonsági mentési szabályzat – Rendszeres vagy folyamatos biztonsági mentési szabályzat konfigurálása.
- Titkosítás – Szolgáltatás által felügyelt vagy ügyfél által felügyelt kulcs használata.
- Címkék – A címkék név-érték párok, amelyek lehetővé teszik az erőforrások kategorizálását és az összevont számlázás megtekintését azáltal, hogy ugyanazt a címkét több erőforrásra és erőforráscsoportra alkalmazza.
Válassza az Áttekintés + létrehozás lehetőséget.
Tekintse át a fiókbeállításokat, majd válassza a Létrehozás lehetőséget. A fiók létrehozása néhány percet vesz igénybe. Várja meg, amíg a portállapon megjelenik az üzembe helyezés befejeződött.
Válassza az Erőforrás megnyitása lehetőséget az Azure Cosmos DB-fiók oldalának megtekintéséhez.

2. lépés: A Visual Studio-projekt beállítása

Nyissa meg a Visual Studiót, és válassza az Új projekt létrehozása lehetőséget.
Az Új projekt létrehozása területen válassza a C#-hoz készült Konzolalkalmazás lehetőséget, majd válassza a Tovább gombot.
Nevezze el a projektet CosmosGettingStartedTutorial néven, majd válassza a Létrehozás lehetőséget.
A Megoldáskezelő kattintson a jobb gombbal az új konzolalkalmazásra, amely a Visual Studio-megoldás alatt található, és válassza a NuGet-csomagok kezelése lehetőséget.
A NuGet-csomagkezelőben válassza a Tallózás lehetőséget , és keressen rá a Microsoft.Azure.Cosmos kifejezésre. Válassza a Microsoft.Azure.Cosmos lehetőséget , majd a Telepítés lehetőséget.

Az Azure Cosmos DB SQL API ügyfélkódtárának csomagazonosítója a következő: Microsoft Azure Cosmos DB Client Library.

Nagyszerű! Most, hogy befejeztük a beállítást, lássunk neki a kód megírásának! Az oktatóanyag befejezett projektje: .NET-konzolalkalmazás fejlesztése az Azure Cosmos DB használatával.

3. lépés: Csatlakozás egy Azure Cosmos DB-fiókhoz

Cserélje le a C#-alkalmazás elején található hivatkozásokat a Program.cs fájlban az alábbi hivatkozásokkal:

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

Adja hozzá ezeket az állandókat és változókat az Program osztályhoz.

public class Program
{
    // ADD THIS PART TO YOUR CODE

    // The Azure Cosmos DB endpoint for running this sample.
    private static readonly string EndpointUri = "<your endpoint here>";
    // The primary key for the Azure Cosmos account.
    private static readonly string PrimaryKey = "<your primary key>";

    // The Cosmos client instance
    private CosmosClient cosmosClient;

    // The database we will create
    private Database database;

    // The container we will create.
    private Container container;

    // The name of the database and container we will create
    private string databaseId = "FamilyDatabase";
    private string containerId = "FamilyContainer";
}

Megjegyzés

Ha ismeri a .NET SDK előző verzióját, akkor lehet, hogy ismeri a kifejezésgyűjteményt és a dokumentumot. Mivel az Azure Cosmos DB több API-modellt is támogat, a .NET SDK 3.0-s verziója a tároló és az elem általános kifejezéseit használja. A tárolók lehetnek gyűjtemények, grafikonok vagy táblák. Egy elem lehet dokumentum, él/csúcspont vagy sor, és a tároló tartalma. További információ: Adatbázisok, tárolók és elemek használata az Azure Cosmos DB-ben.

Nyissa meg az Azure Portalt. Keresse meg az Azure Cosmos DB-fiókját, majd válassza a Kulcsok lehetőséget.
A Programban.cs cserélje le <your endpoint URL> az URI értékét. Cserélje le <your primary key> az ELSŐDLEGES KULCS értékére.

A Main metódus alatt adjon hozzá egy GetStartedDemoAsync nevű új aszinkron feladatot, amely példányosítja az újat CosmosClient.

public static async Task Main(string[] args)
{
}

// ADD THIS PART TO YOUR CODE
/*
    Entry point to call methods that operate on Azure Cosmos DB resources in this sample
*/
public async Task GetStartedDemoAsync()
{
    // Create a new instance of the Cosmos Client
    this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
}

A GetStartedDemoAsync-t használjuk belépési pontként, amely meghívja az Azure Cosmos DB-erőforrásokon működő metódusokat.

Adja hozzá a következő kódot a GetStartedDemoAsync aszinkron feladat main metódusból való futtatásához. A Main metódus észleli a kivételeket, és a konzolba írja azokat.

public static async Task Main(string[] args)
{
    try
    {
        Console.WriteLine("Beginning operations...\n");
        Program p = new Program();
        await p.GetStartedDemoAsync();

    }
    catch (CosmosException cosmosException)
    {
        Console.WriteLine("Cosmos Exception with Status {0} : {1}\n", cosmosException.StatusCode, cosmosException);
    }
    catch (Exception e)
    {
        Console.WriteLine("Error: {0}", e);
    }
    finally
    {
        Console.WriteLine("End of demo, press any key to exit.");
        Console.ReadKey();
    }
}

Az alkalmazás futtatásához válassza az F5 lehetőséget.

A konzol megjeleníti a következő üzenetet: A bemutató vége, a kilépéshez nyomja le bármelyik billentyűt. Ez az üzenet megerősíti, hogy az alkalmazás kapcsolatot létesített az Azure Cosmos DB-hez. Ezután bezárhatja a konzolablakot.

Gratulálunk! Sikeresen csatlakozott egy Azure Cosmos DB-fiókhoz.

4. lépés: Adatbázis létrehozása

Az adatbázis a tárolók között particionált elemek logikai tárolója. CreateDatabaseIfNotExistsAsync A CosmosClient osztály vagy CreateDatabaseAsync metódusa létrehozhat egy adatbázist.

Másolja és illessze be a CreateDatabaseAsync metódust a GetStartedDemoAsync metódus alá.
```
/// <summary>
/// Create the database if it does not exist
/// </summary>
private async Task CreateDatabaseAsync()
{
    // Create a new database
    this.database = await this.cosmosClient.CreateDatabaseIfNotExistsAsync(databaseId);
    Console.WriteLine("Created Database: {0}\n", this.database.Id);
}
```
CreateDatabaseAsync létrehoz egy új, azonosítóval FamilyDatabase rendelkező adatbázist, ha még nem létezik, és a mezőből van megadva az databaseId azonosító. Ebben a bemutatóban a gyakorlat részeként hozjuk létre az adatbázist, éles alkalmazások esetében azonban nem ajánlott azt a normál folyamat részeként elvégezni.

Másolja és illessze be az alábbi kódot, ahol példányosítani szeretné a CosmosClientet az imént hozzáadott CreateDatabaseAsync metódus meghívásához.

public async Task GetStartedDemoAsync()
{
    // Create a new instance of the Cosmos Client
    this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);

    //ADD THIS PART TO YOUR CODE
    await this.CreateDatabaseAsync();
}

A programnak.cs most így kell kinéznie, a végpont és az elsődleges kulcs ki van töltve.

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

namespace CosmosGettingStartedTutorial
{
    class Program
    {
        // The Azure Cosmos DB endpoint for running this sample.
        private static readonly string EndpointUri = "<your endpoint here>";
        // The primary key for the Azure Cosmos account.
        private static readonly string PrimaryKey = "<your primary key>";

        // The Cosmos client instance
        private CosmosClient cosmosClient;

        // The database we will create
        private Database database;

        // The container we will create.
        private Container container;

        // The name of the database and container we will create
        private string databaseId = "FamilyDatabase";
        private string containerId = "FamilyContainer";

        public static async Task Main(string[] args)
        {
            try
            {
                Console.WriteLine("Beginning operations...");
                Program p = new Program();
                await p.GetStartedDemoAsync();
            }
            catch (CosmosException cosmosException)
            {
                Console.WriteLine("Cosmos Exception with Status {0} : {1}\n", cosmosException.StatusCode, cosmosException);
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: {0}\n", e);
            }
            finally
            {
                Console.WriteLine("End of demo, press any key to exit.");
                Console.ReadKey();
            }
        }

        /// <summary>
        /// Entry point to call methods that operate on Azure Cosmos DB resources in this sample
        /// </summary>
        public async Task GetStartedDemoAsync()
        {
            // Create a new instance of the Cosmos Client
            this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
            await this.CreateDatabaseAsync();
        }

        /// <summary>
        /// Create the database if it does not exist
        /// </summary>
        private async Task CreateDatabaseAsync()
        {
            // Create a new database
            this.database = await this.cosmosClient.CreateDatabaseIfNotExistsAsync(databaseId);
            Console.WriteLine("Created Database: {0}\n", this.database.Id);
        }
    }
}

Az alkalmazás futtatásához válassza az F5 lehetőséget.

Megjegyzés

Ha "503 szolgáltatás nem érhető el kivétel" hibaüzenet jelenik meg, lehetséges, hogy a közvetlen kapcsolati módhoz szükséges portokat egy tűzfal blokkolja. A probléma megoldásához nyissa meg a szükséges portokat, vagy használja az átjáró módú kapcsolatot az alábbi kódban látható módon:
```
  // Create a new instance of the Cosmos Client in Gateway mode
  this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey, new CosmosClientOptions()
         {
             ConnectionMode = ConnectionMode.Gateway
         });
```

Gratulálunk! Sikeresen létrehozott egy Azure Cosmos-adatbázist.

5. lépés: Tároló létrehozása

Figyelmeztetés

A metódus CreateContainerIfNotExistsAsync létrehoz egy új tárolót, amely díjszabási következményekkel jár. További részletekért látogasson el az árképzést ismertető oldalra.

A tárolók a CreateContainerIfNotExistsAsync vagy a CreateContainerAsync metódussal hozhatók létre az CosmosDatabase osztályban. A tárolók elemekből (JSON-dokumentumok, ha SQL API esetén) és a JavaScripthez társított kiszolgálóoldali alkalmazáslogikából( például tárolt eljárásokból, felhasználó által definiált függvényekből és eseményindítókból) áll.

Másolja és illessze be a CreateContainerAsync metódust a CreateDatabaseAsync metódus alá. CreateContainerAsync létrehoz egy új tárolót az azonosítóval FamilyContainer , ha még nem létezik, a containerId tulajdonság által LastName particionált mezőből megadott azonosítóval. Ennek a bemutatónak a célja a tároló létrehozása a gyakorlat részeként, de éles alkalmazások esetében nem ajánlott a normál folyamat részeként elvégezni.

/// <summary>
/// Create the container if it does not exist. 
/// Specifiy "/LastName" as the partition key since we're storing family information, to ensure good distribution of requests and storage.
/// </summary>
/// <returns></returns>
private async Task CreateContainerAsync()
{
    // Create a new container
    this.container = await this.database.CreateContainerIfNotExistsAsync(containerId, "/LastName");
    Console.WriteLine("Created Container: {0}\n", this.container.Id);
}

Másolja és illessze be az alábbi kódot, ahol példányosította a CosmosClientet az imént hozzáadott CreateContainer metódus meghívásához.

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

    //ADD THIS PART TO YOUR CODE
    await this.CreateContainerAsync();
}

Az alkalmazás futtatásához válassza az F5 lehetőséget.

Gratulálunk! Sikeresen létrehozott egy Azure Cosmos-tárolót.

6. lépés: Elemek hozzáadása a tárolóhoz

Az osztály CreateItemAsync metódusa CosmosContainer létrehozhat egy elemet. Az SQL API használatakor az elemek dokumentumokként lesznek kivetítve, amelyek felhasználó által meghatározott tetszőleges JSON-tartalmak. Most már beszúrhat egy elemet az Azure Cosmos-tárolóba.

Először hozzunk létre egy Family osztályt, amely az Azure Cosmos DB-ben tárolt objektumokat jelöli ebben a mintában. Emellett létrehozunk Parent, Child, Pet, alosztályokat is, Address amelyek a következőkben vannak használatban Family: . Az elemnek a Id JSON-ban megadott id módon szerializált tulajdonságot kell tartalmaznia.

Válassza a Ctrl+Shift+A billentyűkombinációt az Új elem hozzáadása parancs megnyitásához. Adjon hozzá egy új osztályt Family.cs a projekthez.

Másolja és illessze be a Family, Parent, Child, Petés Address osztályt.Family.cs

using Newtonsoft.Json;

namespace CosmosGettingStartedTutorial
{
    public class Family
    {
        [JsonProperty(PropertyName = "id")]
        public string Id { get; set; }
        public string LastName { get; set; }
        public Parent[] Parents { get; set; }
        public Child[] Children { get; set; }
        public Address Address { get; set; }
        public bool IsRegistered { get; set; }
        public override string ToString()
        {
            return JsonConvert.SerializeObject(this);
        }
    }

    public class Parent
    {
        public string FamilyName { get; set; }
        public string FirstName { get; set; }
    }

    public class Child
    {
        public string FamilyName { get; set; }
        public string FirstName { get; set; }
        public string Gender { get; set; }
        public int Grade { get; set; }
        public Pet[] Pets { get; set; }
    }

    public class Pet
    {
        public string GivenName { get; set; }
    }

    public class Address
    {
        public string State { get; set; }
        public string County { get; set; }
        public string City { get; set; }
    }
}

A Programba vissza.cs adja hozzá a AddItemsToContainerAsync metódust a CreateContainerAsync metódus után.

/// <summary>
/// Add Family items to the container
/// </summary>
private async Task AddItemsToContainerAsync()
{
    // Create a family object for the Andersen family
    Family andersenFamily = new Family
    {
        Id = "Andersen.1",
        LastName = "Andersen",
        Parents = new Parent[]
        {
            new Parent { FirstName = "Thomas" },
            new Parent { FirstName = "Mary Kay" }
        },
        Children = new Child[]
        {
            new Child
            {
                FirstName = "Henriette Thaulow",
                Gender = "female",
                Grade = 5,
                Pets = new Pet[]
                {
                    new Pet { GivenName = "Fluffy" }
                }
            }
        },
        Address = new Address { State = "WA", County = "King", City = "Seattle" },
        IsRegistered = false
    };

    try
    {
        // Read the item to see if it exists.  
        ItemResponse<Family> andersenFamilyResponse = await this.container.ReadItemAsync<Family>(andersenFamily.Id, new PartitionKey(andersenFamily.LastName));
        Console.WriteLine("Item in database with id: {0} already exists\n", andersenFamilyResponse.Resource.Id);
    }
    catch(CosmosException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
    {
        // Create an item in the container representing the Andersen family. Note we provide the value of the partition key for this item, which is "Andersen"
        ItemResponse<Family> andersenFamilyResponse = await this.container.CreateItemAsync<Family>(andersenFamily, new PartitionKey(andersenFamily.LastName));

        // Note that after creating the item, we can access the body of the item with the Resource property off the ItemResponse. We can also access the RequestCharge property to see the amount of RUs consumed on this request.
        Console.WriteLine("Created item in database with id: {0} Operation consumed {1} RUs.\n", andersenFamilyResponse.Resource.Id, andersenFamilyResponse.RequestCharge);
    }

    // Create a family object for the Wakefield family
    Family wakefieldFamily = new Family
    {
        Id = "Wakefield.7",
        LastName = "Wakefield",
        Parents = new Parent[]
        {
            new Parent { FamilyName = "Wakefield", FirstName = "Robin" },
            new Parent { FamilyName = "Miller", FirstName = "Ben" }
        },
        Children = new Child[]
        {
            new Child
            {
                FamilyName = "Merriam",
                FirstName = "Jesse",
                Gender = "female",
                Grade = 8,
                Pets = new Pet[]
                {
                    new Pet { GivenName = "Goofy" },
                    new Pet { GivenName = "Shadow" }
                }
            },
            new Child
            {
                FamilyName = "Miller",
                FirstName = "Lisa",
                Gender = "female",
                Grade = 1
            }
        },
        Address = new Address { State = "NY", County = "Manhattan", City = "NY" },
        IsRegistered = true
    };

    try
    {
        // Read the item to see if it exists
        ItemResponse<Family> wakefieldFamilyResponse = await this.container.ReadItemAsync<Family>(wakefieldFamily.Id, new PartitionKey(wakefieldFamily.LastName));
        Console.WriteLine("Item in database with id: {0} already exists\n", wakefieldFamilyResponse.Resource.Id);
    }
    catch(CosmosException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
    {
        // Create an item in the container representing the Wakefield family. Note we provide the value of the partition key for this item, which is "Wakefield"
        ItemResponse<Family> wakefieldFamilyResponse = await this.container.CreateItemAsync<Family>(wakefieldFamily, new PartitionKey(wakefieldFamily.LastName));

        // Note that after creating the item, we can access the body of the item with the Resource property off the ItemResponse. We can also access the RequestCharge property to see the amount of RUs consumed on this request.
        Console.WriteLine("Created item in database with id: {0} Operation consumed {1} RUs.\n", wakefieldFamilyResponse.Resource.Id, wakefieldFamilyResponse.RequestCharge);
    }
}

A kód ellenőrzi, hogy egy azonos azonosítójú elem még nem létezik-e. Két elemet szúrunk be, egyet az Andersen családhoz és a Wakefield családhoz.

Adjon hozzá egy hívást AddItemsToContainerAsync a GetStartedDemoAsync metódushoz.

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

    //ADD THIS PART TO YOUR CODE
    await this.AddItemsToContainerAsync();
}

Az alkalmazás futtatásához válassza az F5 lehetőséget.

Gratulálunk! Sikeresen létrehozott két Azure Cosmos-elemet.

7. lépés: Az Azure Cosmos DB-erőforrások lekérdezése

Az Azure Cosmos DB támogatja az egyes tárolókban tárolt JSON-dokumentumokon végzett részletes lekérdezéseket. További információt az SQL-lekérdezések használatának első lépései című témakörben talál. Az alábbi mintakód bemutatja, hogyan futtathat lekérdezést az előző lépésben beszúrt elemeken.

Másolja és illessze be a metódust a QueryItemsAsyncAddItemsToContainerAsync metódus után.

/// <summary>
/// Run a query (using Azure Cosmos DB SQL syntax) against the container
/// </summary>
private async Task QueryItemsAsync()
{
    var sqlQueryText = "SELECT * FROM c WHERE c.LastName = 'Andersen'";

    Console.WriteLine("Running query: {0}\n", sqlQueryText);

    QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText);
    using 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);
        }
    }
}

Adjon hozzá egy hívást QueryItemsAsync a GetStartedDemoAsync metódushoz.

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

    //ADD THIS PART TO YOUR CODE
    await this.QueryItemsAsync();
}

Az alkalmazás futtatásához válassza az F5 lehetőséget.

Gratulálunk! Sikeresen lekérdezett egy Azure Cosmos-tárolót.

8. lépés: JSON-elem cseréje

Most frissítünk egy elemet az Azure Cosmos DB-ben. Megváltoztatjuk az IsRegistered egyik gyerek tulajdonát FamilyGrade .

Másolja és illessze be a metódust a ReplaceFamilyItemAsyncQueryItemsAsync metódus után.

/// <summary>
/// Replace an item in the container
/// </summary>
private async Task ReplaceFamilyItemAsync()
{
    ItemResponse<Family> wakefieldFamilyResponse = await this.container.ReadItemAsync<Family>("Wakefield.7", new PartitionKey("Wakefield"));
    var itemBody = wakefieldFamilyResponse.Resource;
    
    // update registration status from false to true
    itemBody.IsRegistered = true;
    // update grade of child
    itemBody.Children[0].Grade = 6;

    // replace the item with the updated content
    wakefieldFamilyResponse = await this.container.ReplaceItemAsync<Family>(itemBody, itemBody.Id, new PartitionKey(itemBody.LastName));
    Console.WriteLine("Updated Family [{0},{1}].\n \tBody is now: {2}\n", itemBody.LastName, itemBody.Id, wakefieldFamilyResponse.Resource);
}

Adjon hozzá egy hívást ReplaceFamilyItemAsync a GetStartedDemoAsync metódushoz.

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

    //ADD THIS PART TO YOUR CODE
    await this.ReplaceFamilyItemAsync();
}

Az alkalmazás futtatásához válassza az F5 lehetőséget.

Gratulálunk! Sikeresen lecserélt egy Azure Cosmos-elemet.

9. lépés: Elem törlése

Most törölünk egy elemet az Azure Cosmos DB-ben.

Másolja és illessze be a metódust DeleteFamilyItemAsync a ReplaceFamilyItemAsync metódus után.

/// <summary>
/// Delete an item in the container
/// </summary>
private async Task DeleteFamilyItemAsync()
{
    var partitionKeyValue = "Wakefield";
    var familyId = "Wakefield.7";

    // Delete an item. Note we must provide the partition key value and id of the item to delete
    ItemResponse<Family> wakefieldFamilyResponse = await this.container.DeleteItemAsync<Family>(familyId,new PartitionKey(partitionKeyValue));
    Console.WriteLine("Deleted Family [{0},{1}]\n", partitionKeyValue, familyId);
}

Adjon hozzá egy hívást DeleteFamilyItemAsync a GetStartedDemoAsync metódushoz.

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

    //ADD THIS PART TO YOUR CODE
    await this.DeleteFamilyItemAsync();
}

Az alkalmazás futtatásához válassza az F5 lehetőséget.

Gratulálunk! Sikeresen törölt egy Azure Cosmos-elemet.

10. lépés: Az adatbázis törlése

Most töröljük az adatbázist. A létrehozott adatbázis törlése eltávolítja az adatbázist és az összes gyermekerőforrást. Az erőforrások közé tartoznak a tárolók, az elemek és a tárolt eljárások, a felhasználó által definiált függvények és eseményindítók. A példányt CosmosClient is megsemmisítjük.

Másolja és illessze be a metódust DeleteDatabaseAndCleanupAsync a DeleteFamilyItemAsync metódus után.

/// <summary>
/// Delete the database and dispose of the Cosmos Client instance
/// </summary>
private async Task DeleteDatabaseAndCleanupAsync()
{
    DatabaseResponse databaseResourceResponse = await this.database.DeleteAsync();
    // Also valid: await this.cosmosClient.Databases["FamilyDatabase"].DeleteAsync();

    Console.WriteLine("Deleted Database: {0}\n", this.databaseId);

    //Dispose of CosmosClient
    this.cosmosClient.Dispose();
}

Adjon hozzá egy hívást DeleteDatabaseAndCleanupAsync a GetStartedDemoAsync metódushoz.

/// <summary>
/// Entry point to call methods that operate on Azure Cosmos DB resources in this sample
/// </summary>
public async Task GetStartedDemoAsync()
{
    // Create a new instance of the Cosmos Client
    this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);
    await this.CreateDatabaseAsync();
    await this.CreateContainerAsync();
    await this.AddItemsToContainerAsync();
    await this.QueryItemsAsync();
    await this.ReplaceFamilyItemAsync();
    await this.DeleteFamilyItemAsync();
    await this.DeleteDatabaseAndCleanupAsync();
}

Az alkalmazás futtatásához válassza az F5 lehetőséget.

Gratulálunk! Sikeresen törölt egy Azure Cosmos-adatbázist.

11. lépés: Futtassa a teljes C# konzolalkalmazást!

Válassza az F5 lehetőséget a Visual Studióban az alkalmazás hibakeresési módban való létrehozásához és futtatásához.

A teljes alkalmazás kimenetének egy konzolablakban kell megjelennie. A kimenet a hozzáadott lekérdezések eredményeit jeleníti meg. Ennek egyeznie kell az alábbi példaszövegel.

Beginning operations...

Created Database: FamilyDatabase

Created Container: FamilyContainer

Created item in database with id: Andersen.1 Operation consumed 11.43 RUs.

Created item in database with id: Wakefield.7 Operation consumed 14.29 RUs.

Running query: SELECT * FROM c WHERE c.LastName = 'Andersen'

        Read {"id":"Andersen.1","LastName":"Andersen","Parents":[{"FamilyName":null,"FirstName":"Thomas"},{"FamilyName":null,"FirstName":"Mary Kay"}],"Children":[{"FamilyName":null,"FirstName":"Henriette Thaulow","Gender":"female","Grade":5,"Pets":[{"GivenName":"Fluffy"}]}],"Address":{"State":"WA","County":"King","City":"Seattle"},"IsRegistered":false}

Updated Family [Wakefield,Wakefield.7].
        Body is now: {"id":"Wakefield.7","LastName":"Wakefield","Parents":[{"FamilyName":"Wakefield","FirstName":"Robin"},{"FamilyName":"Miller","FirstName":"Ben"}],"Children":[{"FamilyName":"Merriam","FirstName":"Jesse","Gender":"female","Grade":6,"Pets":[{"GivenName":"Goofy"},{"GivenName":"Shadow"}]},{"FamilyName":"Miller","FirstName":"Lisa","Gender":"female","Grade":1,"Pets":null}],"Address":{"State":"NY","County":"Manhattan","City":"NY"},"IsRegistered":true}

Deleted Family [Wakefield,Wakefield.7]

Deleted Database: FamilyDatabase

End of demo, press any key to exit.

Gratulálunk! Elvégezte az oktatóanyagot, és egy működőképes C# konzolalkalmazással rendelkezik!

Az oktatóanyagban szereplő teljes megoldás beszerzése

Ha nem volt ideje elvégezni az oktatóanyag lépéseit, vagy csak le szeretné tölteni a kódmintákat, letöltheti.

A GetStarted megoldás létrehozásához a következő előfeltételekre van szükség:

Aktív Azure-fiók. Ha még nincs fiókja, létrehozhat egy ingyenes fiókot.
Egy Azure Cosmos DB-fiók.
A GitHubon elérhető GetStarted megoldás.

Ha vissza szeretné állítani az Azure Cosmos DB .NET SDK-ra mutató hivatkozásokat a Visual Studióban, kattintson a jobb gombbal a megoldásra Megoldáskezelő, majd válassza a NuGet-csomagok visszaállítása lehetőséget. Ezután a App.config fájlban frissítse az értékeket a EndPointUriPrimaryKey3. lépésben leírt módon: Csatlakozás Azure Cosmos DB-fiókhoz.

Ennyi, építsd fel, és már úton vagy!

Következő lépések

Összetettebb ASP.NET MVC-oktatóanyagot szeretne? Lásd az oktatóanyagot: ASP.NET Core MVC-webalkalmazás fejlesztése az Azure Cosmos DB-vel a .NET SDK használatával.
Skálázási és teljesítménytesztelést szeretne végezni az Azure Cosmos DB-vel? Tekintse meg a teljesítmény- és méretezési tesztelést az Azure Cosmos DB-vel.
Az Azure Cosmos DB-kérések, -használat és -tárolás monitorozásának megismeréséhez tekintse meg a teljesítmény- és tárolási metrikák Monitorozása az Azure Cosmos DB-ben című témakört.
További információ az Azure Cosmos DB-ről: Üdvözli az Azure Cosmos DB.
Kapacitástervezést szeretne végezni az Azure Cosmos DB-be történő migráláshoz? A kapacitástervezéshez használhatja a meglévő adatbázisfürt adatait.
- Ha csak a meglévő adatbázisfürt virtuális magjainak és kiszolgálóinak számát ismeri, olvassa el a kérelemegységek virtuális magok vagy vCPU-k használatával történő becslését
- Ha ismeri az aktuális adatbázis számítási feladatának tipikus kérési arányait, olvassa el a kérelemegységek becslését az Azure Cosmos DB Capacity Planner használatával