Teil 4: Hinzufügen eines Modells zu einer ASP.NET Core MVC-App

Von Rick Anderson und Jon P. Smith.

In diesem Tutorial werden Klassen für die Verwaltung von Filmen in einer Datenbank hinzugefügt. Diese Klassen stellen den „Modell“-Teil der MVC-App dar.

Diese Modellklassen werden mit Entity Framework Core (EF Core) verwendet, um mit einer Datenbank zu arbeiten. EF Core ist ein ORM-Framework (Objektrelationales Mapping), das den Datenzugriffscode vereinfacht, den Sie schreiben müssen.

Die erstellten Modellklassen werden als POCO-Klassen bezeichnet (von Plain Old CLR Objects). POCO-Klassen weisen keine Abhängigkeit von EF Core auf. Sie definieren lediglich die Eigenschaften der Daten, die in der Datenbank gespeichert werden sollen.

In diesem Tutorial werden zuerst die Modellklassen erstellt. Anschließend erstellt EF Core die Datenbank.

Hinzufügen einer Datenmodellklasse

Visual Studio

Klicken Sie mit der rechten Maustaste auf den Ordner Modelle>Hinzufügen>Klasse. Nennen Sie die Datei Movie.cs.

Visual Studio Code

Fügen Sie dem Ordner Models eine Datei mit dem Namen Movie.cs hinzu.

Aktualisieren Sie die Datei Models/Movie.cs mit dem folgenden 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; }
}

Die Movie-Klasse enthält ein Id-Feld, das von der Datenbank für den Primärschlüssel benötigt wird.

Das DataType-Attribut für ReleaseDate gibt den Typ der Daten (Date) an. Mit diesem Attribut:

• Der Benutzer muss keine Zeitinformationen in das Datumsfeld eingeben.
• Nur das Datum wird angezeigt, keine Zeitinformationen.

DataAnnotations werden in einem späteren Tutorial behandelt.

Das Fragezeichen nach string gibt an, dass die Eigenschaft Nullwerte zulässt. Weitere Informationen finden Sie unter Nullable-Verweistypen.

Hinzufügen von NuGet-Paketen

Visual Studio

Visual Studio installiert automatisch die erforderlichen Pakete.

Erstellen Sie das Projekt, um zu ermitteln, ob Compilerfehler vorliegen.

Visual Studio Code

Führen Sie die folgenden .NET-CLI-Befehle aus:

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 --prerelease
dotnet add package Microsoft.EntityFrameworkCore.SQLite --prerelease
dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design --prerelease
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --prerelease
dotnet add package Microsoft.EntityFrameworkCore.Tools --prerelease

Die oben aufgeführten Befehle fügen Folgendes hinzu:

• Die CLI-Tools für EF Core.
• Das Gerüstbautool „aspnet-codegenerator“.
• Entwurfszeittools für EF Core.
• Den EF Core-SQLite-Anbieter, der das EF Core-Paket als Abhängigkeit installiert.
• Für Gerüstbau erforderliche Pakete: Microsoft.VisualStudio.Web.CodeGeneration.Design und Microsoft.EntityFrameworkCore.SqlServer.

Eine Anleitung für die Konfiguration mehrerer Umgebungen, die es einer App ermöglicht, Ihre Datenbankkontexte nach Umgebung zu konfigurieren, finden Sie unter Verwenden von mehreren Umgebungen in ASP.NET Core.

Hinweis

Standardmäßig stellt die Architektur der zu installierenden .NET-Binärdateien die derzeit ausgeführte Betriebssystemarchitektur dar. Informationen zum Angeben einer anderen Betriebssystemarchitektur finden Sie unter dotnet tool install, --arch option. Weitere Informationen finden Sie unter GitHub Issue dotnet/docs #29262.

Drücken Sie in Visual Studio Code STRG+F5 (Windows) oder ⌘+F5 (macOS), um die App ohne Debugging auszuführen.

Wählen Sie im Panel unterhalb des Editorbereichs die Registerkarte PROBLEME oder im Menü Ansicht die Option Probleme aus, wenn sie sich derzeit nicht in der Ansicht befindet. Stellen Sie sicher, dass keine Kompilierungsfehler aufgetreten sind.

Gerüstbau der Movie-Seiten

Verwenden Sie das Tool für den Gerüstbau, um CRUD-Seiten (Create, Read, Update und Delete) für das Movie-Modell zu erstellen.

Visual Studio

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner Controller, und wählen Sie Hinzufügen > Neues Gerüstelement aus.

Im Dialogfeld Neues Gerüstelement hinzufügen:

• Wählen Sie im linken Bereich Installiert>Allgemein>MVC aus.
• Wählen Sie MVC-Controller mit Ansichten unter Verwendung von Entity Framework aus.
• Wählen Sie Hinzufügen.

Vervollständigen Sie das Dialogfeld MVC-Controller mit Ansichten unter Verwendung von Entity Framework hinzufügen:

• Wählen Sie in der Dropdownliste Modellklasse den Eintrag Movie (MvcMovie.Models) aus.
• Wählen Sie in der Zeile Datenkontextklasse das +-Zeichen (Plus) aus.
  • Im Dialogfeld Datenkontext hinzufügen wird der Klassenname MvcMovie.Data.MvcMovieContext generiert.
  • Wählen Sie Hinzufügen.
• Wählen Sie in der Dropdownliste Datenbankanbieter die Option SQL Server aus.
• Ansichten und Controllername: Übernehmen Sie die Standardeinstellung.
• Wählen Sie Hinzufügen.

Wenn Sie eine Fehlermeldung erhalten, wählen Sie Hinzufügen ein zweites Mal aus, um es erneut zu versuchen.

Beim Gerüstbau werden die folgenden Pakete hinzugefügt:

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

Beim Gerüstbau wird Folgendes erstellt:

• Ein Movies-Controller: Controllers/MoviesController.cs
• Razor-Ansichtsdateien für die Seiten Erstellen, Löschen, Details, Bearbeiten und Index: Views/Movies/*.cshtml
• Eine Datenbankkontext-Klasse: Data/MvcMovieContext.cs

Beim Gerüstbau werden folgende Aktualisierungen vorgenommen:

• Die erforderlichen Paketverweise werden in die MvcMovie.csproj-Projektdatei eingefügt.
• Registriert den Datenbankkontext in der Datei Program.cs.
• Zur appsettings.json -Datei wird eine Datenbankverbindungszeichenfolge hinzugefügt.

Die automatische Erstellung dieser Dateien und Dateiaktualisierungen wird als Gerüstbau bezeichnet.

Sie können die Gerüstbauseiten noch nicht verwenden, da die Datenbank nicht vorhanden ist. Wenn Sie die App ausführen und den Link Movie App auswählen, wird die Fehlermeldung Die Datenbank kann nicht geöffnet werden oder Keine solche Tabelle: Movie angezeigt.

Erstellen Sie die App, um sicherzustellen, dass keine Fehler vorliegen.

Visual Studio Code

Öffnen Sie ein Befehlsfenster im Projektverzeichnis. Das Projektverzeichnis ist das Verzeichnis mit den Dateien Program.cs und .csproj.

Exportieren Sie unter macOS und Linux den Pfad des Gerüstbautools:

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

Führen Sie den folgenden Befehl aus:

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

Die folgende Tabelle zeigt die Details der Parameter des Codegenerators von ASP.NET:

Parameter	BESCHREIBUNG
-M	Der Name des Modells.
-dc	Der Datenkontext.
--relativeFolderPath	Der relative Ausgabeordnerpfad zur Erstellung der Dateien.
--useDefaultLayout|-udl	Das Standardlayout sollte für die Ansichten verwendet werden.
--referenceScriptLibraries	Fügt _ValidationScriptsPartial zum Bearbeiten und Erstellen von Seiten hinzu.
--databaseProvider sqlite	Geben Sie an, ob DbContext SQLite anstelle von SQL Server verwenden sollte.

Verwenden Sie den h-Switch um Hilfe für den aspnet-codegenerator controller-Befehl zu erhalten:

dotnet aspnet-codegenerator controller -h

Weitere Informationen finden Sie unter dotnet aspnet-codegenerator.

Beim Gerüstbau wird Folgendes erstellt:

• Ein Movies-Controller: Controllers/MoviesController.cs
• Razor-Ansichtsdateien für die Seiten Erstellen, Löschen, Details, Bearbeiten und Index: Views/Movies/*.cshtml
• Eine Datenbankkontext-Klasse: Data/MvcMovieContext.cs

Beim Gerüstbau werden folgende Aktualisierungen vorgenommen:

• Registriert den Datenbankkontext in der Datei Program.cs.
• Zur appsettings.json -Datei wird eine Datenbankverbindungszeichenfolge hinzugefügt.

Die automatische Erstellung dieser Dateien und Dateiaktualisierungen wird als Gerüstbau bezeichnet.

Sie können die Gerüstbauseiten noch nicht verwenden, da die Datenbank nicht vorhanden ist. Wenn Sie die App ausführen und den Link Movie App auswählen, wird die Fehlermeldung Die Datenbank kann nicht geöffnet werden oder Keine solche Tabelle: Movie angezeigt.

Erstellen Sie die App, um sicherzustellen, dass keine Fehler vorliegen.

Verwenden von SQLite für die Entwicklung und von SQL Server für die Produktion

Der folgende hervorgehobene Code in Program.cs zeigt, wie SQLite in der Entwicklung und SQL Server in der Produktion verwendet wird.

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

Anfängliche Migration

Verwenden Sie das EF Core-Feature für Migrationen, um die Datenbank zu erstellen. Bei Migrationen handelt es sich um mehrere Tools, mit denen Sie eine Datenbank dem Datenmodell entsprechend erstellen und aktualisieren können.

Visual Studio

Wählen Sie im Menü Tools die Option NuGet-Paket-Manager>Paket-Manager-Konsole aus.

Geben Sie in der Paket-Manager-Konsole (PMC) den folgenden Befehl ein:

Add-Migration InitialCreate

• Add-Migration InitialCreate: Generiert die Migrationsdatei Migrations/{timestamp}_InitialCreate.cs. Das InitialCreate-Argument ist der Migrationsname. Es kann jeder Name verwendet werden, aber per Konvention wird ein Name ausgewählt, der die Migration beschreibt. Da dies die erste Migration ist, enthält die generierte Klasse Code zum Erstellen des Datenbankschemas. Das Datenbankschema basiert auf dem Modell, das in der Klasse MvcMovieContext angegeben ist.

Es wird die folgende Warnung angezeigt, die in einem späteren Schritt behandelt wird:

Für die Dezimaleigenschaft „Preis“ beim Entitätstyp „Movie“ wurde kein Speichertyp angegeben. Dadurch werden Werte automatisch abgeschnitten, falls diese nicht der Standardgenauigkeit und -skalierung entsprechen. Geben Sie den Spaltentyp von SQL-Server explizit an, der durch „HasColumnType“ sämtliche Werte in „OnModelCreating“ unterstützen kann. Geben Sie Genauigkeit und Skalierung mithilfe von „HasPrecision“ an, oder konfigurieren Sie mithilfe von „HasConversion“ einen Wertkonverter.

Geben Sie in der PMC den folgenden Befehl ein:

Update-Database

• Update-Database: Aktualisiert die Datenbank auf die neueste Migration, die der vorherige Befehl erstellt hat. Der Befehl führt die Up-Methode in der Datei Migrations/{time-stamp}_InitialCreate.cs aus, mit der die Datenbank erstellt wird.

Weitere Informationen zu den PMC-Tools für EF Core finden Sie unter Referenz der EF Core-Tools: PMC in Visual Studio.

Visual Studio Code

Führen Sie den folgenden .NET-CLI-Befehl aus:

dotnet ef migrations add InitialCreate

• ef migrations add InitialCreate: Generiert die Migrationsdatei Migrations/{timestamp}_InitialCreate.cs. Das InitialCreate-Argument ist der Migrationsname. Es kann jeder Name verwendet werden, aber per Konvention wird ein Name ausgewählt, der die Migration beschreibt. Da dies die erste Migration ist, enthält die generierte Klasse Code zum Erstellen des Datenbankschemas. Das Datenbankschema basiert auf dem Modell, das in der MvcMovieContext-Klasse in der Datei Data/MvcMovieContext.cs angegeben ist.

Es wird die folgende Warnung angezeigt, die in einem späteren Schritt behandelt wird:

Für die Dezimaleigenschaft „Preis“ beim Entitätstyp „Movie“ wurde kein Speichertyp angegeben. Dadurch werden Werte automatisch abgeschnitten, falls diese nicht der Standardgenauigkeit und -skalierung entsprechen. Geben Sie den Spaltentyp von SQL-Server explizit an, der durch „HasColumnType“ sämtliche Werte in „OnModelCreating“ unterstützen kann. Geben Sie Genauigkeit und Skalierung mithilfe von „HasPrecision“ an, oder konfigurieren Sie mithilfe von „HasConversion“ einen Wertkonverter.

Führen Sie den folgenden .NET-CLI-Befehl aus:

dotnet ef database update

• ef database update: Aktualisiert die Datenbank auf die neueste Migration, die der vorherige Befehl erstellt hat. Der Befehl führt die Up-Methode in der Datei Migrations/{time-stamp}_InitialCreate.cs aus, mit der die Datenbank erstellt wird.

Weitere Informationen zum Verwalten mehrerer Anbieter wie Microsoft SQL Server und SQLite finden Sie unter Migrations with Multiple Providers (Migration mit mehreren Anbietern).

Testen der App

Visual Studio

Führen Sie die APP aus, und wählen Sie den Link Movie App aus.

Wenn Sie eine ähnliche Ausnahme wie die folgende erhalten, haben Sie möglicherweise den Update-Database-Befehl im Migrationsschritt nicht durchgeführt:

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

Visual Studio Code

Führen Sie die APP aus, und wählen Sie den Link Movie App aus.

Wenn Sie eine ähnliche Ausnahme wie die folgende erhalten, haben Sie möglicherweise den dotnet ef database update-Befehl im Migrationsschritt nicht durchgeführt:

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

Hinweis

Sie können unter Umständen in das Feld Price keine Kommas als Dezimaltrennzeichen eingeben. Zur Unterstützung der jQuery-Validierung für Gebietsschemas mit einer anderen Sprache als Englisch, in denen ein Komma („,“) als Dezimaltrennzeichen verwendet wird, und für Datums- und Uhrzeitformate, die nicht dem US-englischen Format entsprechen, muss die App globalisiert werden. Globalisierungsanweisungen finden Sie unter GitHub-Problem.

Untersuchen der generierten Datenbankkontextklasse und -registrierung

Bei EF Core erfolgt der Datenzugriff über ein Modell. Ein Modell setzt sich aus Entitätsklassen und einem Kontextobjekt zusammen, das eine Sitzung mit der Datenbank darstellt. Das Kontextobjekt ermöglicht das Abfragen und Speichern von Daten. Der Datenbankkontext wird von Microsoft.EntityFrameworkCore.DbContext abgeleitet und gibt die Entitäten an, die im Datenmodell enthalten sein sollen.

Beim Gerüstbau wird die Datenbankkontextklasse Data/MvcMovieContext.cs erstellt:

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

Der obige Code erstellt eine DbSet<Movie>-Eigenschaft, die die Filme in der Datenbank darstellt.

Dependency Injection

ASP.NET Core wird mit Abhängigkeitsinjektion (Dependency Injection, DI) erstellt. Dienste, z. B. der Datenbankkontext, müssen mit DI in Program.cs registriert werden. Diese Dienste werden den Komponenten, die sie benötigen, über Konstruktorparameter zur Verfügung gestellt.

Der Konstruktor in der Datei Controllers/MoviesController.cs verwendet die Abhängigkeitsinjektion zum Einfügen des Datenbankkontexts (MvcMovieContext) in den Controller. Der Datenbankkontext wird in den einzelnen CRUD-Methoden im Controller verwendet.

Beim Gerüstbau wurde der folgende hervorgehobene Code in Program.cs erzeugt:

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

Das ASP.NET Core-Konfigurationssystem liest die Datenbankverbindungszeichenfolge „MvcMovieContext“.

Untersuchen der generierten Datenbankverbindungszeichenfolge

Beim Gerüstbau wurde der appsettings.json -Datei eine Verbindungszeichenfolge hinzugefügt:

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

Für die lokale Entwicklung liest das ASP.NET Core-Konfigurationssystem den ConnectionString-Schlüssel aus der appsettings.json -Datei.

Die InitialCreate-Klasse

Untersuchen Sie die Migrationsdatei 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");
        }
    }
}

Für den Code oben gilt:

• InitialCreate.Up erstellt die Movie-Tabelle und konfiguriert Id als Primärschlüssel.
• InitialCreate.Down macht die von der Up-Migration vorgenommenen Schemaänderungen rückgängig.

Abhängigkeitsinjektion im Controller

Öffnen Sie die Datei Controllers/MoviesController.cs, und überprüfen Sie den Konstruktor:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

Der Konstruktor verwendet die Abhängigkeitsinjektion zum Einfügen des Datenbankkontexts (MvcMovieContext) in den Controller. Der Datenbankkontext wird in den einzelnen CRUD-Methoden im Controller verwendet.

Testen Sie die Seite Create (Erstellen). Geben Sie die Daten ein, und senden Sie sie.

Testen Sie die Seiten Edit (Bearbeiten), Details und Delete (Löschen).

Stark typisierte Modelle und die @model-Direktive

Weiter oben in diesem Tutorial haben Sie gesehen, wie ein Controller mithilfe des Wörterbuchs ViewData Daten oder Objekte an eine Ansicht übergeben kann. Das Wörterbuch ViewData ist ein dynamisches Objekt, das eine praktische Möglichkeit zur späten Bindung bietet, um Informationen an eine Ansicht zu übergeben.

MVC bietet die Möglichkeit, stark typisierte Modellobjekte an eine Ansicht zu übergeben. Dieser stark typisierte Ansatz ermöglicht eine Überprüfung Ihres Codes zur Kompilierzeit. Der Gerüstbaumechanismus hat ein stark typisiertes Modell in die MoviesController-Klasse und Ansichten übergeben.

Untersuchen Sie die generierte Details-Methode in der Datei 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);
}

Der id-Parameter wird im Allgemeinen als Routendaten übergeben. https://localhost:5001/movies/details/1 legt beispielsweise Folgendes fest:

• Den Controller auf den Controller movies (das erste URL-Segment).
• Die Aktion auf details (das zweite URL-Segment).
• Die id auf 1 (das letzte URL-Segment).

id kann wie im folgenden Beispiel mit einer Abfragezeichenfolge übergeben werden:

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

Der id-Parameter wird als Nullable-Typ (int?) für den Fall definiert, dass kein id-Wert angegeben wird.

Ein Lambdaausdruck wird an die FirstOrDefaultAsync-Methode übergeben, um Movie-Entitäten auszuwählen, die mit den Routendaten oder dem Wert der Abfragezeichenfolge übereinstimmen.

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

Wenn ein Film gefunden wird, wird eine Instanz des Movie-Modells an die Ansicht Details übergeben:

return View(movie);

Untersuchen Sie den Inhalt der Datei 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>

Die @model-Anweisung am Anfang der Ansichtsdatei gibt den Typ des Objekts an, den die Ansicht erwartet. Beim Erstellen des Movie-Controllers wurde die folgende @model-Anweisung eingeschlossen:

@model MvcMovie.Models.Movie

Diese @model-Anweisung ermöglicht den Zugriff auf den Film, den der Controller an die Ansicht übergeben hat. Das Model-Objekt ist stark typisiert. In der Ansicht Details.cshtml übergibt der Code jedes Filmfeld an die HTML-Hilfsprogramme DisplayNameFor und DisplayFor mit dem stark typisierten Model-Objekt. Die Methoden Create und Edit und Ansichten übergeben außerdem ein Movie-Modelobjekt.

Untersuchen Sie die Ansicht Index.cshtml und die Index-Methode im Movies-Controller. Beachten Sie, wie der Code beim Aufrufen der View-Methode ein List-Objekt erstellt. Der Code übergibt diese Liste Movies aus der Aktionsmethode Index an die Ansicht:

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

Der Code gibt Problemdetails zurück, wenn die Movie-Eigenschaft des Datenkontexts NULL ist.

Als der Movies-Controller erstellt wurde, hat der Gerüstbau automatisch die folgende @model-Anweisung am Anfang der Datei Index.cshtml hinzugefügt:

@model IEnumerable<MvcMovie.Models.Movie>

Diese @model-Direktive ermöglicht Zugriff auf die Liste der Filme, die der Controller an die Ansicht übergeben hat, indem ein stark typisiertes Model-Objekt verwendet wird. In der Ansicht Index.cshtml durchläuft der Code z. B. die Filme mithilfe einer foreach-Anweisung für das stark typisierte Model-Objekt in einer Schleife:

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

Da das Model-Objekt stark typisiert ist (als ein IEnumerable<Movie>-Objekt), wird jedes Element in der Schleife als Movie typisiert. Neben anderen Vorteilen überprüft der Compiler die im Code verwendeten Typen.

Zusätzliche Ressourcen

• Entity Framework Core für Einsteiger
• Taghilfsprogramme
• Globalisierung und Lokalisierung

Vorheriges Tutorial: Hinzufügen einer AnsichtNächstes Tutorial: Arbeiten mit SQL