Deel 4: een model toevoegen aan een ASP.NET Core MVC-app

Door Rick Anderson en Jon P Smith.

In deze handleiding worden klassen toegevoegd om films in een database te beheren. Deze klassen zijn het onderdeel 'Model' van de MVC-app.

Deze modelklassen worden gebruikt met Entity Framework Core (EF Core) om met een database te werken. EF Core is een ORM-framework (object-relational mapping) dat de code voor gegevenstoegang vereenvoudigt die u moet schrijven.

De gemaakte modelklassen worden POCO--klassen genoemd, van Plain Old CLR-Objects. POCO-klassen hebben geen afhankelijkheid van EF Core. Ze definiëren alleen de eigenschappen van de gegevens die moeten worden opgeslagen in de database.

In deze zelfstudie worden eerst modelklassen gemaakt en EF Core de database maakt.

Een gegevensmodelklasse toevoegen

Visual Studio

Klik met de rechtermuisknop op de map Modellen>>Klassetoevoegen. Geef het bestand de naam Movie.cs.

Visual Studio Code

Voeg een bestand met de naam Movie.cs toe aan de map Models.

Werk het Models/Movie.cs-bestand bij met de volgende code:

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; }
}

De klasse Movie bevat een Id veld, dat vereist is voor de database voor de primaire sleutel.

Het kenmerk DataType op ReleaseDate geeft het type gegevens (Date) aan. Met dit kenmerk:

• De gebruiker hoeft geen tijdgegevens in te voeren in het datumveld.
• Alleen de datum wordt weergegeven, geen tijdinformatie.

DataAnnotations worden behandeld in een volgende handleiding.

Het vraagteken na string geeft aan dat de eigenschap nullable is. Voor meer informatie, zie Nullbare referentietypen.

NuGet-pakketten toevoegen

Visual Studio

Visual Studio installeert automatisch de vereiste pakketten.

Bouw het project als controle op compilerfouten.

Visual Studio Code

Voer de volgende .NET CLI-opdrachten uit:

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

Met de voorgaande opdrachten voegt u de volgende dingen toe:

• De CLI-hulpprogramma's voor EF Core
• Het scaffolding-hulpprogramma aspnet-codegenerator.
• Ontwerptijdhulpmiddelen voor EF Core
• De EF Core SQLite-provider, waarmee het EF Core-pakket als een afhankelijkheid wordt geïnstalleerd.
• Pakketten die nodig zijn voor steigerbouw: Microsoft.VisualStudio.Web.CodeGeneration.Design en Microsoft.EntityFrameworkCore.SqlServer.

Zie Meerdere omgevingen gebruiken in ASP.NET Corevoor hulp bij het configureren van de databasecontexten per omgeving.

Notitie

De architectuur van de binaire .NET-bestanden die moeten worden geïnstalleerd, vertegenwoordigt standaard de huidige besturingssysteemarchitectuur. Zie dotnet tool install, --arch optionom een andere besturingssysteemarchitectuur op te geven. Zie GitHub-probleem dotnet/AspNetCore.Docs #29262voor meer informatie.

Druk in Visual Studio Code op Ctrl+F5- om de app uit te voeren zonder foutopsporing.

Selecteer in het deelvenster onder de editorregio het tabblad PROBLEMEN of selecteer in het menu WeergavePROBLEMEN als het momenteel niet in beeld is. Controleer of er geen compilatiefouten zijn.

Filmpagina's opzetten

Gebruik het scaffolding hulpprogramma om de Create-, Read-, Update- en Delete-pagina's (CRUD) voor het filmmodel te produceren.

Visual Studio

Klik in Solution Explorermet de rechtermuisknop op de map Controllers en selecteer Add > New Scaffolded Item.

In het dialoogvenster Nieuw gescaffolde item toevoegen:

• Selecteer in het linkerdeelvenster >Common>MVC-geïnstalleerd.
• Selecteer MVC-controller met weergaven met behulp van Entity Framework.
• Selecteer toevoegen.

Voltooi de MVC-controller toevoegen met weergaven, met behulp van het dialoogvenster Entity Framework:

• Selecteer in de vervolgkeuzelijst Modelklasse de optie Movie (MvcMovie.Models).
• Selecteer in de gegevenscontextklasse rij het + (plusteken).
  • In het dialoogvenster Gegevenscontext toevoegen wordt de klassenaam MvcMovie.Data.MvcMovieContext gegenereerd.
  • Selecteer toevoegen.
• Selecteer in de vervolgkeuzelijst Database providerSQL Server.
• Weergaven en Controllernaam: behoud de Standaardwaarde.
• Selecteer toevoegen.

Als u een foutbericht krijgt, selecteert u een tweede keer toevoegen om het opnieuw te proberen.

Met scaffolding worden de volgende pakketten toegevoegd:

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

Met scaffolding maakt u het volgende:

• Een filmscontroller: Controllers/MoviesController.cs
• Razor bestanden weergeven voor maken, verwijderen, details, bewerken en pagina's indexeren: Views/Movies/*.cshtml
• Een databasecontextklasse: Data/MvcMovieContext.cs

De scaffolding werkt het volgende bij:

• Voegt vereiste pakketverwijzingen in het MvcMovie.csproj projectbestand in.
• Registreert de databasecontext in het Program.cs-bestand.
• Hiermee voegt u een databaseverbindingsreeks toe aan het appsettings.json-bestand.

Het automatisch maken van deze bestanden en bestandsupdates wordt bekend als scaffolding.

De pagina's in de scaffolded kunnen nog niet worden gebruikt omdat de database niet bestaat. Het uitvoeren van de app en het selecteren van de Film-app koppeling resulteert in een Kan de database niet openen of geen dergelijke tabel: Film foutbericht.

Bouw de app om te controleren of er geen fouten zijn.

Visual Studio Code

Open een opdrachtvenster in de projectmap. De projectmap is de map met de Program.cs- en .csproj-bestanden.

Exporteer op macOS en Linux het scaffold-toolpad:

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

Voer de volgende opdracht uit:

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

De volgende tabel bevat de parameters voor de ASP.NET Core-codegenerator:

Parameter	Beschrijving
-m	De naam van het model.
-dc	De gegevenscontext.
--relativeFolderPath	Het relatieve pad naar de uitvoermap om de bestanden te maken.
--useDefaultLayout|-udl	De standaardindeling moet worden gebruikt voor de weergaven.
--referenceScriptLibraries	Voegt _ValidationScriptsPartial toe aan de pagina's Bewerken en Maken.
--databaseProvider sqlite	Geef aan dat DbContext SQLite moet gebruiken in plaats van SQL Server.

Gebruik de switch h om hulp te verkrijgen bij de opdracht aspnet-codegenerator controller:

dotnet aspnet-codegenerator controller -h

Zie dotnet aspnet-codegenerator voor meer informatie

Met scaffolding maakt u het volgende:

• Een filmscontroller: Controllers/MoviesController.cs
• Razor bestanden weergeven voor maken, verwijderen, details, bewerken en pagina's indexeren: Views/Movies/*.cshtml
• Een databasecontextklasse: Data/MvcMovieContext.cs

Het steigersysteem werkt het volgende bij:

• Registreert de databasecontext in het Program.cs-bestand
• Hiermee voegt u een databaseverbindingsreeks toe aan het appsettings.json-bestand.

Het automatisch aanmaken van deze bestanden en bestandsupdates wordt scaffoldinggenoemd.

De pagina's in de scaffolded kunnen nog niet worden gebruikt omdat de database niet bestaat. Het starten van de app en het selecteren van de koppeling Movie App resulteert in een foutmelding Kan database niet openen of geen dergelijke tabel: Movie.

Bouw de app om te controleren of er geen fouten zijn.

SQLite gebruiken voor ontwikkeling, SQL Server voor productie

De volgende gemarkeerde code in Program.cs laat zien hoe u SQLite gebruikt in ontwikkeling en SQL Server in productie.

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")));
}

Initiële migratie

Gebruik de functie EF CoreMigrations om de database te maken. Migrations is een set hulpprogramma's waarmee een database wordt gemaakt en bijgewerkt zodat deze overeenkomt met het gegevensmodel.

Visual Studio

Selecteer in het menu ToolsNuGet Package Manager>Package Manager Console.

Voer in de Package Manager Console (PMC) de volgende opdracht in:

Add-Migration InitialCreate

• Add-Migration InitialCreate: genereert een Migrations/{timestamp}_InitialCreate.cs migratiebestand. Het argument InitialCreate is de migratienaam. Elke naam kan worden gebruikt, maar volgens de conventie wordt een naam geselecteerd die de migratie beschrijft. Omdat dit de eerste migratie is, bevat de gegenereerde klasse code om het databaseschema te maken. Het databaseschema is gebaseerd op het model dat is opgegeven in de klasse MvcMovieContext.

De volgende waarschuwing wordt weergegeven, die in een latere stap wordt behandeld:

Er is geen winkeltype opgegeven voor de decimale eigenschap 'Prijs' voor entiteitstype 'Film'. Hierdoor worden waarden stilzwijgend afgekapt als ze niet in de standaardprecisie en schaal passen. Geef expliciet het kolomtype sql-server op dat alle waarden in 'OnModelCreating' kan bevatten met behulp van HasColumnType, geef precisie en schaal op met behulp van HasPrecision of configureer een waardeconversieprogramma met hasconversion.

Voer in de PMC de volgende opdracht in:

Update-Database

• Update-Database: hiermee wordt de database bijgewerkt naar de meest recente migratie, die met de vorige opdracht is gemaakt. Met deze opdracht wordt de methode Up uitgevoerd in het Migrations/{time-stamp}_InitialCreate.cs-bestand, waarmee de database wordt gemaakt.

Zie EF Core referentiemateriaal voor hulpprogramma's - PMC in Visual Studiovoor meer informatie over de PMC-hulpprogramma's voor EF Core.

Visual Studio Code

Voer de volgende .NET CLI-opdracht uit:

dotnet ef migrations add InitialCreate

• ef migrations add InitialCreate: genereert een Migrations/{timestamp}_InitialCreate.cs migratiebestand. Het argument InitialCreate is de migratienaam. Elke naam kan worden gebruikt, maar volgens de conventie wordt een naam geselecteerd die de migratie beschrijft. Dit is de eerste migratie, dus de gegenereerde klasse bevat code om het databaseschema te maken. Het databaseschema is gebaseerd op het model dat is opgegeven in de klasse MvcMovieContext, in het Data/MvcMovieContext.cs-bestand.

De volgende waarschuwing wordt weergegeven, die in een latere stap wordt behandeld:

Er is geen winkeltype opgegeven voor de decimale eigenschap 'Prijs' voor entiteitstype 'Film'. Hierdoor worden waarden stilzwijgend afgekapt als ze niet binnen de standaardprecisie en -schaal passen. Geef expliciet het kolomtype sql-server op dat alle waarden in 'OnModelCreating' kan bevatten met behulp van HasColumnType, geef precisie en schaal op met behulp van HasPrecision of configureer een waardeconversieprogramma met hasconversion.

Voer de volgende .NET CLI-opdracht uit:

dotnet ef database update

• ef database update: hiermee wordt de database bijgewerkt naar de meest recente migratie, die met de vorige opdracht is gemaakt. Met deze opdracht wordt de methode Up uitgevoerd in het Migrations/{time-stamp}_InitialCreate.cs-bestand, waarmee de database wordt gemaakt.

Zie Migraties met meerdere providersvoor meer informatie over het onderhouden van meerdere providers, zoals Microsoft SQL Server en SQLite.

De app testen

Visual Studio

Voer de app uit en selecteer de koppeling Movie App.

Als u een uitzondering krijgt die vergelijkbaar is met het volgende, hebt u mogelijk het Update-Database-commando gemist in stap van de-migraties:

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

Visual Studio Code

Voer de app uit en selecteer de koppeling Movie App.

Als u een uitzondering krijgt die vergelijkbaar is met het volgende, hebt u mogelijk de dotnet ef database update opdracht gemist in migratiestap .

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

Notitie

Mogelijk kunt u geen decimale komma's invoeren in het veld Price. Ter ondersteuning van jQuery-validatie voor niet-Engelse landinstellingen die een komma (",") gebruiken voor een decimaalteken en voor niet-US-English datumnotaties, moet de app worden geglobaliseerd. Zie dit GitHub-probleemvoor instructies voor globalisatie.

De gegenereerde databasecontextklasse en -registratie onderzoeken

Met EF Corewordt gegevenstoegang uitgevoerd met behulp van een model. Een model bestaat uit entiteitsklassen en een contextobject dat een sessie met de database vertegenwoordigt. Met het contextobject kunt u gegevens opvragen en opslaan. De databasecontext is afgeleid van Microsoft.EntityFrameworkCore.DbContext en geeft de entiteiten op die moeten worden opgenomen in het gegevensmodel.

Met scaffolding wordt de contextklasse van de Data/MvcMovieContext.cs database gemaakt:

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!;
    }
}

Met de voorgaande code maakt u een eigenschap DbSet<Movie> die de films in de database vertegenwoordigt.

Afhankelijkheidsinjectie

ASP.NET Core is gebouwd met dependency injection (DI). Services, zoals de databasecontext, worden geregistreerd bij DI in Program.cs. Deze services worden aangeboden aan componenten die ze nodig hebben via constructorparameters.

In het bestand Controllers/MoviesController.cs gebruikt de constructor afhankelijkheidsinjectie om de MvcMovieContext databasecontext in de controller te injecteren. De databasecontext wordt gebruikt in elk van de CRUD methoden in de controller.

Scaffolding heeft de volgende gemarkeerde code gegenereerd in 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")));

Het ASP.NET Core-configuratiesysteem leest de verbindingsreeks van de database 'MvcMovieContext'.

De gegenereerde databaseverbindingsreeks onderzoeken

Scaffolding heeft een verbindingsreeks toegevoegd aan het appsettings.json-bestand:

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"
  }
}

Voor lokale ontwikkeling leest het ASP.NET Core-configuratiesysteem de sleutel ConnectionString uit het bestand appsettings.json.

De InitialCreate-klasse

Bekijk het Migrations/{timestamp}_InitialCreate.cs migratiebestand:

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");
        }
    }
}

In de voorgaande code:

• InitialCreate.Up maakt de filmtabel en configureert Id als primaire sleutel.
• InitialCreate.Down de schemawijzigingen die door de Up migratie zijn aangebracht, terugdraaien.

Afhankelijkheidsinjectie in de controller

Open het bestand Controllers/MoviesController.cs en bekijk de constructor:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

De constructor gebruikt afhankelijkheidsinjectie om de databasecontext (MvcMovieContext) in de controller te injecteren. De databasecontext wordt gebruikt in elk van de CRUD methoden in de controller.

Test de pagina maken. Voer gegevens in en verzend deze.

Test de bewerken, detailsen pagina's verwijderen.

Sterk getypte modellen en de @model richtlijn

Eerder in deze zelfstudie hebt u gezien hoe een controller gegevens of objecten aan een weergave kan doorgeven met behulp van de ViewData woordenlijst. De ViewData woordenlijst is een dynamisch object dat een handige, laat-gebonden manier biedt om informatie door te geven aan een weergave.

MVC biedt de mogelijkheid tot het doorgeven van sterk getypte modelobjecten aan een weergave. Deze sterk getypeerde benadering maakt controle van code tijdens de compileertijd mogelijk. Het steigermechanisme heeft een sterk getypeerd model doorgegeven in de MoviesController klasse en weergaven.

Bekijk de gegenereerde methode Details in het bestand 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);
}

De parameter id wordt over het algemeen doorgegeven als routegegevens. Bijvoorbeeld https://localhost:5001/movies/details/1 reeksen:

• De controller voor de movies-controller, het eerste URL-segment.
• De actie voor details, het tweede URL-segment.
• Het id tot 1, het laatste URL-segment.

De id kan worden doorgegeven met een querystring, zoals in het volgende voorbeeld:

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

De parameter id wordt gedefinieerd als een nullable type (int?) in gevallen waarin de id waarde niet is opgegeven.

Een lambda-expressie wordt doorgegeven aan de methode FirstOrDefaultAsync om filmentiteiten te selecteren die overeenkomen met de routegegevens of querytekenreekswaarde.

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

Als er een film wordt gevonden, wordt een exemplaar van het Movie model doorgegeven aan de Details weergave:

return View(movie);

Bekijk de inhoud van het Views/Movies/Details.cshtml-bestand:

@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>

De @model-instructie boven aan het weergavebestand geeft het type object op dat door de weergave wordt verwacht. Toen de filmcontroller werd gemaakt, werd de volgende @model instructie opgenomen:

@model MvcMovie.Models.Movie

Deze @model richtlijn geeft toegang tot de film die door de controller aan de weergave is doorgegeven. Het Model-object is sterk getypt. In de Details.cshtml-weergave geeft de code bijvoorbeeld elk filmveld door aan de DisplayNameFor- en DisplayFor-HTML-helpers met het sterk getypeerde Model-object. De Create en Edit methoden en weergaven geven ook een Movie modelobject door.

Bekijk de Index.cshtml-weergave en de methode Index in de controller Films. U ziet hoe de code een List-object maakt wanneer deze de methode View aanroept. De code geeft deze Movies lijst door vanuit de actiemethode Index aan de weergave:

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

De code retourneert probleemdetails als de eigenschap Movie van de gegevenscontext null is.

Toen de filmcontroller werd gemaakt, bevatte scaffolding de volgende @model instructie bovenaan het Index.cshtml-bestand.

@model IEnumerable<MvcMovie.Models.Movie>

De @model-instructie maakt toegang mogelijk tot de lijst met films die de controller aan de weergave heeft doorgegeven door gebruik te maken van een sterk getypt Model-object. In de weergave Index.cshtml doorloopt de code bijvoorbeeld de films met een foreach-instructie over het sterk getypte Model-object.

@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>

Omdat het Model-object sterk is getypt als een IEnumerable<Movie>-object, wordt elk item in de lus getypt als Movie. De compiler valideert onder andere de typen die in de code worden gebruikt.

Aanvullende informatiebronnen

• Entity Framework Core voor beginners
• Tag Helpers
• globalisatie en lokalisatie

Vorige: Een weergave toevoegenVolgende: Werken met SQL