Notions de base d’ASP.NET Core : utilisation d’une base de données

Découvrez comment connecter une application Web ASP.NET Core à une base de données relationnelle avec la solution EF Core ORM et comment utiliser une base de données MySQL avec Dapper.

La base de données est la forme de stockage la plus courante dans les applications Web, permettant aux applications de stocker et de récupérer des informations de manière fiable et à grande échelle. Vous pouvez la considérer comme un composant essentiel et utile dans tout projet. Voyons comment accéder et utiliser une base de données dans une application ASP.NET Core à l’aide d’EF Core et Dapper.

L’une des principales fonctionnalités offertes par ASP.NET Core, un framework de développement Web open source, est sa capacité à s’intégrer de manière transparente à différents systèmes de gestion de bases de données relationnelles tels que SQL Server, MySQL et PostgreSQL. Il s’intègre également aux bases de données non relationnelles telles que MongoDB et Firebase. Cela offre aux entreprises une grande variété d’options pour choisir la base de données la mieux adaptée à leurs besoins.

ASP.NET Core dispose d’une excellente ressource pour travailler avec des bases de données, qui possède déjà plusieurs implémentations abstraites. Les développeurs n’ont pas besoin de réinventer la roue à chaque fois qu’ils doivent créer une nouvelle application. Je parle bien sûr du fameux Mappage objet-relationnel (ORM) maintenu par Microsoft, le EF Core.

Entity Framework Core est un ORM largement utilisé qui facilite l’interaction entre l’application et la base de données. Il simplifie les tâches quotidiennes, telles que la création de tables et de requêtes, en fournissant un ensemble d’outils pour la manipulation de données basées sur du code. Cela accélère le développement et réduit le code nécessaire pour travailler avec les bases de données.

Dans cet article, vous apprendrez comment implémenter une application Web dans ASP.NET Core à partir de zéro et l’intégrer à une base de données. Vous apprendrez également les meilleures pratiques en utilisant EF Core et le micro-ORM Dapper.

Conditions préalables

Cet article suppose que vous possédez déjà des connaissances de base sur l’utilisation de bases de données, telles que la compréhension de SQL et des commandes de base telles que SELECT, INSERT, UPDATE et DELETE pour manipuler et interroger des données.

Nous utiliserons la version 7 de SDK .NETla version recommandée au moment de la rédaction de cet article.

Cet article utilise Visual Studiomais n’hésitez pas à utiliser un autre IDE de votre choix.

Création de l’application

Créons une application simple à l’aide du modèle natif ASP.NET Core pour un minimum d’API. Vous ajouterez les dépendances EF Core et créerez la base de données via le Approche Code First. Enfin, vous créerez les méthodes nécessaires à la manipulation des données.

Vous pouvez accéder au code source complet du projet ici : Code source de PetManager.

Dans Visual Studio, suivez ces étapes pour démarrer rapidement :

• Créez un nouveau projet.
• Choisir API Web ASP.NET Core.
• Nomme le; cet article utilise Gestionnaire d’animaux.
• Choisissez la version .NET. Cet article utilise la version 7.
• Décochez Utiliser des contrôleurs.
• Cliquez sur Créer.

Création de la classe modèle

Ensuite, créez l’entité principale de votre application à travers laquelle EF Core concevra la base de données. Lorsque vous exécutez des commandes EF Core, la table est générée à partir du nom de la classe et les colonnes de la table refléteront les propriétés de la classe.

A la racine du projet, créez un nouveau dossier appelé Des modèles. Dans le dossier, créez une nouvelle classe appelée Animal de compagnie. Ouvrez la classe nouvellement créée et remplacez le code existant par le code ci-dessous :

namespace PetManager.Models;
public class Pet
{
    public Guid Id { get; set; }
    public string? Name { get; set; }
    public string? Species { get; set; }
    public string? Breed { get; set; }
    public int Age { get; set; }
    public string? Color { get; set; }
    public double Weight { get; set; }
    public bool Vaccinated { get; set; }
    public string? LastVaccinationDate { get; set; }
    public Owner? Owner { get; set; }
    public Guid OwnerId { get; set; }
}

public class Owner
{
    public Guid Id { get; set; }
    public string? Name { get; set; }
    public string? Email { get; set; }
    public string? Phone { get; set; }
}

Création de la classe DbContext et ajout du noyau EF

Créons maintenant la classe chargée de communiquer avec EF Core. Grâce à cela, EF Core créera la connexion à la base de données et convertira également l’entité de la base de données vers la classe que vous avez créée précédemment.

Afin d’utiliser les fonctionnalités d’EF Core, téléchargez le package du projet dans Visual Studio :

• Dans le Projet onglet, cliquez sur Gérer les packages NuGet…. Une nouvelle fenêtre apparaîtra.
• Cliquez sur Parcourir.
• Dans le champ de recherche, collez le texte Microsoft.EntityFrameworkCore.
• Choisissez la dernière version disponible (ce tutoriel utilise la version 7.0.5).
• Cliquer pour installer.

Pour exécuter correctement les commandes EF Core, téléchargez les packages NuGet suivants :

A la racine du projet, créez un nouveau dossier appelé Données. Dans le dossier, créez une nouvelle classe appelée PetDbContext et remplacez le code généré par le code ci-dessous :

using Microsoft.EntityFrameworkCore;
using PetManager.Models;
namespace PetManager.Data;

public class PetDbContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder options) =>
       options.UseSqlite("DataSource=petManagerDb; Cache=Shared");

    public DbSet<Pet> Pets { get; set; }
    public DbSet<Owner> Owner { get; set; }
}

Notez que le PetDbContext la classe hérite des fonctions de la DbContext classe. À travers le OnConfiguring() méthode, vous transmettez les paramètres de la base de données, en définissant le nom (petManagerDb) et confirmant que le cache de la base de données sera partagé.

Le Pet la classe est mappée à l’entité de base de données via l’implémentation de DbSet<Pet> Pets { get; set; } et le Owner classe DbSet<Owner> Owner { get; set; }.

Création de la base de données via EF Core

EF Core peut créer la base de données basée sur l’entité du projet en exécutant simplement quelques commandes. Cependant, pour ce faire, vous devez avoir installé EF globalement sur votre ordinateur :

dotnet tool install --global dotnet-ef

Pour exécuter des commandes EF dans Visual Studio, procédez comme suit :

• Cliquez avec le bouton droit sur le projet.
• Choisir Ouvrir dans le terminal.
• Dans le terminal, exécutez la commande dotnet ef migrations add InitialModel pour créer les scripts de base de données.
• Exécutez la commande dotnet ef database update pour créer la base de données à la racine du projet.

Après avoir exécuté les commandes, vous devriez obtenir un résultat semblable à l’image ci-dessous :

Création des points de terminaison de l’API

Puisque la base de données a été créée à la racine du projet, votre étape suivante consiste à créer les routes API pour remplir la base de données.

Remplacez le code dans le Program.cs fichier avec le code ci-dessous :

using Microsoft.EntityFrameworkCore;
using PetManager.Data;
using PetManager.Models;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddTransient<PetDbContext>();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.MapGet("/pets", (PetDbContext db) =>
{
    var pets = db.Pets;
    var owners = db.Owner;

    foreach (var petItem in pets)
    {
        var owner = owners.SingleOrDefault(o => o.Id == petItem.OwnerId);
        petItem.Owner = owner;
    }
    return Results.Ok(pets);
});

app.MapGet("/pets/{id}", (Guid id, PetDbContext db) =>
{
    var pets = db.Pets;
    var pet = pets.SingleOrDefault(p => p.Id == id);

    if (pet == null)
        return Results.NotFound();

    var owners = db.Owner;
    var owner = owners.SingleOrDefault(o => o.Id == pet.OwnerId);
    pet.Owner = owner;

    return Results.Ok(pet);
});

app.MapPost("/pets", (PetDbContext db, Pet pet) =>
{
    var pets = db.Pets;
    db.Pets.Add(pet);
    db.SaveChanges();
    return Results.Created($"/pets/{pet.Id}", pet);
});

app.MapPut("/pets/{id}", (Guid id, Pet pet, PetDbContext db) =>
{
    db.Entry(pet).State = EntityState.Modified;
    db.Entry(pet.Owner).State = EntityState.Modified;
    db.SaveChanges();
    return Results.Ok(pet);
});

app.MapDelete("/pets/{id}", (Guid id, PetDbContext db) =>
{
    var pets = db.Pets;
    var petEntity = db.Pets.SingleOrDefault(p => p.Id == id);
    if (petEntity == null)
        return Results.NotFound();

    var owners = db.Owner;
    var owner = owners.SingleOrDefault(o => o.Id == petEntity.OwnerId);
    owners.Remove(owner);

    pets.Remove(petEntity);
    db.SaveChanges();
    return Results.NoContent();
});

app.UseHttpsRedirection();
app.Run();

Le code ci-dessus ajoute une injection de dépendances pour la classe PetDbContext via le code builder.Services.AddTransient();. Vous implémentez également les points de terminaison de l’API pour exécuter le Fonctions CRUD. Les points de terminaison appellent les méthodes que vous avez créées dans la classe de base de données.

Exécution de l’application

Votre API est prête à être exécutée, donc dans Visual Studio, cliquez sur l’icône Lecture. Une fenêtre s’ouvrira dans votre navigateur et vous pourrez désormais tester l’application via l’interface Swagger.

Élargir la POSTE onglet et cliquez Essayer. Dans l’onglet qui s’ouvre, collez le JSON ci-dessous et cliquez sur Exécuter.

{
  "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
  "name": "Max",
  "species": "Dog",
  "breed": "Golden Retriever",
  "age": 3,
  "color": "Golden",
  "weight": 30,
  "vaccinated": true,
  "lastVaccinationDate": "2023-05-01",
  "owner": {
    "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
    "name": "John Doe",
    "email": "johndoe@example.com",
    "phone": "123-456-7890"
  }
}

Avec cette procédure, vous venez de créer un enregistrement dans la base de données. Maintenant, allez dans le OBTENIR onglet et cliquez Essayer > Exécuter pour récupérer l’enregistrement que vous avez créé.

Le GIF ci-dessous montre la procédure de création et de recherche d’un enregistrement.

Analyse de la base de données

Cet article utilise SQLiteune base de données relationnelle connue pour sa simplicité, où le fichier contenant la base de données et les tables sont stockés dans l’application elle-même.

Pour afficher les données de la base de données, ce didacticiel utilise le Éditeur de vues SQLite pour Windowsmais vous pouvez utiliser n’importe quel autre logiciel de votre choix.

Pour créer une connexion avec la base de données, ouvrez le SQLite Viewer, sélectionnez le type SQLite et cliquez Choisir le fichier. Sélectionnez le petManagerDb à la racine du projet et cliquez sur la connexion. Vous pouvez voir le processus dans l’image ci-dessous :

Avec la connexion ouverte, vous pouvez effectuer une recherche dans la base de données, comme indiqué dans l’image ci-dessous :

Notez que le Pets la table établit une relation de clé étrangère avec le Owner table à travers le OwnerId colonne. Lorsque vous utilisez une classe comme propriété dans une autre classe, EF Core identifie qu’une relation existe entre elles. Lorsque vous exécutez les commandes Migrations, les scripts SQL créés sont déjà préparés pour la création de clés étrangères.

Accéder aux données avec Dapper et MySQL

Pimpant est une bibliothèque d’accès aux données .NET. Il a été développé pour simplifier et rationaliser le processus d’accès aux bases de données relationnelles, permettant aux développeurs d’écrire des requêtes SQL directement et efficacement.

Contrairement à d’autres solutions ORM plus complexes, telles que Cadre d’entité, Dapper est un micro-ORM. Bibliothèque minimaliste, Dapper se concentre uniquement sur la tâche de mapper les résultats des requêtes SQL en objets .NET. Il offre des performances exceptionnellement rapides grâce à son approche légère et simple.

Pour utiliser la base de données MySQL, vous devez avoir préalablement configuré un serveur MySQL en local. Cet article n’explique pas comment configurer MySQL, mais des didacticiels sont facilement disponibles en ligne.

Dapper ne dispose pas de ressources natives pour générer des bases de données et des tables comme EF Core, vous devez donc les créer manuellement. Vous pouvez utiliser les commandes SQL ci-dessous pour créer la base de données et les tables dans MySQL :

CREATE DATABASE `petmanagerdb`  ;

USE `petmanagerdb` ;


CREATE TABLE `pet` (
  `Id` char(36) NOT NULL,
  `Name` varchar(255) DEFAULT NULL,
  `Species` varchar(255) DEFAULT NULL,
  `Breed` varchar(255) DEFAULT NULL,
  `Age` int DEFAULT NULL,
  `Color` varchar(255) DEFAULT NULL,
  `Weight` double DEFAULT NULL,
  `Vaccinated` tinyint(1) DEFAULT NULL,
  `LastVaccinationDate` date DEFAULT NULL,
  `OwnerId` char(36) NOT NULL,
  PRIMARY KEY (`Id`),
  KEY `OwnerId` (`OwnerId`),
  CONSTRAINT `pet_ibfk_1` FOREIGN KEY (`OwnerId`) REFERENCES `owner` (`Id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;


CREATE TABLE `owner` (
  `Id` char(36) NOT NULL,
  `Name` varchar(255) DEFAULT NULL,
  `Email` varchar(255) DEFAULT NULL,
  `Phone` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`Id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

Pour travailler avec Dapper, vous devez télécharger deux packages NuGet :

Vous pouvez également les télécharger via Gérer les packages NuGet dans Visual Studio.

Vous devez créer une nouvelle entité pour représenter les tables dans MySQL. À l’intérieur de Des modèles dossier créer une nouvelle classe appelée Modèle pour animaux de compagnie et remplacez le code généré par le code ci-dessous :

namespace PetManager.Models;
public class PetDto
{
   public string? Id { get; set; }
    public string? Name { get; set; }
    public string? Species { get; set; }
    public string? Breed { get; set; }
    public int Age { get; set; }
    public string? Color { get; set; }
    public double Weight { get; set; }
    public bool Vaccinated { get; set; }
    public string? LastVaccinationDate { get; set; }
    public string? OwnerId { get; set; }
    public OwnerDto? Owner { get; set;}
}

public class OwnerDto
{
    public string? Id { get; set; }
    public string? Name { get; set; }
    public string? Email { get; set; }
    public string? Phone { get; set; }
}

Toujours à l’intérieur du Des modèles dossier, ajoutez une nouvelle classe appelée Chaîne de connexion et remplacez le code généré par le code ci-dessous :

namespace PetManager.Models;
public class ConnectionString
{
    public string? ProjectConnection { get; set; }
}

Cette classe sera utilisée pour stocker la chaîne de connexion MySQL.

Créons maintenant la classe de référentiel qui exécutera les requêtes dans MySQL. À l’intérieur de Données dossier, créez une nouvelle classe appelée Dépôt d’animaux et remplacez le code généré par le code ci-dessous :

using Dapper;
using Microsoft.Extensions.Options;
using MySql.Data.MySqlClient;
using PetManager.Models;
using System.Data;

namespace PetManager.Data;
public class PetRepository
{
    private readonly IDbConnection _dbConnection;

    public PetRepository(IOptions<ConnectionString> connectionString)
    {
        _dbConnection = new MySqlConnection(connectionString.Value.ProjectConnection);
    }

    public async Task<List<PetDto>> GetAllPets()
    {
        using (_dbConnection)
        {
            string query = "select * from pet";

            var pets = await _dbConnection.QueryAsync<PetDto>(query);
            return pets.ToList();
        }
    }

    public async Task<OwnerDto> GetOwner(string ownerId)
    {
        using (_dbConnection)
        {
            string query = "select * from owner where id = @OwnerId";

            var owner = await _dbConnection.QueryAsync<OwnerDto>(query, new { OwnerId = ownerId });

            return owner.SingleOrDefault();
        }
    }
}

Notez que dans le code ci-dessus, vous définissez des méthodes pour rechercher des entités dans la base de données ; vous transmettrez une chaîne de requête contenant le code SQL nécessaire pour renvoyer les données.

Créons maintenant la chaîne de connexion MySQL. Ouvrez le appsettings.json fichier à la racine du projet et remplacez le code existant par le code ci-dessous :

{
  "ConnectionStrings": {
    "ProjectConnection": "host=localhost; port=YOUR_MYSQL_PORT; database=petmanagerdb; user=YOUR_MYSQL_USER; password=YOUR_MYSQL_PASSWORD;"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

Remplacer YOUR_MYSQL_PORT, YOUR_MYSQL_USER et YOUR_MYSQL_PASSWORD avec vos paramètres MySQL locaux.

La dernière étape consiste à ajouter les configurations des classes précédemment créées. Dans le Program.cs fichier, ajoutez les lignes de code ci-dessous :

builder.Services.AddSingleton<PetRepository>();
builder.Services.Configure<ConnectionString>(builder.Configuration.GetSection("ConnectionStrings"));

Vous devez également ajouter le point de terminaison qui utilisera la base de données MySQL. Dans le Program.cs fichier, ajoutez le code ci-dessous :

app.MapGet("/pets/viadapper", async (PetRepository db) =>
{
    var pets = await db.GetAllPets();
    foreach (var pet in pets)
        pet.Owner = await db.GetOwner(pet.OwnerId);

    return Results.Ok(pets);
});

Pour le tester, exécutez l’application et utilisez Swagger pour exécuter le /pets/viadapper point final comme indiqué ci-dessous :

Conclusion

La base de données est un thème omniprésent dans le développement d’applications Web, et ASP.NET Core possède toutes les fonctionnalités nécessaires pour permettre aux développeurs de travailler plus facilement avec elles. Il existe de nombreuses options pour travailler avec des bases de données dans ASP.NET Core ; cet article aborde deux des principaux.

Vous avez appris à créer une application Web dans ASP.NET Core et à la connecter à une base de données relationnelle à l’aide de l’approche Code First avec la solution EF Core ORM. Vous avez également appris à utiliser une base de données MySQL avec le micro-ORM Dapper.