Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Note
Dies ist nicht die neueste Version dieses Artikels. Für die aktuelle Veröffentlichung siehe die .NET 11-Version dieses Artikels.
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 objektrelationales Zuordnungsframework (ORM), 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
Klicken Sie mit der rechten Maustaste auf den Ordner Modelle>Hinzufügen>Klasse. Nennen Sie die Datei Movie.cs.
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 Lernprogramm behandelt.
Das Fragezeichen nach string zeigt an, dass die Eigenschaft null sein kann. Weitere Informationen finden Sie unter Nullable-Verweistypen.
Hinzufügen von NuGet-Paketen
Visual Studio installiert automatisch die erforderlichen Pakete.
Erstellen Sie das Projekt, um zu ermitteln, ob Compilerfehler vorliegen.
Gerüstbau der Movie-Seiten
Verwenden Sie das Gerüstbauwerkzeug, um CRUD-Seiten (Create, Read, Update und Delete) für das Filmmodell zu erstellen.
Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf den Ordner Controller, und wählen Sie Add > New Scaffolded Item 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 aus.
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 aus.
- Wählen Sie in der Dropdown-Liste DatenbankanbieterSQL Server aus.
- Ansichten und Controllername: Übernehmen Sie die Standardeinstellung.
- Wählen Sie Hinzufügen aus.
Wenn Sie eine Fehlermeldung erhalten, wählen Sie Hinzufügen ein zweites Mal aus, um es erneut zu versuchen.
Scaffolding fügt die folgenden Pakete hinzu:
Microsoft.EntityFrameworkCore.SqlServerMicrosoft.EntityFrameworkCore.ToolsMicrosoft.VisualStudio.Web.CodeGeneration.Design
Durch das Gerüst entsteht Folgendes:
- Ein Film-Controller:
Controllers/MoviesController.cs -
Razor Dateien zum Erstellen, Löschen, Details, Bearbeiten und Index von Seiten anzeigen:
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. - Fügt der Datei
appsettings.jsoneine Datenbank-Verbindungszeichenfolge hinzu.
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.
Erste Migration
Verwenden Sie das Feature EF CoreMigrationen, um die Datenbank zu erstellen. Migrations ist eine Reihe von Tools zum Erstellen und Aktualisieren einer Datenbank, die dem Datenmodell entspricht.
Wählen Sie im Menü ToolsNuGet Paket-Manager>Paket-Manager Console aus.
Geben Sie in der Paket-Manager Konsole (PMC) den folgenden Befehl ein:
Add-Migration InitialCreate
-
Add-Migration InitialCreate: Generiert die MigrationsdateiMigrations/{timestamp}_InitialCreate.cs. DasInitialCreate-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 KlasseMvcMovieContextangegeben 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 dieUp-Methode in der DateiMigrations/{time-stamp}_InitialCreate.csaus, mit der die Datenbank erstellt wird.
Weitere Informationen zu den PMC-Tools für EF Core finden Sie unter EF Core Tools reference - PMC in Visual Studio.
Testen der App
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.
Note
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. Anweisungen zur Globalisierung finden Sie unter dieses 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 abgeleitet. EntityFrameworkCore.DbContext und gibt die Entitäten an, die in das Datenmodell aufgenommen werden sollen.
Scaffolding erstellt die Data/MvcMovieContext.cs-Datenbankkontextklasse.
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.
Abhängigkeitsinjektion
ASP.NET Core wird mit Dependency Injection (DI) erstellt. Dienste, wie der Datenbankkontext, werden bei DI in Program.cs registriert. 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:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<MvcMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("MvcMovieContext") ?? throw new InvalidOperationException("Connection string 'MvcMovieContext' not found.")));
Das ASP.NET Core-Konfigurationssystem liest die Datenbank-Verbindungszeichenfolge "MvcMovieContext".
Überprüfen Sie die generierte Datenbank-Verbindungszeichenfolge
Das Gerüst hat der Datei appsettings.json eine Verbindungszeichenfolge hinzugefügt.
{
"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"
}
}
Für die lokale Entwicklung liest das konfigurationssystem ASP.NET Core den Schlüssel ConnectionString aus der Datei appsettings.json.
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");
}
}
}
Im vorhergehenden Code:
-
InitialCreate.Uperstellt die Movie-Tabelle und konfiguriertIdals Primärschlüssel. -
InitialCreate.Downsetzt die von derUpMigration vorgenommenen Schemaänderungen zurück.
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:{PORT}/movies/details/1 legt beispielsweise Folgendes fest:
- Den Controller dem Controller
movieszuordnen, dem ersten URL-Segment. - Die Aktion auf
details(das zweite URL-Segment). - Die
idauf 1 (das letzte URL-Segment).
id kann wie im folgenden Beispiel mit einer Abfragezeichenfolge übergeben werden:
https://localhost:{PORT}/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 List-Methode ein View-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>
Die @model-Direktive ermöglicht den 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.