Connecter une application .NET avec MongoDB Atlas

Vous avez probablement entendu parler de MongoDB, l'une des bases de données NoSQL les plus populaires aujourd'hui. Dans cet article, nous allons créer une application en .NET 6 et la connecter à MongoDB Atlas simplement et objectivement.

Les bases de données sont strictement liées au développement de logiciels. Les développeurs de logiciels doivent donc être familiarisés avec ce sujet. Une base de données qui s'est démarquée ces dernières années est MongoDB, qui est une base de données NoSQL et dispose d'une ressource précieuse, l'Atlas MongoDB.

Dans cet article, nous aurons une introduction à MongoDB Atlas, nous créerons une application .NET 6 à partir de rien et nous la connecterons à la base de données du cluster Atlas.

Création de l'application .NET 6

Vous pouvez accéder au code source complet du projet à ce lien :Code source.

L'application utilisée dans l'exemple sera unAPI minimale disponible dans .NET 6. Vous devez donc installer le SDK .NET 6. Lien pour télécharger :SDK .NET 6.

Pour créer l'application, utilisez la commande ci-dessous :

dotnet nouveau web -o StudentManager

Ouvrez le projet avec votre IDE préféré. Dans cet exemple, j'utiliserai Visual Studio 2022.

Double-cliquez sur le projet (StudentManager.csproj) et ajoutez le code suivant pour installer les dépendances, puis recompilez le projet.

  <Groupe d'articles>
	<PackageReference Inclure="MongoDB.Driver"Version="2.13.2" />
	<PackageReference Inclure="Swashbuckle.AspNetCore"Version="6.2.3" />
	<PackageReference Inclure="Swashbuckle.AspNetCore.Swagger"Version="6.2.3" />
	<PackageReference Inclure="Swashbuckle.AspNetCore.SwaggerGen"Version="6.2.3" />
	<PackageReference Inclure="Swashbuckle.AspNetCore.SwaggerUI"Version="6.2.3" />
  </Groupe d'articles>

Création des utilisations globales

Les "utilisations globales" sont des fonctionnalités disponibles dans C# 10 et elles permettent d'utiliser des références pour n'importe quelle classe du projet.

Pour utiliser cette fonctionnalité, créez un dossier appelé "Helpers" et à l'intérieur, créez une classe appelée "GlobalUsings". Remplacez le code généré par le code ci-dessous. Ne vous inquiétez pas des erreurs d'importation, nous créerons plus tard les espaces de noms qui n'existent pas encore.

global en utilisantÉtudiantManager.Des modèles;
global en utilisantÉtudiantManager.Données;
global en utilisantÉtudiantManager.Prestations de service;
global en utilisantMongoDB.Bson;
global en utilisantMongoDB.Bson.Sérialisation.Les attributs;
global en utilisantMongoDB.Chauffeur;
global en utilisantMicrosoft.Rallonges.Choix;
global en utilisantMicrosoft.OpenApi.Des modèles;

Ensuite, créons notre entité de base de données. Donc, créez un dossier appelé "Models" et à l'intérieur, ajoutez une classe appelée "Student" et collez-y le code suivant :

espace de nomsÉtudiantManager.Des modèles;

Publiqueenregistrer l'étudiant{
    [BsonId]
    [BsonReprésentation(BsonType.ID d'objet)]
    Publique chaîne de caractères_identifiant{ avoir; ensemble; }

    [BsonElement("nom d'étudiant")]
    Publique chaîne de caractèresNom d'étudiant{ avoir; ensemble; }

    [BsonElement("l'école")]
    PubliqueÉcole École{ avoir; ensemble; }

    [BsonElement("Des marques")]
    Publique entier[]Des marques{ avoir; ensemble; }
}

Publiqueenregistrer l'école{
    [BsonElement("id_école")]
    Publique entierID de l'école{ avoir; ensemble; }

    [BsonElement("Nom")]
    Publique chaîne de caractèresNom{ avoir; ensemble; }

    [BsonElement("adresse")]
    Publique chaîne de caractèresAdresse{ avoir; ensemble; }

    [BsonElement("ville")]
    Publique chaîne de caractèresVille{ avoir; ensemble; }

    [BsonElement("Etat")]
    Publique chaîne de caractèresÉtat{ avoir; ensemble; }

    [BsonElement("code postal")]
    Publique chaîne de caractèresCode postal{ avoir; ensemble; }
}

Atlas MongoDB

Qu'est-ce que l'Atlas MongoDB ?

MongoDB Atlas est l'une des bases de données non relationnelles les plus populaires aujourd'hui. En tant que service de base de données, il fournit toutes les fonctionnalités de MongoDB, en plus d'automatiser les tâches d'administration de la base de données telles que la configuration de la base de données, le provisionnement de l'infrastructure, les correctifs, les événements de mise à l'échelle, les sauvegardes, etc.

Configuration de l'Atlas MongoDB

Après avoir créé l'exemple d'application dans .NET et implémenté l'entité de base de données, nous allons configurer MongoDB Atlas. Si vous débutez avec MongoDB Atlas, je vous recommande ce guide pour créer et configurer votre premier cluster :Premiers pas avec MongoDB Atlas.

Avec le cluster configuré, nous pouvons créer une base de données "student_db" et une collection "students" comme dans l'image ci-dessous :

Obtenir la connexion au cluster

Pour connecter notre application au cluster et avoir accès à la base de données créée, nous devons obtenir la chaîne de connexion, que nous utiliserons plus tard. Pour l'obtenir, suivez simplement les étapes comme indiqué dans les images ci-dessous:

Sur votre base de données, cliquez sur "Se connecter".

Sélectionnez "Connecter votre application".

Sélectionnez le pilote C#/.NET version 2.13 ou ultérieure et vous obtiendrez votre chaîne de connexion.

Définition de la chaîne de connexion

Maintenant que nous avons la connexion au cluster, implémentons la configuration dans le projet.

Remplacez donc le code du fichier "appsettings.json" par le code ci-dessous :

{
  "Paramètres de la base de données des étudiants": {
    "Chaîne de connexion": "",
    "Nom de la base de données": "bd_étudiant",
    "NomCollection": "étudiants",
    "IsSSL": vrai
  },
  "Enregistrement": {
    "Niveau Log": {
      "Défaut": "Information",
      "Microsoft.AspNetCore": "Avertissement"
    }
  },
  "Hôtes autorisés": "*"
}

Important!Dans votre connexion au cluster, remplacez " » par le mot de passe de votre utilisateur de cluster et remplacez « myFirstDatabase » par « student_db ». Dans le code ci-dessus, remplacez "” avec votre connexion au cluster.

Création des paramètres de la base de données

Créons maintenant la classe qui contiendra les variables chargées de stocker les valeurs de la chaîne de connexion créée précédemment.

Créez donc un dossier appelé "Data", et à l'intérieur, créez une nouvelle classe appelée "StudentDatabaseSettings" et insérez-y le code suivant :

espace de nomsÉtudiantManager.Données;
Publique classer StudentDatabaseSettings
{
    Publique chaîne de caractèresChaîne de connexion{ avoir; ensemble; } = chaîne de caractères.Vide;
    Publique chaîne de caractèresNom de la base de données{ avoir; ensemble; } = chaîne de caractères.Vide;
    Publique chaîne de caractèresNomCollection{ avoir; ensemble; } = chaîne de caractères.Vide;
}

Création du service

Maintenant, créons une classe "service" qui sera responsable de la création d'une connexion à la base de données et de l'exécution des opérations CRUD.

Donc, créez un nouveau dossier appelé "Services" et à l'intérieur, créez une nouvelle classe appelée "StudentService" et mettez le code ci-dessous à l'intérieur :

espace de nomsÉtudiantManager.Prestations de service;

Publique classer Service aux étudiants
{
    privé lecture seulementIMongoCollection<Élève>_étudiants;

    Publique Service aux étudiants(IOptions<StudentDatabaseSettings>choix)
    {
        oùmongoClient= Nouveau MongoClient(choix.Évaluer.Chaîne de connexion);_étudiants=mongoClient.Obtenir la base de données(choix.Évaluer.Nom de la base de données)
            .ObtenirCollection<Élève>(choix.Évaluer.NomCollection);
    }

    Publique asynchroneTâche<Lister<Élève>> Avoir tout() =>
        attendre_étudiants.Trouver(_=> vrai).ToListAsync();

    Publique asynchroneTâche<Élève> Avoir(chaîne de caractèresidentifiant) =>
        attendre_étudiants.Trouver(s=>s._identifiant==identifiant).FirstOrDefaultAsyncFirstOrDefaultAsync();

    Publique asynchroneTâcheCréer(Étudiant étudiant) =>
        attendre_étudiants.InsertOneAsync(élève);

    Publique asynchroneTâcheMettre à jour(chaîne de caractèresidentifiant,Étudiant étudiant) =>
        attendre_étudiants.ReplaceOneAsync(s=>s._identifiant==identifiant,élève);

    Publique asynchroneTâcheSupprimer(chaîne de caractèresidentifiant) =>
        attendre_étudiants.SupprimerUnAsynchrone(s=>s._identifiant==identifiant);
}

Création des points de terminaison et configuration du Swagger

Créons maintenant les paramètres pour activer le swagger et ajoutons les points de terminaison qui utiliseront les méthodes de service créées précédemment, ainsi que l'injection de dépendance de la classe "StudentService" et la configuration qui remplira les valeurs des variables de la base de données.

Dans le fichier Program.cs, remplacez le code existant par le code ci-dessous :

oùconstructeur=Application Web.Créer un constructeur(arguments);


S'inscrireServices(constructeur.Prestations de service);

oùapplication=constructeur.Construire();


ConfigureApp(application);application.Cours();

annuler S'inscrireServices(Services IServiceCollection)
{prestations de service.Configurer<StudentDatabaseSettings>(constructeur.Configuration.ObtenirSection("Paramètres de la base de données des étudiants"));prestations de service.AjouterSingleton<Service aux étudiants>();prestations de service.Ajouter des contrôleurs();prestations de service.AddEndpointsApiExplorer();prestations de service.AjouterSwaggerGen(c=>
    {c.SwaggerDoc("v1", Nouveau OpenApiInfo
        {Titre= "API Contacts",La description= "Stocker et partager des contacts",Version= "v1"
        });
    });
}

annuler ConfigureApp(Application WebApplication)
{
    
    si (application.Environnement.EstDéveloppement())
    {application.Utiliser Swagger();application.UtiliserSwaggerUI();
    }application.Utiliser la redirection HTTPS();application.Utiliser l'autorisation();application.MapControllers();application.MapGet("/api/étudiant", asynchrone (Service aux étudiants)
        => attendreservice.Avoir tout());application.MapGet("/api/étudiant/{id}", asynchrone (Service aux étudiants, chaîne de caractèresidentifiant)
        => attendreservice.Avoir(identifiant));application.CartePoste("/api/étudiant", asynchrone (Service aux étudiants,Étudiant étudiant) =>
    {
        attendreservice.Créer(élève);
        retournerRésultats.Créé($"/étudiant/{étudiant._id}",élève);
    });application.MapPut("/api/étudiant/{id}", asynchrone (Service aux étudiants, chaîne de caractèresidentifiant,Mise à jour des étudiantsÉtudiant) =>
    {
        oùélève= attendreservice.Avoir(identifiant);

        si (élèveest nul)
            retournerRésultats.Pas trouvé();mise à jourÉtudiant._identifiant=élève._identifiant;

        attendreservice.Mettre à jour(identifiant,mise à jourÉtudiant);

        retournerRésultats.Pas de contenu();
    });application.CarteSupprimer("/api/étudiants/{id}", asynchrone (Service aux étudiants, chaîne de caractèresidentifiant) =>
    {
        oùélève= attendreservice.Avoir(identifiant);

        si (élèveest nul) retournerRésultats.Pas trouvé();

        attendreservice.Supprimer(identifiant);

        retournerRésultats.Pas trouvé();
    });
}

Tester l'API avec Fiddler Everywhere

Si vous avez suivi les étapes précédentes, notre application est prête à être exécutée et testée. Pour que la page Swagger s'affiche au démarrage de l'application, vous devrez ajouter la configuration comme indiqué dans l'image ci-dessous :

Après avoir démarré l'application, nous pouvons effectuer des opérations CRUD. Dans ce tutoriel, j'utilise Fiddler Everywhere.

Ci-dessous l'entrée dans la base de données MongoDB Atlas :

Conclusion

Dans cet article, nous avons créé une application .NET 6 qui effectue des opérations CRUD et utilise l'Atlas MongoDB comme base de données.

Les avantages de l'utilisation de MongoDB Atlas sont nombreux et l'union avec .NET en fait un outil encore plus étonnant. N'hésitez pas à suggérer des améliorations, vos commentaires sont toujours les bienvenus !