Ces informations portent sur la préversion du produit, qui est susceptible d’être en grande partie modifié avant sa commercialisation. Microsoft n’offre aucune garantie, expresse ou implicite, concernant les informations fournies ici.
Dans ce tutoriel, des classes sont ajoutées pour la gestion des films dans une base de données. Les classes de modèle de l’application utilisent Entity Framework Core (EF Core) pour travailler avec la base de données. EF Core est un mappeur relationnel d’objets (O/RM) qui simplifie l’accès aux données. Vous écrivez d’abord les classes du modèle, puis EF Core crée la base de données.
Les classes de modèle portent le nom de classes OCT (« Objet CLR Traditionnel »), car elles n’ont pas de dépendances envers EF Core. Elles définissent les propriétés des données stockées dans la base de données.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet RazorPagesMovie >Ajouter>Nouveau dossier. Nommez le dossier Models.
Cliquez avec le bouton droit sur le dossier Models. Sélectionnez Ajouter>Classe. Nommez la classe Movie.
Ajoutez les propriétés suivantes à la classe Movie :
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
La classe Movie contient :
Le champ ID est nécessaire à la base de données pour la clé primaire.
Attribut [DataType] qui spécifie le type de données dans la propriété ReleaseDate. Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
La présence du point d’interrogation après string indique que la propriété peut accepter les valeurs Null. Pour plus d’informations, consultez Types référence pouvant accepter la valeur Null.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Générez le projet pour vérifier qu’il n’y a pas d’erreur de compilation.
Ajoutez un dossier nommé Models.
Ajoutez une classe au dossier Models nommé Movie.cs.
Ajoutez les propriétés suivantes à la classe Movie :
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
La classe Movie contient :
Champ ID permettant de fournir une clé primaire pour la base de données.
Attribut [DataType] pour spécifier le type de données dans le champ ReleaseDate. Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
La présence du point d’interrogation après string indique que la propriété peut accepter les valeurs Null. Pour plus d’informations, consultez Types référence pouvant accepter la valeur Null.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Le fournisseur EF Core SQLite, qui installe le package EF Core comme une dépendance.
Les packages nécessaires à la génération de modèles automatique : Microsoft.VisualStudio.Web.CodeGeneration.Design et Microsoft.EntityFrameworkCore.SqlServer.
Pour obtenir de l’aide sur la configuration de plusieurs environnements qui permet à une application de configurer ses contextes de base de données par environnement, consultez Utiliser plusieurs environnements dans ASP.NET Core.
Remarque
Par défaut, l’architecture des fichiers binaires .NET à installer représente l’architecture du système d’exploitation en cours d’exécution. Pour spécifier une architecture de système d’exploitation différente, consultez dotnet tool install, --arch option.
Pour plus d'informations, consultez le problème GitHub dotnet/AspNetCore.Docs n° 29262.
Dans Visual Studio Code, appuyez sur Ctrl+F5 (Windows) ou ⌘+F5 (macOS) pour exécuter l’application sans débogage.
Dans le panneau situé sous la région de l’éditeur, sélectionnez l’onglet PROBLÈMES ou, dans le menu Affichage, sélectionnez Problèmes s’il n’est pas actuellement affiché. Vérifiez qu’il n’y a pas d’erreur de compilation.
Dans la fenêtre Outil solution, cliquez sur le projet RazorPagesMovie, puis sélectionnez Ajouter un>nouveau dossier.... Nommez le dossier Models.
Cliquez sur le dossier Models, puis sélectionnez Ajouter une>nouvelle classe....
Dans la boîte de dialogue Nouveau fichier :
Dans le volet gauche, sélectionnez Général.
Dans le volet central, sélectionnez Classe vide.
Nommez la classe Movie, puis sélectionnez Créer.
Ajoutez les propriétés suivantes à la classe Movie :
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
La classe Movie contient :
Champ ID permettant de fournir une clé primaire pour la base de données.
Attribut [DataType] pour spécifier le type de données dans le champ ReleaseDate. Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Générez le projet pour vérifier qu’il n’y a pas d’erreur de compilation.
Générer automatiquement le modèle de film
Dans cette section, le modèle de film est généré automatiquement. Autrement dit, l’outil de génération de modèles automatique génère des pages pour les opérations de création, de lecture, de mise à jour et de suppression (CRUD) pour le modèle de film.
Utiliser SQLite pour le développement, SQL Server pour la production
Lorsque SQLite est sélectionné, le code généré par le modèle est prêt pour le développement. Le code suivant montre comment sélectionner la chaîne de connexion SQLite dans le développement et SQL Server dans la production.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Le code précédent n’appelle pas UseDeveloperExceptionPage dans le développement, car WebApplication appelle UseDeveloperExceptionPage en mode développement.
Ajoutez le package NuGet Microsoft.EntityFrameworkCore.Sqlite, qui est requis pour l’outil de génération de modèles automatique.
Dans la fenêtre Outil solution, cliquez sur le projet RazorPagesMovie, puis sélectionnez Ouvrir dans le terminal.
La fenêtre Terminal s’ouvre avec l’invite de commandes dans le répertoire du projet, qui contient les fichiers Program.cs et .csproj.
Cliquez avec le bouton droit sur le dossier Pages >Ajouter>Nouveau dossier.
Nommez le dossier Movies.
Cliquez sur le dossier Pages/Movies >Ajouter>Nouvelle génération de modèles automatique....
Dans la boîte de dialogue Nouvelle génération de modèles automatique, sélectionnez Pages Razor utilisant Entity Framework (CRUD)>Ajouter.
Renseignez la boîte de dialogue Ajouter des pages Razor avec Entity Framework (CRUD) :
Dans la ligne classe de modèle à utiliser :, entrez Movie.
Dans la ligne classe DbContext à utiliser :, nommez la classe RazorPagesMovie.Data.RazorPagesMovieContext.
Sélectionnez Terminer.
Le processus de génération de modèles automatique peut prendre un certain temps, car les packages requis sont automatiquement téléchargés et ajoutés au projet.
Le fichier appsettings.json est mis à jour avec la chaîne de connexion utilisée pour se connecter à une base de données locale.
Utiliser SQLite pour le développement, SQL Server pour la production
Lorsque SQLite est sélectionné, le code généré par le modèle est prêt pour le développement. Le code suivant montre comment sélectionner la chaîne de connexion SQLite dans le développement et SQL Server dans la production.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Le code précédent n’appelle pas UseDeveloperExceptionPage dans le développement, car WebApplication appelle UseDeveloperExceptionPage en mode développement.
Fichiers créés et mis à jour
Le processus de génération de modèles automatique crée les fichiers suivants :
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Les modifications Program.cs sont expliquées plus loin dans ce tutoriel.
Créer le schéma de base de données initial à l’aide de la fonctionnalité de migration d’EF
La fonctionnalité de migration dans Entity Framework Core permet de :
Créer le schéma de base de données initial.
Mettre à jour de façon incrémentielle le schéma de base de données afin de le garder synchronisé avec le modèle de données de l’application. Les données existantes dans la base de données sont conservées.
Dans cette section, la fenêtre Console du gestionnaire de package est utilisée pour :
Ajouter une migration initiale
Mettez à jour la base de données avec la migration initiale.
Dans le menu Outils, sélectionnez Gestionnaire de package NuGet>Console du gestionnaire de package.
Dans la console du Gestionnaire de package, entrez les commandes suivantes :
Add-Migration InitialCreate
Update-Database
La commande Add-Migration génère le code nécessaire à la création du schéma de base de données initial. Le schéma est basé sur le modèle spécifié dans DbContext. L’argument InitialCreate est utilisé pour nommer la migration. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné.
La commande Update-Database exécute la méthode Up dans des migrations qui n’ont pas été appliquées. Dans ce cas, la commande exécute la méthode Up dans le fichier Migrations/<time-stamp>_InitialCreate.cs, ce qui entraîne la création de la base de données.
Cliquez avec le bouton droit sur le projet RazorPagesMovie.csproj, puis sélectionnez Ouvrir dans le terminal intégré.
La fenêtre Terminal s’ouvre avec l’invite de commandes dans le répertoire du projet, qui contient les fichiers Program.cs et .csproj.
Exécutez les commandes CLI .NET suivantes :
dotnet ef migrations add InitialCreate
dotnet ef database update
La commande migrations génère le code nécessaire à la création du schéma de base de données initial. Le schéma est basé sur le modèle spécifié dans DbContext. L’argument InitialCreate est utilisé pour nommer les migrations. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné.
La commande update exécute la méthode Up dans des migrations qui n’ont pas été appliquées. Dans ce cas, la commande update exécute la méthode Up dans le fichier Migrations/<time-stamp>_InitialCreate.cs, ce qui entraîne la création de la base de données.
Remarque
Pour SQLite, le type de colonne pour le champ Price est défini sur TEXT. Cela sera résolu dans une étape ultérieure.
Cliquez sur le projet RazorPagesMovie, puis sélectionnez Ouvrir dans le terminal.
La fenêtre Terminal s’ouvre avec l’invite de commandes dans le répertoire du projet, qui contient les fichiers Program.cs et .csproj.
Exécutez les commandes CLI .NET Core suivantes :
dotnet tool uninstall --global dotnet-ef
dotnet tool install --global dotnet-ef
dotnet ef migrations add InitialCreate
dotnet ef database update
Les commandes tool installent les derniers outils Entity Framework Core après avoir désinstallé la version précédente, le cas échéant.
Remarque
Par défaut, l’architecture des fichiers binaires .NET à installer représente l’architecture du système d’exploitation en cours d’exécution. Pour spécifier une architecture de système d’exploitation différente, consultez dotnet tool install, --arch option.
Pour plus d'informations, consultez le problème GitHub dotnet/AspNetCore.Docs n° 29262.
La commande migrations génère le code nécessaire à la création du schéma de base de données initial. Le schéma est basé sur le modèle spécifié dans DbContext. L’argument InitialCreate est utilisé pour nommer les migrations. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné.
La commande update exécute la méthode Up dans des migrations qui n’ont pas été appliquées. Dans ce cas, la commande update exécute la méthode Up dans le fichier Migrations/<time-stamp>_InitialCreate.cs, ce qui entraîne la création de la base de données.
Remarque
Pour SQLite, le type de colonne pour le champ Price est défini sur TEXT. Cela sera résolu dans une étape ultérieure.
L’avertissement suivant s’affiche et sera traité dans une étape ultérieure :
Aucun type n’a été spécifié pour la colonne décimale 'Price' sur le type d’entité 'Movie'. Les valeurs sont tronquées en mode silencieux si elles ne sont pas compatibles avec la précision et l’échelle par défaut. Spécifiez explicitement le type de colonne SQL Server capable d’accueillir toutes les valeurs en utilisant ’HasColumnType()’.
Spécifie les entités qui sont incluses dans le modèle de données.
Coordonne les fonctionnalités EF Core, telles que Créer, Lire, Mettre à jour et Supprimer, pour le modèle Movie.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using RazorPagesMovie.Models;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie> Movie { get; set; } = default!;
}
}
Le code précédent crée une propriété DbSet<Movie> pour le jeu d’entités. Dans la terminologie Entity Framework, un jeu d’entités correspond généralement à une table de base de données. Une entité correspond à une ligne dans la table.
Le nom de la chaîne de connexion est transmis au contexte en appelant une méthode sur un objet DbContextOptions. Pour le développement local, le système de configuration lit la chaîne de connexion à partir du fichier appsettings.json.
Tester l’application
Exécutez l’application et ajoutez /Movies à l’URL dans le navigateur (http://localhost:port/movies).
Si vous voyez le message d’erreur suivant :
SqlException: Cannot open database "RazorPagesMovieContext-GUID" requested by the login. The login failed.
Login failed for user 'User-name'.
Vous ne pourrez peut-être pas entrer de virgules décimales dans le champ Price. Pour prendre en charge la validation jQuery pour les paramètres régionaux autres que « Anglais » qui utilisent une virgule (« , ») comme décimale et des formats de date autres que le format « Anglais (États-Unis »), l’application doit être localisée. Pour obtenir des instructions sur la localisation, consultez ce problème GitHub.
Testez les liens Modifier, Détails et Supprimer.
Le prochain didacticiel décrit les fichiers créés par la génération de modèles automatique.
Examiner le contexte inscrit avec l’injection de dépendances
ASP.NET Core comprend l’injection de dépendances. Des services, tels que le contexte de base de données EF Core, sont inscrits avec l’injection de dépendance au démarrage de l’application. Ces services sont affectés aux composants qui les nécessitent (par exemple les Pages Razor) par le biais de paramètres de constructeur. Le code de constructeur qui obtient une instance de contexte de base de données est indiqué plus loin dans le tutoriel.
L’outil de génération de modèles automatique a créé automatiquement un contexte de base de données et l’a inscrit dans le conteneur d’injection de dépendances. Le code mis en surbrillance suivant est ajouté au fichier Program.cs par le générateur de modèles :
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Dans ce tutoriel, des classes sont ajoutées pour la gestion des films dans une base de données. Les classes de modèle de l’application utilisent Entity Framework Core (EF Core) pour travailler avec la base de données. EF Core est un mappeur relationnel d’objets (O/RM) qui simplifie l’accès aux données. Vous écrivez d’abord les classes du modèle, puis EF Core crée la base de données.
Les classes de modèle portent le nom de classes OCT (« Objet CLR Traditionnel »), car elles n’ont pas de dépendances envers EF Core. Elles définissent les propriétés des données stockées dans la base de données.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet RazorPagesMovie >Ajouter>Nouveau dossier. Nommez le dossier Models.
Cliquez avec le bouton droit sur le dossier Models. Sélectionnez Ajouter>Classe. Nommez la classe Movie.
Ajoutez les propriétés suivantes à la classe Movie :
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
La classe Movie contient :
Le champ ID est nécessaire à la base de données pour la clé primaire.
Attribut [DataType] qui spécifie le type de données dans la propriété ReleaseDate. Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
La présence du point d’interrogation après string indique que la propriété peut accepter les valeurs Null. Pour plus d’informations, consultez Types référence pouvant accepter la valeur Null.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Générez le projet pour vérifier qu’il n’y a pas d’erreur de compilation.
Ajoutez un dossier nommé Models.
Ajoutez une classe au dossier Models nommé Movie.cs.
Ajoutez les propriétés suivantes à la classe Movie :
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
La classe Movie contient :
Champ ID permettant de fournir une clé primaire pour la base de données.
Attribut [DataType] pour spécifier le type de données dans le champ ReleaseDate. Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
La présence du point d’interrogation après string indique que la propriété peut accepter les valeurs Null. Pour plus d’informations, consultez Types référence pouvant accepter la valeur Null.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Le fournisseur EF Core SQLite, qui installe le package EF Core comme une dépendance.
Les packages nécessaires à la génération de modèles automatique : Microsoft.VisualStudio.Web.CodeGeneration.Design et Microsoft.EntityFrameworkCore.SqlServer.
Pour obtenir de l’aide sur la configuration de plusieurs environnements qui permet à une application de configurer ses contextes de base de données par environnement, consultez Utiliser plusieurs environnements dans ASP.NET Core.
Remarque
Par défaut, l’architecture des fichiers binaires .NET à installer représente l’architecture du système d’exploitation en cours d’exécution. Pour spécifier une architecture de système d’exploitation différente, consultez dotnet tool install, --arch option.
Pour plus d'informations, consultez le problème GitHub dotnet/AspNetCore.Docs n° 29262.
Dans Visual Studio Code, appuyez sur Ctrl+F5 (Windows) ou ⌘+F5 (macOS) pour exécuter l’application sans débogage.
Dans le panneau situé sous la région de l’éditeur, sélectionnez l’onglet PROBLÈMES ou, dans le menu Affichage, sélectionnez Problèmes s’il n’est pas actuellement affiché. Vérifiez qu’il n’y a pas d’erreur de compilation.
Dans la fenêtre Outil solution, cliquez sur le projet RazorPagesMovie, puis sélectionnez Ajouter un>nouveau dossier.... Nommez le dossier Models.
Cliquez sur le dossier Models, puis sélectionnez Ajouter une>nouvelle classe....
Dans la boîte de dialogue Nouveau fichier :
Dans le volet gauche, sélectionnez Général.
Dans le volet central, sélectionnez Classe vide.
Nommez la classe Movie, puis sélectionnez Créer.
Ajoutez les propriétés suivantes à la classe Movie :
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
La classe Movie contient :
Champ ID permettant de fournir une clé primaire pour la base de données.
Attribut [DataType] pour spécifier le type de données dans le champ ReleaseDate. Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Générez le projet pour vérifier qu’il n’y a pas d’erreur de compilation.
Générer automatiquement le modèle de film
Dans cette section, le modèle de film est généré automatiquement. Autrement dit, l’outil de génération de modèles automatique génère des pages pour les opérations de création, de lecture, de mise à jour et de suppression (CRUD) pour le modèle de film.
Utiliser SQLite pour le développement, SQL Server pour la production
Lorsque SQLite est sélectionné, le code généré par le modèle est prêt pour le développement. Le code suivant montre comment sélectionner la chaîne de connexion SQLite dans le développement et SQL Server dans la production.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Le code précédent n’appelle pas UseDeveloperExceptionPage dans le développement, car WebApplication appelle UseDeveloperExceptionPage en mode développement.
Ajoutez le package NuGet Microsoft.EntityFrameworkCore.Sqlite, qui est requis pour l’outil de génération de modèles automatique.
Dans la fenêtre Outil solution, cliquez sur le projet RazorPagesMovie, puis sélectionnez Ouvrir dans le terminal.
La fenêtre Terminal s’ouvre avec l’invite de commandes dans le répertoire du projet, qui contient les fichiers Program.cs et .csproj.
Cliquez avec le bouton droit sur le dossier Pages >Ajouter>Nouveau dossier.
Nommez le dossier Movies.
Cliquez sur le dossier Pages/Movies >Ajouter>Nouvelle génération de modèles automatique....
Dans la boîte de dialogue Nouvelle génération de modèles automatique, sélectionnez Pages Razor utilisant Entity Framework (CRUD)>Ajouter.
Renseignez la boîte de dialogue Ajouter des pages Razor avec Entity Framework (CRUD) :
Dans la ligne classe de modèle à utiliser :, entrez Movie.
Dans la ligne classe DbContext à utiliser :, nommez la classe RazorPagesMovie.Data.RazorPagesMovieContext.
Sélectionnez Terminer.
Le processus de génération de modèles automatique peut prendre un certain temps, car les packages requis sont automatiquement téléchargés et ajoutés au projet.
Le fichier appsettings.json est mis à jour avec la chaîne de connexion utilisée pour se connecter à une base de données locale.
Utiliser SQLite pour le développement, SQL Server pour la production
Lorsque SQLite est sélectionné, le code généré par le modèle est prêt pour le développement. Le code suivant montre comment sélectionner la chaîne de connexion SQLite dans le développement et SQL Server dans la production.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Le code précédent n’appelle pas UseDeveloperExceptionPage dans le développement, car WebApplication appelle UseDeveloperExceptionPage en mode développement.
Fichiers créés et mis à jour
Le processus de génération de modèles automatique crée les fichiers suivants :
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Les modifications Program.cs sont expliquées plus loin dans ce tutoriel.
Créer le schéma de base de données initial à l’aide de la fonctionnalité de migration d’EF
La fonctionnalité de migration dans Entity Framework Core permet de :
Créer le schéma de base de données initial.
Mettre à jour de façon incrémentielle le schéma de base de données afin de le garder synchronisé avec le modèle de données de l’application. Les données existantes dans la base de données sont conservées.
Dans cette section, la fenêtre Console du gestionnaire de package est utilisée pour :
Ajouter une migration initiale
Mettez à jour la base de données avec la migration initiale.
Dans le menu Outils, sélectionnez Gestionnaire de package NuGet>Console du gestionnaire de package.
Dans la console du Gestionnaire de package, entrez les commandes suivantes :
Add-Migration InitialCreate
Update-Database
La commande Add-Migration génère le code nécessaire à la création du schéma de base de données initial. Le schéma est basé sur le modèle spécifié dans DbContext. L’argument InitialCreate est utilisé pour nommer la migration. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné.
La commande Update-Database exécute la méthode Up dans des migrations qui n’ont pas été appliquées. Dans ce cas, la commande exécute la méthode Up dans le fichier Migrations/<time-stamp>_InitialCreate.cs, ce qui entraîne la création de la base de données.
Cliquez avec le bouton droit sur le projet RazorPagesMovie.csproj, puis sélectionnez Ouvrir dans le terminal intégré.
La fenêtre Terminal s’ouvre avec l’invite de commandes dans le répertoire du projet, qui contient les fichiers Program.cs et .csproj.
Exécutez les commandes CLI .NET suivantes :
dotnet ef migrations add InitialCreate
dotnet ef database update
La commande migrations génère le code nécessaire à la création du schéma de base de données initial. Le schéma est basé sur le modèle spécifié dans DbContext. L’argument InitialCreate est utilisé pour nommer les migrations. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné.
La commande update exécute la méthode Up dans des migrations qui n’ont pas été appliquées. Dans ce cas, la commande update exécute la méthode Up dans le fichier Migrations/<time-stamp>_InitialCreate.cs, ce qui entraîne la création de la base de données.
Remarque
Pour SQLite, le type de colonne pour le champ Price est défini sur TEXT. Cela sera résolu dans une étape ultérieure.
Cliquez sur le projet RazorPagesMovie, puis sélectionnez Ouvrir dans le terminal.
La fenêtre Terminal s’ouvre avec l’invite de commandes dans le répertoire du projet, qui contient les fichiers Program.cs et .csproj.
Exécutez les commandes CLI .NET Core suivantes :
dotnet tool uninstall --global dotnet-ef
dotnet tool install --global dotnet-ef
dotnet ef migrations add InitialCreate
dotnet ef database update
Les commandes tool installent les derniers outils Entity Framework Core après avoir désinstallé la version précédente, le cas échéant.
Remarque
Par défaut, l’architecture des fichiers binaires .NET à installer représente l’architecture du système d’exploitation en cours d’exécution. Pour spécifier une architecture de système d’exploitation différente, consultez dotnet tool install, --arch option.
Pour plus d'informations, consultez le problème GitHub dotnet/AspNetCore.Docs n° 29262.
La commande migrations génère le code nécessaire à la création du schéma de base de données initial. Le schéma est basé sur le modèle spécifié dans DbContext. L’argument InitialCreate est utilisé pour nommer les migrations. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné.
La commande update exécute la méthode Up dans des migrations qui n’ont pas été appliquées. Dans ce cas, la commande update exécute la méthode Up dans le fichier Migrations/<time-stamp>_InitialCreate.cs, ce qui entraîne la création de la base de données.
Remarque
Pour SQLite, le type de colonne pour le champ Price est défini sur TEXT. Cela sera résolu dans une étape ultérieure.
L’avertissement suivant s’affiche et sera traité dans une étape ultérieure :
Aucun type n’a été spécifié pour la colonne décimale 'Price' sur le type d’entité 'Movie'. Les valeurs sont tronquées en mode silencieux si elles ne sont pas compatibles avec la précision et l’échelle par défaut. Spécifiez explicitement le type de colonne SQL Server capable d’accueillir toutes les valeurs en utilisant ’HasColumnType()’.
Spécifie les entités qui sont incluses dans le modèle de données.
Coordonne les fonctionnalités EF Core, telles que Créer, Lire, Mettre à jour et Supprimer, pour le modèle Movie.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using RazorPagesMovie.Models;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie> Movie { get; set; } = default!;
}
}
Le code précédent crée une propriété DbSet<Movie> pour le jeu d’entités. Dans la terminologie Entity Framework, un jeu d’entités correspond généralement à une table de base de données. Une entité correspond à une ligne dans la table.
Le nom de la chaîne de connexion est transmis au contexte en appelant une méthode sur un objet DbContextOptions. Pour le développement local, le système de configuration lit la chaîne de connexion à partir du fichier appsettings.json.
Tester l’application
Exécutez l’application et ajoutez /Movies à l’URL dans le navigateur (http://localhost:port/movies).
Si vous voyez le message d’erreur suivant :
SqlException: Cannot open database "RazorPagesMovieContext-GUID" requested by the login. The login failed.
Login failed for user 'User-name'.
Vous ne pourrez peut-être pas entrer de virgules décimales dans le champ Price. Pour prendre en charge la validation jQuery pour les paramètres régionaux autres que « Anglais » qui utilisent une virgule (« , ») comme décimale et des formats de date autres que le format « Anglais (États-Unis »), l’application doit être localisée. Pour obtenir des instructions sur la localisation, consultez ce problème GitHub.
Testez les liens Modifier, Détails et Supprimer.
Le prochain didacticiel décrit les fichiers créés par la génération de modèles automatique.
Examiner le contexte inscrit avec l’injection de dépendances
ASP.NET Core comprend l’injection de dépendances. Des services, tels que le contexte de base de données EF Core, sont inscrits avec l’injection de dépendance au démarrage de l’application. Ces services sont affectés aux composants qui les nécessitent (par exemple les Pages Razor) par le biais de paramètres de constructeur. Le code de constructeur qui obtient une instance de contexte de base de données est indiqué plus loin dans le tutoriel.
L’outil de génération de modèles automatique a créé automatiquement un contexte de base de données et l’a inscrit dans le conteneur d’injection de dépendances. Le code mis en surbrillance suivant est ajouté au fichier Program.cs par le générateur de modèles :
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Dans ce tutoriel, des classes sont ajoutées pour la gestion des films dans une base de données. Les classes de modèle de l’application utilisent Entity Framework Core (EF Core) pour travailler avec la base de données. EF Core est un mappeur relationnel d’objets (O/RM) qui simplifie l’accès aux données. Vous écrivez d’abord les classes du modèle, puis EF Core crée la base de données.
Les classes de modèle portent le nom de classes OCT (« Objet CLR Traditionnel »), car elles n’ont pas de dépendances envers EF Core. Elles définissent les propriétés des données stockées dans la base de données.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet RazorPagesMovie >Ajouter>Nouveau dossier. Nommez le dossier Models.
Cliquez avec le bouton droit sur le dossier Models. Sélectionnez Ajouter>Classe. Nommez la classe Movie.
Ajoutez les propriétés suivantes à la classe Movie :
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
La classe Movie contient :
Le champ ID est nécessaire à la base de données pour la clé primaire.
Attribut [DataType] qui spécifie le type de données dans la propriété ReleaseDate. Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
La présence du point d’interrogation après string indique que la propriété peut accepter les valeurs Null. Pour plus d’informations, consultez Types référence pouvant accepter la valeur Null.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Générez le projet pour vérifier qu’il n’y a pas d’erreur de compilation.
Ajoutez un dossier nommé Models.
Ajoutez une classe au dossier Models nommé Movie.cs.
Ajoutez les propriétés suivantes à la classe Movie :
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
La classe Movie contient :
Champ ID permettant de fournir une clé primaire pour la base de données.
Attribut [DataType] pour spécifier le type de données dans le champ ReleaseDate. Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
La présence du point d’interrogation après string indique que la propriété peut accepter les valeurs Null. Pour plus d’informations, consultez Types référence pouvant accepter la valeur Null.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Le fournisseur EF Core SQLite, qui installe le package EF Core comme une dépendance.
Les packages nécessaires à la génération de modèles automatique : Microsoft.VisualStudio.Web.CodeGeneration.Design et Microsoft.EntityFrameworkCore.SqlServer.
Pour obtenir de l’aide sur la configuration de plusieurs environnements qui permet à une application de configurer ses contextes de base de données par environnement, consultez Utiliser plusieurs environnements dans ASP.NET Core.
Remarque
Par défaut, l’architecture des fichiers binaires .NET à installer représente l’architecture du système d’exploitation en cours d’exécution. Pour spécifier une architecture de système d’exploitation différente, consultez dotnet tool install, --arch option.
Pour plus d'informations, consultez le problème GitHub dotnet/AspNetCore.Docs n° 29262.
Dans Visual Studio Code, appuyez sur Ctrl+F5 (Windows) ou ⌘+F5 (macOS) pour exécuter l’application sans débogage.
Dans le panneau situé sous la région de l’éditeur, sélectionnez l’onglet PROBLÈMES ou, dans le menu Affichage, sélectionnez Problèmes s’il n’est pas actuellement affiché. Vérifiez qu’il n’y a pas d’erreur de compilation.
Dans la fenêtre Outil solution, cliquez sur le projet RazorPagesMovie, puis sélectionnez Ajouter un>nouveau dossier.... Nommez le dossier Models.
Cliquez sur le dossier Models, puis sélectionnez Ajouter une>nouvelle classe....
Dans la boîte de dialogue Nouveau fichier :
Dans le volet gauche, sélectionnez Général.
Dans le volet central, sélectionnez Classe vide.
Nommez la classe Movie, puis sélectionnez Créer.
Ajoutez les propriétés suivantes à la classe Movie :
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
La classe Movie contient :
Champ ID permettant de fournir une clé primaire pour la base de données.
Attribut [DataType] pour spécifier le type de données dans le champ ReleaseDate. Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Générez le projet pour vérifier qu’il n’y a pas d’erreur de compilation.
Générer automatiquement le modèle de film
Dans cette section, le modèle de film est généré automatiquement. Autrement dit, l’outil de génération de modèles automatique génère des pages pour les opérations de création, de lecture, de mise à jour et de suppression (CRUD) pour le modèle de film.
Utiliser SQLite pour le développement, SQL Server pour la production
Lorsque SQLite est sélectionné, le code généré par le modèle est prêt pour le développement. Le code suivant montre comment sélectionner la chaîne de connexion SQLite dans le développement et SQL Server dans la production.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Le code précédent n’appelle pas UseDeveloperExceptionPage dans le développement, car WebApplication appelle UseDeveloperExceptionPage en mode développement.
Ajoutez le package NuGet Microsoft.EntityFrameworkCore.Sqlite, qui est requis pour l’outil de génération de modèles automatique.
Dans la fenêtre Outil solution, cliquez sur le projet RazorPagesMovie, puis sélectionnez Ouvrir dans le terminal.
La fenêtre Terminal s’ouvre avec l’invite de commandes dans le répertoire du projet, qui contient les fichiers Program.cs et .csproj.
Cliquez avec le bouton droit sur le dossier Pages >Ajouter>Nouveau dossier.
Nommez le dossier Movies.
Cliquez sur le dossier Pages/Movies >Ajouter>Nouvelle génération de modèles automatique....
Dans la boîte de dialogue Nouvelle génération de modèles automatique, sélectionnez Pages Razor utilisant Entity Framework (CRUD)>Ajouter.
Renseignez la boîte de dialogue Ajouter des pages Razor avec Entity Framework (CRUD) :
Dans la ligne classe de modèle à utiliser :, entrez Movie.
Dans la ligne classe DbContext à utiliser :, nommez la classe RazorPagesMovie.Data.RazorPagesMovieContext.
Sélectionnez Terminer.
Le processus de génération de modèles automatique peut prendre un certain temps, car les packages requis sont automatiquement téléchargés et ajoutés au projet.
Le fichier appsettings.json est mis à jour avec la chaîne de connexion utilisée pour se connecter à une base de données locale.
Utiliser SQLite pour le développement, SQL Server pour la production
Lorsque SQLite est sélectionné, le code généré par le modèle est prêt pour le développement. Le code suivant montre comment sélectionner la chaîne de connexion SQLite dans le développement et SQL Server dans la production.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Le code précédent n’appelle pas UseDeveloperExceptionPage dans le développement, car WebApplication appelle UseDeveloperExceptionPage en mode développement.
Fichiers créés et mis à jour
Le processus de génération de modèles automatique crée les fichiers suivants :
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Les modifications Program.cs sont expliquées plus loin dans ce tutoriel.
Créer le schéma de base de données initial à l’aide de la fonctionnalité de migration d’EF
La fonctionnalité de migration dans Entity Framework Core permet de :
Créer le schéma de base de données initial.
Mettre à jour de façon incrémentielle le schéma de base de données afin de le garder synchronisé avec le modèle de données de l’application. Les données existantes dans la base de données sont conservées.
Dans cette section, la fenêtre Console du gestionnaire de package est utilisée pour :
Ajouter une migration initiale
Mettez à jour la base de données avec la migration initiale.
Dans le menu Outils, sélectionnez Gestionnaire de package NuGet>Console du gestionnaire de package.
Dans la console du Gestionnaire de package, entrez les commandes suivantes :
Add-Migration InitialCreate
Update-Database
La commande Add-Migration génère le code nécessaire à la création du schéma de base de données initial. Le schéma est basé sur le modèle spécifié dans DbContext. L’argument InitialCreate est utilisé pour nommer la migration. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné.
La commande Update-Database exécute la méthode Up dans des migrations qui n’ont pas été appliquées. Dans ce cas, la commande exécute la méthode Up dans le fichier Migrations/<time-stamp>_InitialCreate.cs, ce qui entraîne la création de la base de données.
Cliquez avec le bouton droit sur le projet RazorPagesMovie.csproj, puis sélectionnez Ouvrir dans le terminal intégré.
La fenêtre Terminal s’ouvre avec l’invite de commandes dans le répertoire du projet, qui contient les fichiers Program.cs et .csproj.
Exécutez les commandes CLI .NET suivantes :
dotnet ef migrations add InitialCreate
dotnet ef database update
La commande migrations génère le code nécessaire à la création du schéma de base de données initial. Le schéma est basé sur le modèle spécifié dans DbContext. L’argument InitialCreate est utilisé pour nommer les migrations. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné.
La commande update exécute la méthode Up dans des migrations qui n’ont pas été appliquées. Dans ce cas, la commande update exécute la méthode Up dans le fichier Migrations/<time-stamp>_InitialCreate.cs, ce qui entraîne la création de la base de données.
Remarque
Pour SQLite, le type de colonne pour le champ Price est défini sur TEXT. Cela sera résolu dans une étape ultérieure.
Cliquez sur le projet RazorPagesMovie, puis sélectionnez Ouvrir dans le terminal.
La fenêtre Terminal s’ouvre avec l’invite de commandes dans le répertoire du projet, qui contient les fichiers Program.cs et .csproj.
Exécutez les commandes CLI .NET Core suivantes :
dotnet tool uninstall --global dotnet-ef
dotnet tool install --global dotnet-ef
dotnet ef migrations add InitialCreate
dotnet ef database update
Les commandes tool installent les derniers outils Entity Framework Core après avoir désinstallé la version précédente, le cas échéant.
Remarque
Par défaut, l’architecture des fichiers binaires .NET à installer représente l’architecture du système d’exploitation en cours d’exécution. Pour spécifier une architecture de système d’exploitation différente, consultez dotnet tool install, --arch option.
Pour plus d'informations, consultez le problème GitHub dotnet/AspNetCore.Docs n° 29262.
La commande migrations génère le code nécessaire à la création du schéma de base de données initial. Le schéma est basé sur le modèle spécifié dans DbContext. L’argument InitialCreate est utilisé pour nommer les migrations. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné.
La commande update exécute la méthode Up dans des migrations qui n’ont pas été appliquées. Dans ce cas, la commande update exécute la méthode Up dans le fichier Migrations/<time-stamp>_InitialCreate.cs, ce qui entraîne la création de la base de données.
Remarque
Pour SQLite, le type de colonne pour le champ Price est défini sur TEXT. Cela sera résolu dans une étape ultérieure.
L’avertissement suivant s’affiche et sera traité dans une étape ultérieure :
Aucun type n’a été spécifié pour la colonne décimale 'Price' sur le type d’entité 'Movie'. Les valeurs sont tronquées en mode silencieux si elles ne sont pas compatibles avec la précision et l’échelle par défaut. Spécifiez explicitement le type de colonne SQL Server capable d’accueillir toutes les valeurs en utilisant ’HasColumnType()’.
Spécifie les entités qui sont incluses dans le modèle de données.
Coordonne les fonctionnalités EF Core, telles que Créer, Lire, Mettre à jour et Supprimer, pour le modèle Movie.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using RazorPagesMovie.Models;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie> Movie { get; set; } = default!;
}
}
Le code précédent crée une propriété DbSet<Movie> pour le jeu d’entités. Dans la terminologie Entity Framework, un jeu d’entités correspond généralement à une table de base de données. Une entité correspond à une ligne dans la table.
Le nom de la chaîne de connexion est transmis au contexte en appelant une méthode sur un objet DbContextOptions. Pour le développement local, le système de configuration lit la chaîne de connexion à partir du fichier appsettings.json.
Tester l’application
Exécutez l’application et ajoutez /Movies à l’URL dans le navigateur (http://localhost:port/movies).
Si vous voyez le message d’erreur suivant :
SqlException: Cannot open database "RazorPagesMovieContext-GUID" requested by the login. The login failed.
Login failed for user 'User-name'.
Vous ne pourrez peut-être pas entrer de virgules décimales dans le champ Price. Pour prendre en charge la validation jQuery pour les paramètres régionaux autres que « Anglais » qui utilisent une virgule (« , ») comme décimale et des formats de date autres que le format « Anglais (États-Unis »), l’application doit être localisée. Pour obtenir des instructions sur la localisation, consultez ce problème GitHub.
Testez les liens Modifier, Détails et Supprimer.
Le prochain didacticiel décrit les fichiers créés par la génération de modèles automatique.
Examiner le contexte inscrit avec l’injection de dépendances
ASP.NET Core comprend l’injection de dépendances. Des services, tels que le contexte de base de données EF Core, sont inscrits avec l’injection de dépendance au démarrage de l’application. Ces services sont affectés aux composants qui les nécessitent (par exemple les Pages Razor) par le biais de paramètres de constructeur. Le code de constructeur qui obtient une instance de contexte de base de données est indiqué plus loin dans le tutoriel.
L’outil de génération de modèles automatique a créé automatiquement un contexte de base de données et l’a inscrit dans le conteneur d’injection de dépendances. Le code mis en surbrillance suivant est ajouté au fichier Program.cs par le générateur de modèles :
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Dans ce tutoriel, des classes sont ajoutées pour la gestion des films dans une base de données. Les classes de modèle de l’application utilisent Entity Framework Core (EF Core) pour travailler avec la base de données. EF Core est un mappeur relationnel d’objets (O/RM) qui simplifie l’accès aux données. Vous écrivez d’abord les classes du modèle, puis EF Core crée la base de données.
Les classes de modèle portent le nom de classes OCT (« Objet CLR Traditionnel »), car elles n’ont pas de dépendances envers EF Core. Elles définissent les propriétés des données stockées dans la base de données.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet RazorPagesMovie >Ajouter>Nouveau dossier. Nommez le dossier Models.
Cliquez avec le bouton droit sur le dossier Models. Sélectionnez Ajouter>Classe. Nommez la classe Movie.
Ajoutez les propriétés suivantes à la classe Movie :
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; } = string.Empty;
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; } = string.Empty;
public decimal Price { get; set; }
}
}
La classe Movie contient :
Le champ ID est nécessaire à la base de données pour la clé primaire.
Attribut [DataType] qui spécifie le type de données dans la propriété ReleaseDate. Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
Ajoutez un dossier nommé Models.
Ajoutez une classe au dossier Models nommé Movie.cs.
Ajoutez les propriétés suivantes à la classe Movie :
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; } = string.Empty;
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; } = string.Empty;
public decimal Price { get; set; }
}
}
La classe Movie contient :
Champ ID permettant de fournir une clé primaire pour la base de données.
Attribut [DataType] pour spécifier le type de données dans le champ ReleaseDate. Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
Le fournisseur EF Core SQLite, qui installe le package EF Core comme une dépendance.
Les packages nécessaires à la génération de modèles automatique : Microsoft.VisualStudio.Web.CodeGeneration.Design et Microsoft.EntityFrameworkCore.SqlServer.
Pour obtenir de l’aide sur la configuration de plusieurs environnements qui permet à une application de configurer ses contextes de base de données par environnement, consultez Utiliser plusieurs environnements dans ASP.NET Core.
Remarque
Par défaut, l’architecture des fichiers binaires .NET à installer représente l’architecture du système d’exploitation en cours d’exécution. Pour spécifier une architecture de système d’exploitation différente, consultez dotnet tool install, --arch option.
Pour plus d'informations, consultez le problème GitHub dotnet/AspNetCore.Docs n° 29262.
Dans la fenêtre Outil solution, cliquez avec le bouton droit sur le projet RazorPagesMovie, puis sélectionnez Ajouter un>nouveau dossier.... Nommez le dossier Models.
Cliquez avec le bouton droit sur le dossier Models, puis sélectionnez Ajouter>Nouveau fichier.
Dans la boîte de dialogue Nouveau fichier :
Dans le volet gauche, sélectionnez Général.
Dans le volet central, sélectionnez Classe vide.
Nommez la classe Movie, puis sélectionnez Créer.
Ajoutez les propriétés suivantes à la classe Movie :
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; } = string.Empty;
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; } = string.Empty;
public decimal Price { get; set; }
}
}
La classe Movie contient :
Champ ID permettant de fournir une clé primaire pour la base de données.
Attribut [DataType] pour spécifier le type de données dans le champ ReleaseDate. Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Générez le projet pour vérifier qu’il n’y a pas d’erreur de compilation.
Générer automatiquement le modèle de film
Dans cette section, le modèle de film est généré automatiquement. Autrement dit, l’outil de génération de modèles automatique génère des pages pour les opérations de création, de lecture, de mise à jour et de suppression (CRUD) pour le modèle de film.
Ajoutez le package NuGet Microsoft.EntityFrameworkCore.Design, qui est requis pour l’outil de génération de modèles automatique.
Dans le menu Outils, sélectionnez Gestionnaire de package NuGet>Gérer les packages NuGet pour la solution.
Sélectionnez l’onglet Parcourir.
Saisissez Microsoft.EntityFrameworkCore.Design, et sélectionnez-le dans la liste.
Cochez Projet, puis sélectionnez Installer
Sélectionnez J’accepte dans la boîte de dialogue Acceptation de licence.
Créez le dossier Pages/Movies :
Cliquez avec le bouton droit sur le dossier Pages >Ajouter>Nouveau dossier.
Nommez le dossier Movies.
Cliquez avec le bouton droit sur le dossier Pages/Movies >Ajouter>Nouvel élément généré automatiquement.
Dans la boîte de dialogue Ajouter un nouveau modèle automatique, sélectionnez Pages Razor utilisant Entity Framework (CRUD)>Ajouter.
Renseignez la boîte de dialogue Ajouter des pages Razor avec Entity Framework (CRUD) :
Dans la liste déroulante Classe de modèle, sélectionnez Film (RazorPagesMovie.Models).
Dans la ligne Classe du contexte de données, sélectionnez le signe + (plus).
Dans la boîte de dialogue Ajouter un contexte de données, le nom de la classe RazorPagesMovie.Data.RazorPagesMovieContext est généré.
Sélectionnez Ajouter.
Si vous recevez un message d’erreur indiquant que vous devez installer le package Microsoft.EntityFrameworkCore.SqlServer, répétez les étapes commençant par Ajouter>Nouvel élément généré automatiquement.
Le fichier appsettings.json est mis à jour avec la chaîne de connexion utilisée pour se connecter à une base de données locale.
Ouvrez un interpréteur de commandes dans le répertoire du projet, qui contient les fichiers Program.cs et .csproj. Exécutez la commande suivante :
Utiliser SQLite pour le développement, SQL Server pour la production
Lorsque SQLite est sélectionné, le code généré par le modèle est prêt pour le développement. Le code suivant montre comment sélectionner la chaîne de connexion SQLite dans le développement et SQL Server dans la production.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Le code précédent n’appelle pas UseDeveloperExceptionPage dans le développement, car WebApplication appelle UseDeveloperExceptionPage en mode développement.
Créer un dossier Pages/Movies :
Cliquez avec le bouton droit sur le dossier Pages >Ajouter>Nouveau dossier.
Nommez le dossier Movies.
Cliquez avec le bouton droit sur le dossier Pages/Movies >Ajouter>Nouvelle génération de modèles automatique....
Dans la boîte de dialogue Nouvelle génération de modèles automatique, sélectionnez Pages Razor utilisant Entity Framework (CRUD)>Ajouter.
Renseignez la boîte de dialogue Ajouter des pages Razor avec Entity Framework (CRUD) :
Dans la ligne classe de modèle à utiliser :, entrez Movie.
Dans la ligne classe DbContext à utiliser :, nommez la classe RazorPagesMovie.Data.RazorPagesMovieContext.
Sélectionnez Terminer.
Le fichier appsettings.json est mis à jour avec la chaîne de connexion utilisée pour se connecter à une base de données locale.
Utiliser SQLite pour le développement, SQL Server pour la production
Lorsque SQLite est sélectionné, le code généré par le modèle est prêt pour le développement. Le code suivant montre comment sélectionner la chaîne de connexion SQLite dans le développement et SQL Server dans la production.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Le code précédent n’appelle pas UseDeveloperExceptionPage dans le développement, car WebApplication appelle UseDeveloperExceptionPage en mode développement.
Fichiers créés et mis à jour
Le processus de génération de modèles automatique crée les fichiers suivants :
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Les modifications Program.cs sont expliquées plus loin dans ce tutoriel.
Créer le schéma de base de données initial à l’aide de la fonctionnalité de migration d’EF
La fonctionnalité de migration dans Entity Framework Core permet de :
Créer le schéma de base de données initial.
Mettre à jour de façon incrémentielle le schéma de base de données afin de le garder synchronisé avec le modèle de données de l’application. Les données existantes dans la base de données sont conservées.
Dans cette section, la fenêtre Console du gestionnaire de package est utilisée pour :
Ajouter une migration initiale
Mettez à jour la base de données avec la migration initiale.
Dans le menu Outils, sélectionnez Gestionnaire de package NuGet>Console du gestionnaire de package.
Dans la console du Gestionnaire de package, entrez les commandes suivantes :
Add-Migration InitialCreate
Update-Database
Dans la fenêtre Outil solution, cliquez avec le bouton droit sur le projet RazorPagesMovie, puis sélectionnez Ouvrir dans le terminal.
La fenêtre Terminal s’ouvre avec l’invite de commandes dans le répertoire du projet, qui contient les fichiers Program.cs et .csproj.
Exécutez les commandes CLI .NET suivantes :
dotnet tool install --global dotnet-ef
dotnet ef migrations add InitialCreate
dotnet ef database update
Remarque
Par défaut, l’architecture des fichiers binaires .NET à installer représente l’architecture du système d’exploitation en cours d’exécution. Pour spécifier une architecture de système d’exploitation différente, consultez dotnet tool install, --arch option.
Pour plus d'informations, consultez le problème GitHub dotnet/AspNetCore.Docs n° 29262.
Remarque
Pour SQLite, le type de colonne pour le champ Price est défini sur TEXT. Cela sera résolu dans une étape ultérieure.
Les commandes précédentes installent les outils Entity Framework Core et exécutent la commande migrations pour générer du code qui crée le schéma de base de données initial.
L’avertissement suivant s’affiche et sera traité dans une étape ultérieure :
Aucun type n’a été spécifié pour la colonne décimale 'Price' sur le type d’entité 'Movie'. Les valeurs sont tronquées en mode silencieux si elles ne sont pas compatibles avec la précision et l’échelle par défaut. Spécifiez explicitement le type de colonne SQL Server capable d’accueillir toutes les valeurs en utilisant ’HasColumnType()’.
La commande migrations génère le code nécessaire à la création du schéma de base de données initial. Le schéma est basé sur le modèle spécifié dans DbContext. L’argument InitialCreate est utilisé pour nommer les migrations. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné.
La commande update exécute la méthode Up dans des migrations qui n’ont pas été appliquées. Dans ce cas, la commande update exécute la méthode Up dans le fichier Migrations/<time-stamp>_InitialCreate.cs, ce qui entraîne la création de la base de données.
Examiner le contexte inscrit avec l’injection de dépendances
ASP.NET Core comprend l’injection de dépendances. Des services, tels que le contexte de base de données EF Core, sont inscrits avec l’injection de dépendance au démarrage de l’application. Ces services sont affectés aux composants qui les nécessitent (par exemple les Pages Razor) par le biais de paramètres de constructeur. Le code de constructeur qui obtient une instance de contexte de base de données est indiqué plus loin dans le tutoriel.
L’outil de génération de modèles automatique a créé automatiquement un contexte de base de données et l’a inscrit dans le conteneur d’injection de dépendances. Le code mis en surbrillance suivant est ajouté au fichier Program.cs par le générateur de modèles :
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Spécifie les entités qui sont incluses dans le modèle de données.
Coordonne les fonctionnalités EF Core, telles que Créer, Lire, Mettre à jour et Supprimer, pour le modèle Movie.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using RazorPagesMovie.Models;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie>? Movie { get; set; }
}
}
Le code précédent crée une propriété DbSet<Movie> pour le jeu d’entités. Dans la terminologie Entity Framework, un jeu d’entités correspond généralement à une table de base de données. Une entité correspond à une ligne dans la table.
Le nom de la chaîne de connexion est transmis au contexte en appelant une méthode sur un objet DbContextOptions. Pour le développement local, le système de configuration lit la chaîne de connexion à partir du fichier appsettings.json.
Tester l’application
Exécutez l’application et ajoutez /Movies à l’URL dans le navigateur (http://localhost:port/movies).
Si vous voyez le message d’erreur suivant :
SqlException: Cannot open database "RazorPagesMovieContext-GUID" requested by the login. The login failed.
Login failed for user 'User-name'.
Vous ne pourrez peut-être pas entrer de virgules décimales dans le champ Price. Pour prendre en charge la validation jQuery pour les paramètres régionaux autres que « Anglais » qui utilisent une virgule (« , ») comme décimale et des formats de date autres que le format « Anglais (États-Unis »), l’application doit être localisée. Pour obtenir des instructions sur la localisation, consultez ce problème GitHub.
Testez les liens Modifier, Détails et Supprimer.
Le prochain didacticiel décrit les fichiers créés par la génération de modèles automatique.
Dans cette section, des classes sont ajoutées pour la gestion des films dans une base de données. Les classes de modèle de l’application utilisent Entity Framework Core (EF Core) pour travailler avec la base de données. EF Core est un mappeur relationnel d’objets (O/RM) qui simplifie l’accès aux données. Vous écrivez d’abord les classes du modèle, puis EF Core crée la base de données.
Les classes de modèle portent le nom de classes OCT (« Objet CLR Traditionnel »), car elles n’ont pas de dépendances envers EF Core. Elles définissent les propriétés des données stockées dans la base de données.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet RazorPagesMovie >Ajouter>Nouveau dossier. Nommez le dossier Models.
Cliquez avec le bouton droit sur le dossier Models. Sélectionnez Ajouter>Classe. Nommez la classe Movie.
Ajoutez les propriétés suivantes à la classe Movie :
using System;
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}
La classe Movie contient :
Le champ ID est nécessaire à la base de données pour la clé primaire.
[DataType(DataType.Date)] : l’attribut [DataType] spécifie le type de données (Date). Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
Ajoutez un dossier nommé Models.
Ajoutez une classe au dossier Models nommé Movie.cs.
Ajoutez les propriétés suivantes à la classe Movie :
using System;
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}
La classe Movie contient :
Le champ ID est nécessaire à la base de données pour la clé primaire.
[DataType(DataType.Date)] : l’attribut [DataType] spécifie le type de données (Date). Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
Le fournisseur EF Core SQLite, qui installe le package EF Core comme une dépendance.
Les packages nécessaires à la génération de modèles automatique : Microsoft.VisualStudio.Web.CodeGeneration.Design et Microsoft.EntityFrameworkCore.SqlServer.
Pour obtenir de l’aide sur la configuration de plusieurs environnements qui permet à une application de configurer ses contextes de base de données par environnement, consultez Utiliser plusieurs environnements dans ASP.NET Core.
Remarque
Par défaut, l’architecture des fichiers binaires .NET à installer représente l’architecture du système d’exploitation en cours d’exécution. Pour spécifier une architecture de système d’exploitation différente, consultez dotnet tool install, --arch option.
Pour plus d'informations, consultez le problème GitHub dotnet/AspNetCore.Docs n° 29262.
Si vous obtenez une erreur de structure, vérifiez que le moniker de framework cible (TFM) correspond à la version du package NuGet dans le fichier projet. Par exemple, le fichier de projet suivant utilise la version 5.0 pour .NET et les packages NuGet répertoriés :
Dans la fenêtre Outil solution, cliquez sur le projet RazorPagesMovie, puis sélectionnez Ajouter un>nouveau dossier.... Nommez le dossier Models.
Cliquez sur le dossier Models, puis sélectionnez Ajouter>Nouveau fichier....
Dans la boîte de dialogue Nouveau fichier :
Dans le volet gauche, sélectionnez Général.
Dans le volet central, sélectionnez Classe vide.
Nommez la classe Movie, puis sélectionnez Nouveau.
Ajoutez les propriétés suivantes à la classe Movie :
using System;
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}
La classe Movie contient :
Le champ ID est nécessaire à la base de données pour la clé primaire.
[DataType(DataType.Date)] : l’attribut [DataType] spécifie le type de données (Date). Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Générez le projet pour vérifier qu’il n’y a pas d’erreur de compilation.
Générer automatiquement le modèle de film
Dans cette section, le modèle de film est généré automatiquement. Autrement dit, l’outil de génération de modèles automatique génère des pages pour les opérations de création, de lecture, de mise à jour et de suppression (CRUD) pour le modèle de film.
Cliquez avec le bouton droit sur le dossier Pages >Ajouter>Nouveau dossier.
Nommez le dossier Movies.
Cliquez avec le bouton droit sur le dossier Pages/Movies >Ajouter>Nouvel élément généré automatiquement.
Dans la boîte de dialogue Ajouter une génération de modèles automatique, sélectionnez Pages Razor utilisant Entity Framework (CRUD)>Ajouter.
Renseignez la boîte de dialogue Ajouter des pages Razor avec Entity Framework (CRUD) :
Dans la liste déroulante Classe de modèle, sélectionnez Film (RazorPagesMovie.Models).
Dans la ligne Classe du contexte de données, sélectionnez le signe + (plus).
Dans la boîte de dialogue Ajouter un contexte de données, le nom de la classe RazorPagesMovie.Data.RazorPagesMovieContext est généré.
Sélectionnez Ajouter.
Le fichier appsettings.json est mis à jour avec la chaîne de connexion utilisée pour se connecter à une base de données locale.
Ouvrez un interpréteur de commandes dans le répertoire du projet, qui contient les fichiers Program.cs, Startup.cs et .csproj. Exécutez la commande suivante :
Utiliser SQLite pour le développement, SQL Server pour la production
Lorsque SQLite est sélectionné, le code généré par le modèle est prêt pour le développement. Le code suivant montre comment injecter IWebHostEnvironment dans Startup. IWebHostEnvironment est injecté donc ConfigureServices peut utiliser SQLite dans le développement et SQL Server en production.
public class Startup
{
public Startup(IConfiguration configuration, IWebHostEnvironment env)
{
Environment = env;
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public IWebHostEnvironment Environment { get; }
public void ConfigureServices(IServiceCollection services)
{
if (Environment.IsDevelopment())
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(
Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("MovieContext")));
}
services.AddRazorPages();
}
public void Configure(IApplicationBuilder app)
{
if (Environment.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
}
}
Créer un dossier Pages/Movies :
Cliquez avec le bouton droit sur le dossier Pages >Ajouter>Nouveau dossier.
Nommez le dossier Movies.
Cliquez sur le dossier Pages/Movies >Ajouter>Nouvelle génération de modèles automatique....
Dans la boîte de dialogue Nouvelle génération de modèles automatique, sélectionnez Pages Razor utilisant Entity Framework (CRUD)>Ajouter.
Renseignez la boîte de dialogue Ajouter des pages Razor avec Entity Framework (CRUD) :
Dans la ligne classe DbContext à utiliser :, nommez la classe RazorPagesMovie.Data.RazorPagesMovieContext.
Sélectionnez Terminer.
Le fichier appsettings.json est mis à jour avec la chaîne de connexion utilisée pour se connecter à une base de données locale.
Utiliser SQLite pour le développement, SQL Server pour la production
Lorsque SQLite est sélectionné, le code généré par le modèle est prêt pour le développement. Le code suivant montre comment injecter IWebHostEnvironment dans Startup. IWebHostEnvironmentest injecté et ConfigureServices peut donc utiliser SQLite dans le développement et SQL Server dans la production.
public class Startup
{
public Startup(IConfiguration configuration, IWebHostEnvironment env)
{
Environment = env;
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public IWebHostEnvironment Environment { get; }
public void ConfigureServices(IServiceCollection services)
{
if (Environment.IsDevelopment())
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(
Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("MovieContext")));
}
services.AddRazorPages();
}
public void Configure(IApplicationBuilder app)
{
if (Environment.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
}
}
Fichiers créés et mis à jour
Le processus de génération de modèles automatique crée les fichiers suivants :
Les fichiers créés et mis à jour sont expliqués dans la section suivante.
Créer le schéma de base de données initial à l’aide de la fonctionnalité de migration d’EF
La fonctionnalité de migration dans Entity Framework Core permet de :
Créer le schéma de base de données initial.
Mettre à jour de façon incrémentielle le schéma de base de données afin de le garder synchronisé avec le modèle de données de l’application. Les données existantes dans la base de données sont conservées.
Dans cette section, la fenêtre Console du gestionnaire de package est utilisée pour :
Ajouter une migration initiale
Mettez à jour la base de données avec la migration initiale.
Dans le menu Outils, sélectionnez Gestionnaire de package NuGet>Console du gestionnaire de package.
Dans la console du Gestionnaire de package, entrez les commandes suivantes :
Add-Migration InitialCreate
Update-Database
Exécutez les commandes CLI .NET suivantes :
dotnet ef migrations add InitialCreate
dotnet ef database update
Remarque
Pour SQLite, le type de colonne pour le champ Price est défini sur TEXT. Cela sera résolu dans une étape ultérieure.
Pour SQL Server, les commandes précédentes génèrent l’avertissement suivant : « Aucun type n’a été spécifié pour la colonne décimale 'Price' sur le type d’entité 'Movie'. Les valeurs sont tronquées en mode silencieux si elles ne sont pas compatibles avec la précision et l’échelle par défaut. Spécifiez explicitement le type de colonne SQL Server capable d’accueillir toutes les valeurs en utilisant 'HasColumnType()'. »
Ignorez l’avertissement, car il sera traité dans une étape ultérieure.
La commande migrations génère le code nécessaire à la création du schéma de base de données initial. Le schéma est basé sur le modèle spécifié dans DbContext. L’argument InitialCreate est utilisé pour nommer les migrations. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné.
La commande update exécute la méthode Up dans des migrations qui n’ont pas été appliquées. Dans ce cas, la commande update exécute la méthode Up dans le fichier Migrations/<time-stamp>_InitialCreate.cs, ce qui entraîne la création de la base de données.
Examiner le contexte inscrit avec l’injection de dépendances
ASP.NET Core comprend l’injection de dépendances. Des services, tels que le contexte de base de données EF Core, sont inscrits avec l’injection de dépendance au démarrage de l’application. Ces services sont affectés aux composants qui les nécessitent (par exemple les Pages Razor) par le biais de paramètres de constructeur. Le code de constructeur qui obtient une instance de contexte de base de données est indiqué plus loin dans le tutoriel.
L’outil de génération de modèles automatique a créé automatiquement un contexte de base de données et l’a inscrit dans le conteneur d’injection de dépendances.
Examinez la méthode Startup.ConfigureServices. La ligne en surbrillance a été ajoutée par l’outil de génération de modèles automatique :
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages();
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("RazorPagesMovieContext")));
}
Le RazorPagesMovieContext coordonne les fonctionnalités EF Core, telles que Créer, Lire, Mettre à jour et Supprimer, pour le modèle Movie. Le contexte de données (RazorPagesMovieContext) est dérivé de Microsoft.EntityFrameworkCore.DbContext. Il spécifie les entités qui sont incluses dans le modèle de données.
using Microsoft.EntityFrameworkCore;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (
DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie> Movie { get; set; }
}
}
Le code précédent crée une propriété DbSet<Movie> pour le jeu d’entités. Dans la terminologie Entity Framework, un jeu d’entités correspond généralement à une table de base de données. Une entité correspond à une ligne dans la table.
Le nom de la chaîne de connexion est transmis au contexte en appelant une méthode sur un objet DbContextOptions. Pour le développement local, le système de configuration lit la chaîne de connexion à partir du fichier appsettings.json.
Examinez la méthode Up.
Tester l’application
Exécutez l’application et ajoutez /Movies à l’URL dans le navigateur (http://localhost:port/movies).
Si vous voyez le message d’erreur suivant :
SqlException: Cannot open database "RazorPagesMovieContext-GUID" requested by the login. The login failed.
Login failed for user 'User-name'.
Vous ne pourrez peut-être pas entrer de virgules décimales dans le champ Price. Pour prendre en charge la validation jQuery pour les paramètres régionaux autres que « Anglais » qui utilisent une virgule (« , ») comme décimale et des formats de date autres que le format « Anglais (États-Unis »), l’application doit être localisée. Pour obtenir des instructions sur la localisation, consultez ce problème GitHub.
Testez les liens Modifier, Détails et Supprimer.
Journalisation SQL d’Entity Framework Core
La configuration de la journalisation est généralement fournie par la section Logging des fichiers appsettings.{Environment}.json. Pour journaliser les instructions SQL, ajoutez "Microsoft.EntityFrameworkCore.Database.Command": "Information" au fichier appsettings.Development.json :
Dans cette section, des classes sont ajoutées pour la gestion des films. Les classes de modèle de l’application utilisent Entity Framework Core (EF Core) pour travailler avec la base de données. EF Core est un mappeur relationnel d’objets (O/RM) qui simplifie l’accès aux données.
Les classes de modèle portent le nom de classes OCT (« Objet CLR Traditionnel »), car elles n’ont pas de dépendances envers EF Core. Elles définissent les propriétés des données stockées dans la base de données.
Cliquez avec le bouton droit sur le projet RazorPagesMovie >Ajouter>Nouveau dossier. Nommez le dossier Models.
Cliquez avec le bouton droit sur le dossier Models. Sélectionnez Ajouter>Classe. Nommez la classe Movie.
Ajoutez les propriétés suivantes à la classe Movie :
using System;
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}
La classe Movie contient :
Le champ ID est nécessaire à la base de données pour la clé primaire.
[DataType(DataType.Date)] : L’attribut DataType spécifie le type de données (Date). Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Ajoutez un dossier nommé Models.
Ajoutez une classe au dossier Models nommé Movie.cs.
Ajoutez les propriétés suivantes à la classe Movie :
using System;
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}
La classe Movie contient :
Le champ ID est nécessaire à la base de données pour la clé primaire.
[DataType(DataType.Date)] : L’attribut DataType spécifie le type de données (Date). Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Les outils Entity Framework Core pour la CLI .NET.
Le fournisseur EF Core SQLite, qui installe le package EF Core comme une dépendance.
Les packages nécessaires à la génération de modèles automatique : Microsoft.VisualStudio.Web.CodeGeneration.Design et Microsoft.EntityFrameworkCore.SqlServer.
Pour obtenir de l’aide sur la configuration de plusieurs environnements qui permet à une application de configurer ses contextes de base de données par environnement, consultez Utiliser plusieurs environnements dans ASP.NET Core.
Remarque
Par défaut, l’architecture des fichiers binaires .NET à installer représente l’architecture du système d’exploitation en cours d’exécution. Pour spécifier une architecture de système d’exploitation différente, consultez dotnet tool install, --arch option.
Pour plus d'informations, consultez le problème GitHub dotnet/AspNetCore.Docs n° 29262.
Si vous obtenez une erreur de structure, vérifiez que le moniker de framework cible (TFM) correspond à la version du package NuGet dans le fichier projet. Par exemple, le fichier projet suivant contient la version 3.1 pour .NET Core et les packages NuGet répertoriés :
Dans le projet RazorPagesMovie, créez un nouveau dossier nommé Data.
Ajoutez la classe RazorPagesMovieContext suivante au dossier Data :
using Microsoft.EntityFrameworkCore;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (
DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie> Movie { get; set; }
}
}
Le code précédent crée une propriété DbSet pour le jeu d’entités. Dans la terminologie Entity Framework, un jeu d’entités correspond généralement à une table de base de données, et une entité correspond à une ligne dans la table. Le code ne sera pas compilé tant que les dépendances n’auront pas été ajoutées à une étape ultérieure.
Ajouter une chaîne de connexion de base de données
Ajoutez une chaîne de connexion au fichier appsettings.json comme indiqué dans le code en surbrillance suivant :
En tête du Startup.cs, ajoutez les instructions using suivantes :
using RazorPagesMovie.Data;
using Microsoft.EntityFrameworkCore;
Inscrivez le contexte de base de données auprès du conteneur d’injection de dépendances dans Startup.ConfigureServices.
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages();
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(Configuration.GetConnectionString("RazorPagesMovieContext")));
}
Dans la fenêtre Outil solution, cliquez sur le projet RazorPagesMovie, puis sélectionnez Ajouter un>nouveau dossier.... Nommez le dossier Models.
Cliquez avec le bouton droit sur le dossier Models, puis sélectionnez Ajouter>Nouveau fichier.
Dans la boîte de dialogue Nouveau fichier :
Dans le volet gauche, sélectionnez Général.
Dans le volet central, sélectionnez Classe vide.
Nommez la classe Movie, puis sélectionnez Nouveau.
Ajoutez les propriétés suivantes à la classe Movie :
using System;
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}
La classe Movie contient :
Le champ ID est nécessaire à la base de données pour la clé primaire.
[DataType(DataType.Date)] : L’attribut DataType spécifie le type de données (Date). Avec cet attribut :
L’utilisateur n’est pas obligé d’entrer les informations de temps dans le champ de date.
Seule la date est affichée, pas les informations de temps.
Les DataAnnotations sont traitées dans un prochain didacticiel.
Générez le projet pour vérifier qu’il n’y a pas d’erreur de compilation.
Générer automatiquement le modèle de film
Dans cette section, le modèle de film est généré automatiquement. Autrement dit, l’outil de génération de modèles automatique génère des pages pour les opérations de création, de lecture, de mise à jour et de suppression (CRUD) pour le modèle de film.
Cliquez avec le bouton droit sur le dossier Pages >Ajouter>Nouveau dossier.
Nommez le dossier Movies.
Cliquez avec le bouton droit sur le dossier Pages/Movies >Ajouter>Nouvel élément généré automatiquement.
Dans la boîte de dialogue Ajouter une génération de modèles automatique, sélectionnez Pages Razor utilisant Entity Framework (CRUD)>Ajouter.
Renseignez la boîte de dialogue Ajouter des pages Razor avec Entity Framework (CRUD) :
Dans la liste déroulante Classe de modèle, sélectionnez Film (RazorPagesMovie.Models).
Dans la ligne Classe du contexte de données, sélectionnez le signe (plus) + et changez le nom généré à partir de RazorPagesMovie.Models.RazorPagesMovieContext vers RazorPagesMovie.Data.RazorPagesMovieContext. Cette modification n'est pas requise. Elle crée la classe de contexte de base de données avec l’espace de noms correct.
Sélectionnez Ajouter.
Le fichier appsettings.json est mis à jour avec la chaîne de connexion utilisée pour se connecter à une base de données locale.
Ouvrez une fenêtre de commandes dans le répertoire du projet, qui contient les fichiers Program.cs, Startup.cs et .csproj.
Utiliser SQLite pour le développement, SQL Server pour la production
Lorsque SQLite est sélectionné, le code généré par le modèle est prêt pour le développement. Le code suivant montre comment injecter IWebHostEnvironment dans Start-up. IWebHostEnvironment est injecté donc ConfigureServices peut utiliser SQLite dans le développement et SQL Server en production.
public class Startup
{
public Startup(IConfiguration configuration, IWebHostEnvironment env)
{
Environment = env;
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public IWebHostEnvironment Environment { get; }
public void ConfigureServices(IServiceCollection services)
{
if (Environment.IsDevelopment())
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(
Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("MovieContext")));
}
services.AddRazorPages();
}
public void Configure(IApplicationBuilder app)
{
if (Environment.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
}
}
Créer un dossier Pages/Movies :
Cliquez avec le bouton droit sur le dossier Pages >Ajouter>Nouveau dossier.
Nommez le dossier Movies.
Cliquez avec le bouton droit sur le dossier Pages/Movies >Ajouter>Nouvelle génération de modèles automatique....
Dans la boîte de dialogue Nouvelle génération de modèles automatique, sélectionnez Pages Razor utilisant Entity Framework (CRUD)>Ajouter.
Renseignez la boîte de dialogue Ajouter des pages Razor avec Entity Framework (CRUD) :
Dans la liste déroulante Classe de modèle, sélectionnez ou entrez Movie (RazorPagesMovie.Models).
Dans la ligne Classe de contexte de données, tapez le nom de la nouvelle classe, RazorPagesMovie.Données.RazorPagesMovieContext. Cette modification n'est pas requise. Elle crée la classe de contexte de base de données avec l’espace de noms correct.
Sélectionnez Ajouter.
Le fichier appsettings.json est mis à jour avec la chaîne de connexion utilisée pour se connecter à une base de données locale.
Par défaut, l’architecture des fichiers binaires .NET à installer représente l’architecture du système d’exploitation en cours d’exécution. Pour spécifier une architecture de système d’exploitation différente, consultez dotnet tool install, --arch option.
Pour plus d'informations, consultez le problème GitHub dotnet/AspNetCore.Docs n° 29262.
Utiliser SQLite pour le développement, SQL Server pour la production
Lorsque SQLite est sélectionné, le code généré par le modèle est prêt pour le développement. Le code suivant montre comment injecter IWebHostEnvironment dans Start-up. IWebHostEnvironment est injecté donc ConfigureServices peut utiliser SQLite dans le développement et SQL Server en production.
public class Startup
{
public Startup(IConfiguration configuration, IWebHostEnvironment env)
{
Environment = env;
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public IWebHostEnvironment Environment { get; }
public void ConfigureServices(IServiceCollection services)
{
if (Environment.IsDevelopment())
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(
Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("MovieContext")));
}
services.AddRazorPages();
}
public void Configure(IApplicationBuilder app)
{
if (Environment.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
}
}
Par défaut, l’architecture des fichiers binaires .NET à installer représente l’architecture du système d’exploitation en cours d’exécution. Pour spécifier une architecture de système d’exploitation différente, consultez dotnet tool install, --arch option.
Pour plus d'informations, consultez le problème GitHub dotnet/AspNetCore.Docs n° 29262.
Exécutez les commandes CLI .NET suivantes :
dotnet ef migrations add InitialCreate
dotnet ef database update
Les commandes précédentes génèrent l’avertissement suivant : « Aucun type n’a été spécifié pour la colonne décimale 'Price' sur le type d’entité 'Movie'. Les valeurs sont tronquées en mode silencieux si elles ne sont pas compatibles avec la précision et l’échelle par défaut. Spécifiez explicitement le type de colonne SQL Server capable d’accueillir toutes les valeurs en utilisant 'HasColumnType()'. »
Ignorez l’avertissement, car il sera traité dans une étape ultérieure.
La commande de migrations génère le code nécessaire à la création du schéma de base de données initial. Le schéma est basé sur le modèle spécifié dans DbContext. L’argument InitialCreate est utilisé pour nommer les migrations. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné.
La commande update exécute la méthode Up dans des migrations qui n’ont pas été appliquées. Dans ce cas, update exécute la méthode Up dans le fichier Migrations/<time-stamp>_InitialCreate.cs, ce qui entraîne la création de la base de données.
Examiner le contexte inscrit avec l’injection de dépendances
ASP.NET Core comprend l’injection de dépendances. Des services, tels que le contexte de base de données EF Core, sont inscrits avec l’injection de dépendance au démarrage de l’application. Les composants qui nécessitent ces services, par exemple les pages Razor, sont fournis par le biais de paramètres de constructeur. Le code de constructeur qui obtient une instance de contexte de base de données est indiqué plus loin dans le tutoriel.
L’outil de génération de modèles automatique a créé automatiquement un contexte de base de données et l’a inscrit dans le conteneur d’injection de dépendances.
Examinez la méthode Startup.ConfigureServices. La ligne en surbrillance a été ajoutée par l’outil de génération de modèles automatique :
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages();
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("RazorPagesMovieContext")));
}
Le RazorPagesMovieContext coordonne les fonctionnalités EF Core, telles que Créer, Lire, Mettre à jour et Supprimer, pour le modèle Movie. Le contexte de données (RazorPagesMovieContext) est dérivé de Microsoft.EntityFrameworkCore.DbContext. Il spécifie les entités qui sont incluses dans le modèle de données.
using Microsoft.EntityFrameworkCore;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (
DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie> Movie { get; set; }
}
}
Le code précédent crée une propriété DbSet<Movie> pour le jeu d’entités. Dans la terminologie Entity Framework, un jeu d’entités correspond généralement à une table de base de données. Une entité correspond à une ligne dans la table.
Le nom de la chaîne de connexion est transmis au contexte en appelant une méthode sur un objet DbContextOptions. Pour le développement local, le système de configuration lit la chaîne de connexion à partir du fichier appsettings.json.
Examinez la méthode Up.
Tester l’application
Exécutez l’application et ajoutez /Movies à l’URL dans le navigateur (http://localhost:port/movies).
Si vous obtenez l’erreur :
SqlException: Cannot open database "RazorPagesMovieContext-GUID" requested by the login. The login failed.
Login failed for user 'User-name'.
Vous ne pourrez peut-être pas entrer de virgules décimales dans le champ Price. Pour prendre en charge la validation jQuery pour les paramètres régionaux autres que « Anglais » qui utilisent une virgule (« , ») comme décimale et des formats de date autres que le format « Anglais (États-Unis »), l’application doit être localisée. Pour obtenir des instructions sur la localisation, consultez ce problème GitHub.
Testez les liens Modifier, Détails et Supprimer.
Le prochain didacticiel décrit les fichiers créés par la génération de modèles automatique.
La source de ce contenu se trouve sur GitHub, où vous pouvez également créer et examiner les problèmes et les demandes de tirage (pull requests). Pour plus d’informations, consultez notre guide du contributeur.
Prochainement : Tout au long de l'année 2024, nous supprimerons progressivement les GitHub Issues en tant que mécanisme de retour d'information pour le contenu et nous les remplacerons par un nouveau système de retour d'information. Pour plus d’informations, voir: https://aka.ms/ContentUserFeedback.