Snabbstart: Använda Azure DocumentDB med MongoDB-drivrutin för C#

• TypeScript
• JavaScript
• Python
• C#
• Java
• Gå!

I den här snabbstarten skapar du ett grundläggande Azure DocumentDB-program med C#. Azure DocumentDB är ett NoSQL-datalager som gör att program kan lagra dokument i molnet och komma åt dem med hjälp av officiella MongoDB-drivrutiner. Den här guiden visar hur du skapar dokument och utför grundläggande uppgifter i ditt Azure DocumentDB-kluster med hjälp av C#.

API-referens | Källkod | Paket (NuGet)

Förutsättningar

• En prenumeration på Azure

  • Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto

• .NET 10.0 eller senare

Skapa ett Azure DocumentDB-kluster

För att komma igång måste du först skapa ett Azure DocumentDB-kluster som fungerar som grund för att lagra och hantera dina NoSQL-data.

1. Logga in på Azure-portalen (https://portal.azure.com).

2. I menyn i Azure-portalen eller på sidan Start väljer du Skapa en resurs.

3. På sidan Ny söker du efter och väljer Azure DocumentDB.

   

4. På sidan Skapa Azure DocumentDB-kluster och i avsnittet Grundläggande väljer du alternativet Konfigurera i avsnittet Klusternivå .

   

5. På sidan Skala konfigurerar du de här alternativen och väljer sedan Spara för att spara ändringarna på klusternivån.

   	Värde
   Klusternivå	M30 tier, 2 vCore, 8-GiB RAM
   Lagring per shard	128 GiB

   

6. I avsnittet Grundläggande konfigurerar du följande alternativ:

   	Värde
   Subscription	Välj din Azure-prenumeration
   resursgrupp	Skapa en ny resursgrupp eller välj en befintlig resursgrupp
   Klusternamn	Ange ett globalt unikt namn
   Läge	Välj en Azure-region som stöds för din prenumeration
   MongoDB-version	Välj 8.0
   Användarnamn för administratör	Skapa ett användarnamn för att komma åt klustret som användaradministratör
   Lösenord	Använda ett unikt lösenord som är associerat med användarnamnet

   

   Tips/Råd

   Registrera de värden som du använder för användarnamn och lösenord. Dessa värden används senare i den här guiden. Mer information om giltiga värden finns i klusterbegränsningar.

7. Välj Nästa: Nätverk.

8. I avsnittet Brandväggsregler på fliken Nätverk konfigurerar du följande alternativ:

   	Värde
   Anslutningsmetod	Public access
   Tillåt offentlig åtkomst från Azure-tjänster och resurser i Azure till det här klustret	Aktiverad

9. Lägg till en brandväggsregel för den aktuella klientenheten för att bevilja åtkomst till klustret genom att välja + Lägg till aktuell klient-IP-adress.

   

   Tips/Råd

   I många företagsmiljöer är IP-adresser för utvecklardatorer dolda på grund av ett VPN eller andra företagsnätverksinställningar. I dessa fall kan du tillfälligt tillåta åtkomst till alla IP-adresser genom att lägga till IP-adressintervallet 0.0.0.0 - 255.255.255.255 som en brandväggsregel. Använd endast den här brandväggsregeln tillfälligt som en del av anslutningstestning och utveckling.

10. Välj Förhandsgranska + skapa.

11. Granska de inställningar du anger och välj sedan Skapa. Det tar några minuter att skapa klustret. Vänta tills resursdistributionen är klar.

12. Välj slutligen Gå till resurs för att navigera till Azure DocumentDB-klustret i portalen.

Hämta klusterautentiseringsuppgifter

Hämta de autentiseringsuppgifter som du använder för att ansluta till klustret.

1. På klustersidan väljer du alternativet Anslutningssträngar på resursmenyn.

2. I avsnittet Anslutningssträngar kopierar eller registrerar du värdet från fältet Anslutningssträng .

Viktigt!

Anslutningssträngen i portalen innehåller inte lösenordsvärdet. Du måste ersätta <password> platshållaren med de autentiseringsuppgifter som du angav när du skapade klustret eller ange lösenordet interaktivt.

Initiera projektet

Skapa ett nytt .NET-konsolprogramprojekt i den aktuella katalogen.

1. Börja i en tom katalog.

2. Öppna en terminal i den aktuella katalogen.

3. Skapa ett nytt .NET-konsolprogram.

   dotnet new console
   

4. Bygg projektet för att säkerställa att det har byggts framgångsrikt.

   dotnet build
   

Installera klientbiblioteket

Klientbiblioteket är tillgängligt via NuGet som MongoDB.Driver paket.

1. Installera MongoDB .NET-drivrutinen med Hjälp av NuGet-pakethanteraren.

   dotnet add package MongoDB.Driver
   

2. Öppna och granska filen azure-documentdb-dotnet-quickstart.csproj för att verifiera att paketreferensen finns.

3. Importera de nödvändiga namnrymderna till programkoden:

   using System;
   using System.Collections.Generic;
   using System.Threading.Tasks;
   using MongoDB.Bson;
   using MongoDB.Bson.Serialization.Attributes;
   using MongoDB.Driver;
   

Objektmodell

Namn	Description
MongoClient	Typ som används för att ansluta till MongoDB.
IMongoDatabase	Representerar en databas i klustret.
IMongoCollection<T>	Representerar en samling i en databas i klustret.

Kodexempel

• Autentisera klienten
• Hämta en samling
• Skapa ett dokument
• Hämta ett dokument
• Söka i dokument

Koden i det här programmet ansluter till en databas med namnet adventureworks och en samling med namnet products. Samlingen products innehåller information som namn, kategori, kvantitet, en unik identifierare och en försäljningsflagga för varje produkt. Kodexemplen här utför de vanligaste åtgärderna när du arbetar med en samling.

Autentisera klienten

Anslut först till klienten med en grundläggande anslutningssträng.

1. Skapa huvudmetoden och konfigurera anslutningssträngen. Ersätt <your-cluster-name>, <your-username>och <your-password> med din faktiska klusterinformation.

   class Program
   {
       static async Task Main(string[] args)
       {
           // Connection string for Azure DocumentDB cluster
           string connectionString = "mongodb+srv://<your-username>:<your-password>@<your-cluster-name>.global.mongocluster.cosmos.azure.com/?tls=true&authMechanism=SCRAM-SHA-256&retrywrites=false&maxIdleTimeMS=120000";
   
           // Create MongoDB client settings
           var settings = MongoClientSettings.FromConnectionString(connectionString);
   

2. Skapa MongoDB-klienten och verifiera anslutningen.

           // Create a new client and connect to the server
           var client = new MongoClient(settings);
   
           // Ping the server to verify connection
           var database = client.GetDatabase("admin");
           var pingCommand = new BsonDocument("ping", 1);
           await database.RunCommandAsync<BsonDocument>(pingCommand);
   
           Console.WriteLine("Successfully connected and pinged Azure DocumentDB");
   

Hämta en samling

Hämta nu databasen och samlingen. Om databasen och samlingen inte redan finns använder du drivrutinen för att skapa den automatiskt.

1. Hämta en referens till databasen.

           // Get database reference
           var adventureWorksDatabase = client.GetDatabase("adventureworks");
           Console.WriteLine($"Connected to database: {adventureWorksDatabase.DatabaseNamespace.DatabaseName}");
   

2. Hämta en referens till samlingen i databasen.

           // Get collection reference
           var productsCollection = adventureWorksDatabase.GetCollection<Product>("products");
           Console.WriteLine($"Connected to collection: products");
   

Skapa ett dokument

Skapa sedan ett par nya dokument i samlingen. Anslut dokumenten så att de ersätter alla befintliga dokument om de redan finns med samma unika identifierare.

1. Definiera en produktklass och skapa exempelproduktdokument.

           // Create sample products
           var products = new List<Product>
           {
               new Product
               {
                   Id = "00000000-0000-0000-0000-000000004018",
                   Name = "Windry Mittens",
                   Category = "apparel-accessories-gloves-and-mittens",
                   Quantity = 121,
                   Price = 35.00m,
                   Sale = false
               },
               new Product
               {
                   Id = "00000000-0000-0000-0000-000000004318",
                   Name = "Niborio Tent",
                   Category = "gear-camp-tents",
                   Quantity = 140,
                   Price = 420.00m,
                   Sale = true
               }
           };
   

2. Infoga dokumenten med hjälp av upsert-åtgärder.

           // Insert documents with upsert
           foreach (var product in products)
           {
               var filter = Builders<Product>.Filter.Eq(p => p.Id, product.Id);
               var options = new ReplaceOptions { IsUpsert = true };
   
               await productsCollection.ReplaceOneAsync(filter, product, options);
               Console.WriteLine($"Upserted product: {product.Name}");
           }
   

3. Lägg till produktklassdefinitionen i slutet av din Program.cs-fil.

   public class Product
   {
       [BsonId]
       [BsonElement("_id")]
       public string Id { get; set; }
   
       [BsonElement("name")]
       public string Name { get; set; }
   
       [BsonElement("category")]
       public string Category { get; set; }
   
       [BsonElement("quantity")]
       public int Quantity { get; set; }
   
       [BsonElement("price")]
       public decimal Price { get; set; }
   
       [BsonElement("sale")]
       public bool Sale { get; set; }
   }
   

Hämta ett dokument

Utför sedan en punktläsningsåtgärd för att hämta ett visst dokument från samlingen.

1. Definiera filtret för att hitta ett specifikt dokument efter ID.

           // Retrieve a specific document by ID
           var filter = Builders<Product>.Filter.Eq(p => p.Id, "00000000-0000-0000-0000-000000004018");
   

2. Kör frågan och hämta resultatet.

           var retrievedProduct = await productsCollection.Find(filter).FirstOrDefaultAsync();
   
           if (retrievedProduct != null)
           {
               Console.WriteLine($"Retrieved product: {retrievedProduct.Name} - ${retrievedProduct.Price}");
           }
           else
           {
               Console.WriteLine("Product not found");
           }
   

Sök dokument

Slutligen kör du frågor mot flera dokument med hjälp av MQL (MongoDB Query Language).

1. Definiera en fråga för att hitta dokument som matchar specifika villkor.

           // Query for products on sale
           var saleFilter = Builders<Product>.Filter.Eq(p => p.Sale, true);
           var saleProducts = await productsCollection.Find(saleFilter).ToListAsync();
   

2. Iterera genom resultaten för att visa matchande dokument.

           Console.WriteLine("Products on sale:");
           foreach (var product in saleProducts)
           {
               Console.WriteLine($"- {product.Name}: ${product.Price:F2} (Category: {product.Category})");
           }
       }
   }
   

Utforska dina data med Hjälp av Visual Studio Code

Använd DocumentDB-tillägget i Visual Studio Code för att utföra grundläggande databasåtgärder, inklusive frågor, infogning, uppdatering och borttagning av data.

1. Öppna Visual Studio Code.

2. Navigera till vyn Tillägg och sök efter termen DocumentDB. Leta upp tillägget DocumentDB för VS Code.

3. Välj knappen Installera för tillägget. Vänta tills installationen har slutförts. Ladda Visual Studio Code igen om du uppmanas att göra det.

4. Gå till DocumentDB-tillägget genom att välja motsvarande ikon i aktivitetsfältet.

5. I fönstret DocumentDB-anslutningar väljer du + Ny anslutning....

6. I dialogrutan väljer du Tjänstidentifiering och sedan Azure DocumentDB – Azure Service Discovery.

7. Välj din Azure-prenumeration och ditt nyligen skapade Azure DocumentDB-kluster.

   Tips/Råd

   I många företagsmiljöer är IP-adresser för utvecklardatorer dolda på grund av ett VPN eller andra företagsnätverksinställningar. I dessa fall kan du tillfälligt tillåta åtkomst till alla IP-adresser genom att lägga till IP-adressintervallet 0.0.0.0 - 255.255.255.255 som en brandväggsregel. Använd endast den här brandväggsregeln tillfälligt som en del av anslutningstestning och utveckling. Mer information finns i konfigurera brandväggen.

8. I fönstret DocumentDB-anslutningar expanderar du noden för klustret och navigerar till dina befintliga dokument- och samlingsnoder.

9. Öppna snabbmenyn för samlingen och välj sedan DocumentDB Scrapbook > New DocumentDB Scrapbook.

10. Ange följande MQL-kommandon (MongoDB Query Language) och välj sedan Kör alla. Observera utdata från kommandona.

    db.products.find({
      price: { $gt: 200 },
      sale: true
    })
    .sort({ price: -1 })
    .limit(3)
    

Rensa resurser

När du är klar med Azure DocumentDB-klustret kan du ta bort de Azure-resurser som du skapade så att du inte debiteras fler avgifter.

1. I sökfältet Azure Portal söker du efter och väljer Resursgrupper.

   

2. I listan väljer du den resursgrupp som du använde för den här snabbstarten.

   

3. På resursgruppssidan väljer du Ta bort resursgrupp.

4. I dialogrutan för bekräftelse av borttagning anger du namnet på resursgruppen för att bekräfta att du tänker ta bort den. Slutligen väljer du Ta bort för att ta bort resursgruppen permanent.

   

Relaterat innehåll

• Vad är Azure DocumentDB?