Partie 4, ajouter un modèle dans une application ASP.NET Core MVC

Par Rick Anderson et Jon P Smith.

Dans ce tutoriel, des classes sont ajoutées pour la gestion des films dans une base de données. Ces classes constituent la partie « Modèle » de l’application MVC.

Ces classes de modèle sont utilisées avec Entity Framework Core (EF Core) pour utiliser une base de données. EF Core est une infrastructure de mappage relationnel d’objets qui simplifie le code d’accès aux données à écrire.

Les classes du modèle créées sont appelées classes POCO, à partir de Plain Old CLR Objects. Les classes POCO n’ont aucune dépendance vis-à-vis de EF Core. Elles définissent uniquement les propriétés des données qui seront stockées dans la base de données.

Dans ce tutoriel, les classes du modèle sont d’abord créées, puis EF Core crée la base de données.

Ajouter une classe de modèle de données

Visual Studio

Cliquez avec le bouton droit sur le dossier Modèles >Ajouter>Classe. Nommez le fichier Movie.cs.

Visual Studio Code

Ajoutez un fichier nommé Movie.cs au dossier Modèles.

Mettez à jour le fichier Models/Movie.cs avec le code suivant :

using System.ComponentModel.DataAnnotations;

namespace MvcMovie.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 un champ Id, qui est nécessaire à la base de données pour la clé primaire.

L’attribut DataType de ReleaseDate 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.

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.

Ajouter des packages NuGet

Visual Studio

Visual Studio installe automatiquement les packages requis.

Générez le projet en tant que vérification des erreurs du compilateur.

Visual Studio Code

Exécutez les commandes CLI .NET suivantes :

dotnet tool uninstall --global dotnet-aspnet-codegenerator
dotnet tool install --global dotnet-aspnet-codegenerator
dotnet tool uninstall --global dotnet-ef
dotnet tool install --global dotnet-ef
dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet add package Microsoft.EntityFrameworkCore.SQLite
dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools

Les commandes précédentes ajoutent :

• Outils de l’interface de ligne de commande (CLI) pour EF Core
• Outil de génération de modèles automatique aspnet-codegenerator.
• Outils de temps de conception pour EF Core
• 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.

Générer automatiquement des pages de film

Utilisez l’outil de génération de modèles automatique pour Create, Read, Update, et Delete des pages du modèle de film.

Visual Studio

Cliquez avec le bouton droit sur le dossier Contrôleurs dans l’Explorateur de solutions, puis sélectionnez Ajouter > Nouvel élément généré automatiquement.

Dans la boîte de dialogue Ajouter un nouvel élément de modèle généré automatiquement :

• Dans le volet gauche, sélectionnez Installé>Communes>MVC.
• Sélectionnez Contrôleur MVC avec vues, utilisant Entity Framework.
• Sélectionnez Ajouter.

Terminez la boîte de dialogue Ajouter un contrôleur MVC avec des vues, à l’aide d’Entity Framework :

• Dans la liste déroulante Classe du modèle, sélectionnez Film (MvcMovie.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 classe MvcMovie.Data.MvcMovieContext est généré.
  • Cliquez sur Ajouter.
• Dans la liste déroulante Fournisseur de base de données, sélectionnez SQL Server.
• Vues et Nom du contrôleur : conservez la valeur par défaut.
• Sélectionnez Ajouter.

Si vous obtenez un message d’erreur, sélectionnez Ajouter une deuxième fois pour réessayer.

La génération de modèles automatique ajoute les packages suivants :

• Microsoft.EntityFrameworkCore.SqlServer
• Microsoft.EntityFrameworkCore.Tools
• Microsoft.VisualStudio.Web.CodeGeneration.Design

La génération automatique crée les éléments suivants :

• Un contrôleur de films : Controllers/MoviesController.cs
• Razor afficher les fichiers pour les pages Créer, Supprimer, Détails, Modifier et Indexer : Views/Movies/*.cshtml
• Une classe de contexte de base de données : Data/MvcMovieContext.cs

La génération de modèles automatique met à jour les éléments suivants :

• Insère les références de package requises dans le fichier projet MvcMovie.csproj.
• Inscrit le contexte de base de données dans le fichier Program.cs.
• Ajoute une chaîne de connexion de base de données au fichier appsettings.json.

La création automatique de ces fichiers et mises à jour est appelée génération de modèles automatique.

Les pages générées automatiquement ne peuvent pas encore être utilisées, car la base de données n’existe pas. L’exécution de l’application et la sélection du lien Application vidéo entraînent un message d’erreur Impossible d’ouvrir la base de données ou Le type de table suivant n’existe pas : Film.

Générez l’application pour vérifier qu’il n’y a pas d’erreurs.

Visual Studio Code

Ouvrez une fenêtre de commande dans le répertoire du projet. Le répertoire du projet est le répertoire qui contient les fichiers Program.cs et .csproj.

Sur macOS et Linux, exportez le chemin d’accès de l’outil de génération de modèles automatique :

export PATH=$HOME/.dotnet/tools:$PATH

Exécutez la commande suivante :

dotnet aspnet-codegenerator controller -name MoviesController -m Movie -dc MvcMovie.Data.MvcMovieContext --relativeFolderPath Controllers --useDefaultLayout --referenceScriptLibraries --databaseProvider sqlite

Le tableau suivant détaille les paramètres du générateur de code ASP.NET Core :

Paramètre	Description
-m	Nom du modèle.
-dc	Contexte de données.
--relativeFolderPath	Chemin du dossier de sortie relatif pour créer les fichiers.
--useDefaultLayout|-udl	La disposition par défaut doit être utilisée pour les vues.
--referenceScriptLibraries	Ajoute _ValidationScriptsPartial aux pages Modifier et Créer.
--databaseProvider sqlite	Spécifiez si DbContext doit utiliser SQLite au lieu de SQL Server.

Utilisez le commutateur h pour obtenir de l’aide sur la commande aspnet-codegenerator controller :

dotnet aspnet-codegenerator controller -h

Pour plus d’informations, consultez dotnet aspnet-codegenerator.

La génération automatique crée les éléments suivants :

• Un contrôleur de films : Controllers/MoviesController.cs
• Razor afficher les fichiers pour les pages Créer, Supprimer, Détails, Modifier et Indexer : Views/Movies/*.cshtml
• Une classe de contexte de base de données : Data/MvcMovieContext.cs

La génération de modèles automatique met à jour les éléments suivants :

• Inscrit le contexte de base de données dans le fichier Program.cs
• Ajoute une chaîne de connexion de base de données au fichier appsettings.json.

La création automatique de ces fichiers et mises à jour est appelée génération de modèles automatique.

Les pages générées automatiquement ne peuvent pas encore être utilisées, car la base de données n’existe pas. L’exécution de l’application et la sélection du lien Application vidéo entraînent un message d’erreur Impossible d’ouvrir la base de données ou Le type de table suivant n’existe pas : Film.

Générez l’application pour vérifier qu’il n’y a pas d’erreurs.

Utiliser SQLite pour le développement, SQL Server pour la production

Le code mis en évidence suivant dans Program.cs montre comment utiliser SQLite dans le développement et SQL Server en production.

var builder = WebApplication.CreateBuilder(args);

if (builder.Environment.IsDevelopment())
{
    builder.Services.AddDbContext<MvcMovieContext>(options =>
        options.UseSqlite(builder.Configuration.GetConnectionString("MvcMovieContext")));
}
else
{
    builder.Services.AddDbContext<MvcMovieContext>(options =>
        options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMvcMovieContext")));
}

Migration initiale

Utilisez la fonctionnalité EF CoreMigrations pour créer la base de données. La fonctionnalité Migrations est un ensemble d’outils qui vous permettent de créer et de mettre à jour une base de données pour qu’elle corresponde à votre modèle de données.

Visual Studio

Dans le menu Outils, sélectionnez Gestionnaire de package NuGet>Console du gestionnaire de package.

Dans la console du Gestionnaire de package (PMC), entrez la commande suivante :

Add-Migration InitialCreate

• Add-Migration InitialCreate: Génère un Migrations/{timestamp}_InitialCreate.cs fichier de migration. L’argument InitialCreate est le nom de la migration. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné. Étant donné qu’il s’agit de la première migration, la classe générée contient du code permettant de créer le schéma de la base de données. Le schéma de base de données est basé sur le modèle spécifié dans la classe MvcMovieContext.

L’avertissement suivant s’affiche et sera traité dans une étape ultérieure :

Aucun type de magasin n’a été spécifié pour la propriété 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 qui peut prendre en charge toutes les valeurs dans « OnModelCreating » à l’aide de « HasColumnType », spécifiez la précision et l’échelle à l’aide de « HasPrecision » ou configurez un convertisseur de valeurs à l’aide de « HasConversion ».

Dans la console PMC, entrez la commande suivante :

Update-Database

• Update-Database : Met à jour la base de données vers la dernière migration, qui a été créée par la commande précédente. Cette commande exécute la méthode Up dans le fichier Migrations/{time-stamp}_InitialCreate.cs, qui crée la base de données.

Pour plus d’informations sur les outils de la console du gestionnaire de package pour EF Core, consultez EF Core référence sur les outils - Console du gestionnaire de package dans Visual Studio.

Visual Studio Code

Exécutez la commande CLI .NET suivante :

dotnet ef migrations add InitialCreate

• ef migrations add InitialCreate: Génère un Migrations/{timestamp}_InitialCreate.cs fichier de migration. L’argument InitialCreate est le nom de la migration. Vous pouvez utiliser n’importe quel nom, mais par convention, un nom décrivant la migration est sélectionné. Il s’agit de la première migration, la classe générée contient donc du code permettant de créer le schéma de la base de données. Le schéma de base de données est basé sur le modèle spécifié dans la classe MvcMovieContext, dans le fichier Data/MvcMovieContext.cs.

L’avertissement suivant s’affiche et sera traité dans une étape ultérieure :

Aucun type de magasin n’a été spécifié pour la propriété 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 qui peut prendre en charge toutes les valeurs dans « OnModelCreating » à l’aide de « HasColumnType », spécifiez la précision et l’échelle à l’aide de « HasPrecision » ou configurez un convertisseur de valeurs à l’aide de « HasConversion ».

Exécutez la commande CLI .NET suivante :

dotnet ef database update

• ef database update : Met à jour la base de données vers la dernière migration, qui a été créée par la commande précédente. Cette commande exécute la méthode Up dans le fichier Migrations/{time-stamp}_InitialCreate.cs, qui crée la base de données.

Pour plus d’informations sur la gestion de plusieurs fournisseurs tels que Microsoft SQL Server et SQLite, consultez Migrations avec plusieurs fournisseurs.

Tester l’application

Visual Studio

Exécutez l’application et sélectionnez sur le lien Movie App.

Si vous obtenez une exception semblable à ce qui suit, vous avez peut-être manqué la commande Update-Database à l’étape des migrations :

SqlException: Cannot open database "MvcMovieContext-1" requested by the login. The login failed.

Visual Studio Code

Exécutez l’application et sélectionnez sur le lien Movie App.

Si vous obtenez une exception semblable à ce qui suit, vous avez peut-être manqué la commande dotnet ef database update à l’étape des migrations :

SqliteException: SQLite Error 1: 'no such table: Movie'.

Remarque

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.

Examinez la classe de contexte de base de données générée et l’inscription

Avec EF Core, l’accès aux données est effectué à l’aide d’un modèle. Un modèle est constitué de classes d’entité et d’un objet de contexte qui représente une session avec la base de données. L’objet de contexte permet l’interrogation et l’enregistrement des données. Le contexte de base de données est dérivé de Microsoft.EntityFrameworkCore.DbContext et il spécifie les entités à inclure dans le modèle de données.

La génération de modèles crée la classe Data/MvcMovieContext.cs de contexte de base de données :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using MvcMovie.Models;

namespace MvcMovie.Data
{
    public class MvcMovieContext : DbContext
    {
        public MvcMovieContext (DbContextOptions<MvcMovieContext> options)
            : base(options)
        {
        }

        public DbSet<MvcMovie.Models.Movie> Movie { get; set; } = default!;
    }
}

Le code précédent crée une propriété DbSet<Movie> qui représente les films dans la base de données.

Injection de dépendances

ASP.NET Core comprend l’injection de dépendances (DI). Les services, tels que le contexte de base de données, sont inscrits avec une injection de dépendance dans Program.cs. Ces services sont fournis aux composants qui en ont besoin via des paramètres de constructeur.

Dans le fichier Controllers/MoviesController.cs, le constructeur utilise une injection de dépendance pour injecter le contexte de base de données MvcMovieContext dans le contrôleur. Le contexte de base de données est utilisé dans chacune des méthodes la CRUD du contrôleur.

La génération de modèles a généré le code en surbrillance suivant dans Program.cs :

Visual Studio

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<MvcMovieContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("MvcMovieContext") ?? throw new InvalidOperationException("Connection string 'MvcMovieContext' not found.")));

Visual Studio Code

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<MvcMovieContext>(options =>
    options.UseSqlite(builder.Configuration.GetConnectionString("MvcMovieContext")));

Le système de configuration ASP.NET Core lit la chaîne de connexion de base de données « MvcMovieContext ».

Examinez la chaîne de connexion de base de données générée

La génération de modèles a ajouté une chaîne de connexion au fichier appsettings.json :

Visual Studio

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "MvcMovieContext": "Server=(localdb)\\mssqllocaldb;Database=MvcMovieContext-4ebefa10-de29-4dea-b2ad-8a8dc6bcf374;Trusted_Connection=True;MultipleActiveResultSets=true"
  }
}

Visual Studio Code

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "MvcMovieContext": "Data Source=MvcMovie.db"
  }
}

Pour le développement local, le système de configuration ASP.NET Core lit la clé ConnectionString depuis le fichier appsettings.json.

La classe InitialCreate

Examinez le fichier de migration Migrations/{timestamp}_InitialCreate.cs :

using System;
using Microsoft.EntityFrameworkCore.Migrations;

#nullable disable

namespace MvcMovie.Migrations
{
    /// <inheritdoc />
    public partial class InitialCreate : Migration
    {
        /// <inheritdoc />
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.CreateTable(
                name: "Movie",
                columns: table => new
                {
                    Id = table.Column<int>(type: "int", nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Title = table.Column<string>(type: "nvarchar(max)", nullable: true),
                    ReleaseDate = table.Column<DateTime>(type: "datetime2", nullable: false),
                    Genre = table.Column<string>(type: "nvarchar(max)", nullable: true),
                    Price = table.Column<decimal>(type: "decimal(18,2)", nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Movie", x => x.Id);
                });
        }

        /// <inheritdoc />
        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "Movie");
        }
    }
}

Dans le code précédent :

• La méthode InitialCreate.Up crée la table Film et configure Id comme la clé primaire.
• InitialCreate.Down rétablit les modifications de schéma provoquées par la migration Up.

Injection de dépendances dans le contrôleur

Ouvrez le fichier Controllers/MoviesController.cs et examinez le constructeur :

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

    public MoviesController(MvcMovieContext context)
    {
        _context = context;
    }

Le constructeur utilise une injection de dépendance pour injecter le contexte de base de données (MvcMovieContext) dans le contrôleur. Le contexte de base de données est utilisé dans chacune des méthodes la CRUD du contrôleur.

Testez la page Create. Entrez et envoyez des données.

Testez les pages Edit, Details et Delete.

Modèles fortement typés et directive @model

Plus tôt dans ce didacticiel, vous avez vu comment un contrôleur peut passer des données ou des objets à une vue en utilisant le dictionnaire ViewData. Le dictionnaire ViewData est un objet dynamique qui fournit un moyen pratique d’effectuer une liaison tardive pour passer des informations à une vue.

Le modèle MVC fournit la possibilité de passer des objets de modèle fortement typés à une vue. Cette approche fortement typée permet de vérifier votre code au moment de la compilation. Le mécanisme de génération de modèles a passé un modèle fortement typé dans la classe et les vues MoviesController.

Examinez la méthode Details générée dans le fichier Controllers/MoviesController.cs :

// GET: Movies/Details/5
public async Task<IActionResult> Details(int? id)
{
    if (id == null)
    {
        return NotFound();
    }

    var movie = await _context.Movie
        .FirstOrDefaultAsync(m => m.Id == id);
    if (movie == null)
    {
        return NotFound();
    }

    return View(movie);
}

Le paramètre id est généralement passé en tant que données de routage. Par exemple, https://localhost:5001/movies/details/1 définit :

• Le contrôleur sur le contrôleur movies, le premier segment de l’URL.
• L’action sur details, le deuxième segment de l’URL.
• Le id à 1, le dernier segment d’URL.

Le id peut être transmis avec une chaîne de requête, comme dans l’exemple suivant :

https://localhost:5001/movies/details?id=1

Le paramètre id est défini comme type Nullable (int?) au cas où la valeur id n’est pas fournie.

Une expression lambda est passée à la méthode FirstOrDefaultAsync pour sélectionner les entités de film qui correspondent aux données de routage ou à la valeur de la chaîne de requête.

var movie = await _context.Movie
    .FirstOrDefaultAsync(m => m.Id == id);

Si un film est trouvé, une instance du modèle Movie est passée à la vue Details :

return View(movie);

Examinez le contenu du fichier Views/Movies/Details.cshtml :

@model MvcMovie.Models.Movie

@{
    ViewData["Title"] = "Details";
}

<h1>Details</h1>

<div>
    <h4>Movie</h4>
    <hr />
    <dl class="row">
        <dt class = "col-sm-2">
            @Html.DisplayNameFor(model => model.Title)
        </dt>
        <dd class = "col-sm-10">
            @Html.DisplayFor(model => model.Title)
        </dd>
        <dt class = "col-sm-2">
            @Html.DisplayNameFor(model => model.ReleaseDate)
        </dt>
        <dd class = "col-sm-10">
            @Html.DisplayFor(model => model.ReleaseDate)
        </dd>
        <dt class = "col-sm-2">
            @Html.DisplayNameFor(model => model.Genre)
        </dt>
        <dd class = "col-sm-10">
            @Html.DisplayFor(model => model.Genre)
        </dd>
        <dt class = "col-sm-2">
            @Html.DisplayNameFor(model => model.Price)
        </dt>
        <dd class = "col-sm-10">
            @Html.DisplayFor(model => model.Price)
        </dd>
    </dl>
</div>
<div>
    <a asp-action="Edit" asp-route-id="@Model.Id">Edit</a> |
    <a asp-action="Index">Back to List</a>
</div>

L’instruction @model située en haut du fichier de la vue spécifie le type d’objet attendu par la vue. Lorsque le contrôleur de film était créé, l’instruction @model suivante était incluse :

@model MvcMovie.Models.Movie

Cette directive @model autorise l’accès au film que le contrôleur a passé à la vue. L’objet Model est fortement typé. Par exemple, dans la vue Details.cshtml, le code passe chaque champ du film aux Helpers HTML DisplayNameFor et DisplayFor avec l’objet Model fortement typé. Les méthodes et les vues Create et Edit passent aussi un objet du modèle Movie.

Examinez la vue Index.cshtml et la méthode Index dans le contrôleur Movies. Notez comment le code crée un objet List quand il appelle la méthode View. Le code passe cette liste Movies de la méthode d’action Index à la vue :

// GET: Movies
public async Task<IActionResult> Index()
{
    return View(await _context.Movie.ToListAsync());
}

Le code retourne les détails du problème si la propriété Movie du contexte de données est null.

Lors de la création du contrôleur du film, la génération de modèles automatique a inclus l’instruction @model suivante en haut du fichier Index.cshtml :

@model IEnumerable<MvcMovie.Models.Movie>

La directive @model permet d’accéder à la liste des films que le contrôleur a passé à la vue en utilisant un objet Model qui est fortement typé. Par exemple, dans la vue Index.cshtml, le code boucle dans les films avec une instruction foreach sur l’objet Model fortement typé :

@model IEnumerable<MvcMovie.Models.Movie>

@{
    ViewData["Title"] = "Index";
}

<h1>Index</h1>

<p>
    <a asp-action="Create">Create New</a>
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.Title)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.ReleaseDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Genre)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Price)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
@foreach (var item in Model) {
        <tr>
            <td>
                @Html.DisplayFor(modelItem => item.Title)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.ReleaseDate)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Genre)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Price)
            </td>
            <td>
                <a asp-action="Edit" asp-route-id="@item.Id">Edit</a> |
                <a asp-action="Details" asp-route-id="@item.Id">Details</a> |
                <a asp-action="Delete" asp-route-id="@item.Id">Delete</a>
            </td>
        </tr>
}
    </tbody>
</table>

Comme l’objet Model est fortement typé en tant qu’objet IEnumerable<Movie>, chaque élément de la boucle est typé en tant que Movie. Entre autres avantages, le compilateur valide les types utilisés dans le code.

Ressources supplémentaires

• Entity Framework Core pour les débutants
• Tag Helpers
• Globalisation et localisation

Précédent : Ajout d’une vueSuivant : Utilisation de SQL