Diese Informationen beziehen sich auf ein Vorabversionsprodukt, das vor der kommerziellen Freigabe möglicherweise noch wesentlichen Änderungen unterliegt. Microsoft gibt keine Garantie, weder ausdrücklich noch impliziert, hinsichtlich der hier bereitgestellten Informationen.
In diesem Tutorial werden Klassen für die Verwaltung von Filmen in einer Datenbank hinzugefügt. Die Modellklassen der App verwenden Entity Framework Core (EF Core), um mit der Datenbank zu arbeiten. EF Core ist ein objektrelationaler Mapper (O/RM), der den Datenzugriff vereinfacht. Sie schreiben zuerst die Modellklassen. Anschließend erstellt EF Core die Datenbank.
Die Modellklassen werden als POCO-Klassen (von „Plain-Old CLR Objects“) bezeichnet, da sie keinerlei Abhängigkeit von EF Core aufweisen. Sie definieren die Eigenschaften einer Datei, die in der Datenbank gespeichert ist.
Klicken Sie im Solution Explorer mit der rechten Maustaste auf das Projekt RazorPagesMovie >Hinzufügen>Neuer Ordner. Geben Sie dem Ordner den Namen Modelsanmelden.
Klicken Sie mit der rechten Maustaste auf den Ordner Models. Wählen Sie Hinzufügen>Klasse aus. Nennen Sie die Klasse Movie.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
Die Movie-Klasse enthält:
Die Datenbank benötigt das Feld ID für den primären Schlüssel.
Ein [DataType]-Attribut, das den Datentyp in der ReleaseDate-Eigenschaft angibt. Mit diesem Attribut:
Der Benutzer muss keine Zeitinformationen in das Datumsfeld eingeben.
Nur das Datum wird angezeigt, keine Zeitinformationen.
Das Fragezeichen nach string gibt an, dass die Eigenschaft Nullwerte zulässt. Weitere Informationen finden Sie unter Nullable-Verweistypen.
DataAnnotations werden in einem späteren Tutorial behandelt.
Erstellen Sie das Projekt, um sicherzustellen, dass keine Kompilierungsfehler vorliegen.
Fügen Sie einen Ordner mit dem Namen Models hinzu.
Fügen Sie zum Ordner Models eine Klasse mit dem Namen Movie.cs hinzu.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
Die Movie-Klasse enthält:
Ein ID-Feld zum Bereitstellen eines Primärschlüssels für die Datenbank.
Ein [DataType]-Attribut, das den Datentyp im ReleaseDate-Feld angibt. Mit diesem Attribut:
Es ist nicht erforderlich, dass der Benutzer Zeitinformationen in das Datumsfeld eingibt.
Nur das Datum wird angezeigt, keine Zeitinformationen.
Das Fragezeichen nach string gibt an, dass die Eigenschaft Nullwerte zulässt. Weitere Informationen finden Sie unter Nullable-Verweistypen.
DataAnnotations werden in einem späteren Tutorial behandelt.
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.
Erstellen des Gerüsts für das Filmmodell
In diesem Abschnitt wird das Gerüst für das Filmmodell erstellt. Mit dem Tool für den Gerüstbau werden Seiten für die Vorgänge „Create“ (Erstellen), „Read“ (Lesen), „Update“ (Aktualisieren) und „Delete“ (Löschen), kurz CRUD-Vorgänge, für das Filmmodell erstellt.
Klicken Sie mit der rechten Maustaste auf den Ordner Pages>Hinzufügen>Neuer Ordner.
Nennen Sie den Ordner Movies.
Klicken Sie mit der rechten Maustaste auf den Ordner Pages/Movies>Hinzufügen>Neues Gerüstelement.
Wählen Sie im Dialogfeld Neues Gerüst hinzufügen den Eintrag Razor Pages mit Entity Framework (CRUD)>Hinzufügen aus.
Vervollständigen Sie das Dialogfeld Add Razor Pages using Entity Framework (CRUD) (Razor-Seiten mithilfe des Entity Frameworks (CRUD) hinzufügen):
Wählen Sie in der Dropdownliste Modellklasse den Eintrag Film (RazorPagesMovie.Models) aus.
Wählen Sie in der Zeile Datenkontextklasse das + -Zeichen (Pluszeichen) aus.
Im Dialogfeld Datenkontext hinzufügen wird der Klassenname RazorPagesMovie.Data.RazorPagesMovieContext generiert.
Wählen Sie in der Dropdownliste Datenbankanbieter die Option SQL Server aus.
Wählen Sie Hinzufügen.
Die Datei appsettings.json wird mit der Verbindungszeichenfolge aktualisiert, die zum Herstellen einer Verbindung mit einer lokalen Datenbank verwendet wird.
Öffnen Sie eine Befehlsshell im Projektverzeichnis, das die Dateien Program.cs und .csproj enthält. Führen Sie den folgenden Befehl aus:
Verwenden von SQLite für die Entwicklung und von SQL Server für die Produktion
Wenn SQLite ausgewählt wurde, ist der von der Vorlage generierte Code für die Entwicklung bereit. Der folgende Code zeigt, wie Sie die SQLite-Verbindungszeichenfolge in der Entwicklung und SQL Server in der Produktion auswählen.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Der Code oben ruft UseDeveloperExceptionPage nicht in der Entwicklung auf, weil WebApplicationUseDeveloperExceptionPage im Entwicklungsmodus aufruft.
Erstellte und aktualisierte Dateien
Der Gerüstbauprozess erstellt die folgenden Dateien:
Pages/Movies: „Create“, „Delete“, „Details“, „Edit“ und „Index“.
Data/RazorPagesMovieContext.cs
Die erstellten Daten werden im nächsten Tutorial erläutert.
Der Gerüstbauprozess fügt der Datei Program.cs den folgenden hervorgehobenen Code hinzu:
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.MapStaticAssets();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapStaticAssets();
app.MapRazorPages();
app.Run();
Die Änderungen an Program.cs werden später in diesem Tutorial erläutert.
Erstellen des anfängliche, Datenbankschema mithilfe des EF-Features „Migrationen“
Das Feature „Migrationen“ in Entity Framework Core ermöglicht Folgendes:
Erstellen des anfänglichen Datenbankschemas
Schrittweises Aktualisieren des Datenbankschemas, um es mit dem Datenmodell der App synchron zu halten. In der Datenbank vorhandene Daten werden beibehalten.
In diesem Abschnitt wird das Fenster Paket-Manager-Konsole (Package Manager Console, PMC) für Folgendes verwendet:
Fügen Sie eine anfängliche Migration hinzu.
Aktualisieren Sie die Datenbank mit der anfänglichen Migration.
Wählen Sie im Menü Extras die Optionen NuGet-Paket-Manager>Paket-Manager-Konsole aus.
Geben Sie in der PMC den folgenden Befehl ein:
Add-Migration InitialCreate
Mit dem Befehl Add-Migration wird Code generiert, um das anfängliche Datenbankschema zu erstellen. Das Schema basiert auf dem Modell, das in DbContext angegeben ist. Das Argument InitialCreate wird verwendet, um die Migration zu benennen. Es kann jeder Name verwendet werden, aber per Konvention wird ein Name ausgewählt, der die Migration beschreibt.
Es wird die folgende Warnung angezeigt, die in einem späteren Schritt behandelt wird:
No type was specified for the decimal column 'Price' on entity type 'Movie'. Dadurch werden Werte automatisch abgeschnitten, falls diese nicht der Standardgenauigkeit und -skalierung entsprechen. Explicitly specify the SQL server column type that can accommodate all the values using 'HasColumnType()'. (Für die Spalte „Price“ mit Dezimalwerten für den Entitätstyp „Movie“ wurde kein Typ 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 „ForHasColumnType()“ sämtliche Werte unterstützen kann.)
Geben Sie in der PMC den folgenden Befehl ein:
Update-Database
Der Update-Database-Befehl führt die Up-Methode in Migrationen aus, die nicht angewendet wurden. In diesem Fall führt der Befehl die Up-Methode in der Datei Migrations/<time-stamp>_InitialCreate.cs aus, mit der die Datenbank erstellt wird.
Klicken Sie mit der rechten Maustaste auf das Projekt RazorPagesMovie.csproj und wählen Sie dann Im integrierten Terminal öffnen aus.
Das Terminalfenster wird mit der Eingabeaufforderung in dem Projektverzeichnis geöffnet, das die Program.cs und .csproj Dateien enthält.
Führen Sie den folgenden .NET-CLI-Befehl aus:
dotnet ef migrations add InitialCreate
Mit dem Befehl migrations wird Code generiert, um das anfängliche Datenbankschema zu erstellen. Das Schema basiert auf dem Modell, das in DbContext angegeben ist. Das Argument InitialCreate wird verwendet, um die Migrationen zu benennen. Es kann jeder Name verwendet werden, aber per Konvention wird ein Name ausgewählt, der die Migration beschreibt.
Führen Sie den folgenden .NET-CLI-Befehl aus:
dotnet ef database update
Der update-Befehl führt die Up-Methode in Migrationen aus, die nicht angewendet wurden. In diesem Fall führt update die Up-Methode in der Datei Migrations/<time-stamp>_InitialCreate.cs aus, mit der die Datenbank erstellt wird.
Hinweis
Für SQLite wird der Spaltentyp für das Price-Feld auf TEXT festgelegt. Dies wird in einem späteren Schritt aufgelöst.
Gibt an, welche Entitäten im Datenmodell enthalten sind.
Koordiniert die EF Core-Funktionen (Create, Read, Update und Delete) für das Movie-Modell.
Die Klasse RazorPagesMovieContext in der generierten Datei Data/RazorPagesMovieContext.cs:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using RazorPagesMovie.Models;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie> Movie { get; set; } = default!;
}
}
Der vorangehende Code erstellt eine DbSet<Movie>-Eigenschaft für die Entitätenmenge. In der Terminologie von Entity Framework entspricht eine Entitätenmenge in der Regel einer Datenbanktabelle. Entitäten entsprechen Zeilen in Tabellen.
Der Name der Verbindungszeichenfolge wird an den Kontext übergeben, indem Sie eine Methode auf einem DbContextOptions-Objekt aufrufen. Für die lokale Entwicklung liest das -Konfigurationssystem die Verbindungszeichenfolge aus der Datei appsettings.json.
Testen der App
Führen Sie die App aus, und fügen Sie /Movies an die URL im Browser an (http://localhost:port/movies).
Möglicherweise wird eine Fehlermeldung wie diese angezeigt:
SqlException: Cannot open database "RazorPagesMovieContext-GUID" requested by the login. The login failed.
Login failed for user 'User-name'.
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.
Testen Sie die Links Edit (Bearbeiten), Details und Delete (Löschen).
Im nächsten Tutorial finden Sie Erläuterungen zu den Dateien, die durch den Gerüstbau erstellt wurden.
Überprüfen des mit Dependency Injection registrierten Kontexts
ASP.NET Core wird mit Dependency Injection erstellt. Dienste wie der EF Core-Datenbankkontext werden per Dependency Injection beim Anwendungsstart registriert. Komponenten, die diese Dienste erfordern (z. B. Razor Pages), werden über Konstruktorparameter bereitgestellt. Der Konstruktorcode, der eine Datenbankkontextinstanz abruft, wird später in diesem Tutorial erläutert.
Das Tool für den Gerüstbau hat automatisch einen Datenbankkontext erstellt und diesen beim Dependency Injection-Container registriert. Der Datei Program.cs wird der folgende hervorgehobene Code durch den Gerüstbauprozess hinzugefügt:
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.MapStaticAssets();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapStaticAssets();
app.MapRazorPages();
app.Run();
Problembehandlung mit dem fertiggestellten Beispiel
In diesem Tutorial werden Klassen für die Verwaltung von Filmen in einer Datenbank hinzugefügt. Die Modellklassen der App verwenden Entity Framework Core (EF Core), um mit der Datenbank zu arbeiten. EF Core ist ein objektrelationaler Mapper (O/RM), der den Datenzugriff vereinfacht. Sie schreiben zuerst die Modellklassen. Anschließend erstellt EF Core die Datenbank.
Die Modellklassen werden als POCO-Klassen (von „Plain-Old CLR Objects“) bezeichnet, da sie keinerlei Abhängigkeit von EF Core aufweisen. Sie definieren die Eigenschaften einer Datei, die in der Datenbank gespeichert ist.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt RazorPagesMovie >Hinzufügen>Neuer Ordner. Geben Sie dem Ordner den Namen Modelsanmelden.
Klicken Sie mit der rechten Maustaste auf den Ordner Models. Wählen Sie Hinzufügen>Klasse aus. Nennen Sie die Klasse Movie.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
Die Movie-Klasse enthält:
Die Datenbank benötigt das Feld ID für den primären Schlüssel.
Ein [DataType]-Attribut, das den Datentyp in der ReleaseDate-Eigenschaft angibt. Mit diesem Attribut:
Der Benutzer muss keine Zeitinformationen in das Datumsfeld eingeben.
Nur das Datum wird angezeigt, keine Zeitinformationen.
Das Fragezeichen nach string gibt an, dass die Eigenschaft Nullwerte zulässt. Weitere Informationen finden Sie unter Nullable-Verweistypen.
DataAnnotations werden in einem späteren Tutorial behandelt.
Erstellen Sie das Projekt, um sicherzustellen, dass keine Kompilierungsfehler vorliegen.
Fügen Sie einen Ordner mit dem Namen Models hinzu.
Fügen Sie zum Ordner Models eine Klasse mit dem Namen Movie.cs hinzu.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
Die Movie-Klasse enthält:
Ein ID-Feld zum Bereitstellen eines Primärschlüssels für die Datenbank.
Ein [DataType]-Attribut, das den Datentyp im ReleaseDate-Feld angibt. Mit diesem Attribut:
Es ist nicht erforderlich, dass der Benutzer Zeitinformationen in das Datumsfeld eingibt.
Nur das Datum wird angezeigt, keine Zeitinformationen.
Das Fragezeichen nach string gibt an, dass die Eigenschaft Nullwerte zulässt. Weitere Informationen finden Sie unter Nullable-Verweistypen.
DataAnnotations werden in einem späteren Tutorial behandelt.
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.
Klicken Sie im Lösungstoolfenster bei gedrückter Ctrl-Taste auf das Projekt RazorPagesMovie und wählen Sie dann Hinzufügen>Neuer Ordner ... aus. Benennen Sie den Ordner Models.
Klicken Sie bei gedrückter Steuerungstaste auf den Ordner Models, und wählen Sie dann Hinzufügen>Neue Klasse... aus.
Führen Sie im Dialogfeld Neue Datei folgende Aktionen aus:
Klicken Sie im linken Bereich auf Allgemein.
Klicken Sie im mittleren Bereich auf Leere Klasse.
Geben Sie der Klasse den Namen Movie, und wählen sie Erstellen aus.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
Die Movie-Klasse enthält:
Ein ID-Feld zum Bereitstellen eines Primärschlüssels für die Datenbank.
Ein [DataType]-Attribut, das den Datentyp im ReleaseDate-Feld angibt. 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.
Erstellen Sie das Projekt, um sicherzustellen, dass keine Kompilierungsfehler vorliegen.
Erstellen des Gerüsts für das Filmmodell
In diesem Abschnitt wird das Gerüst für das Filmmodell erstellt. Mit dem Tool für den Gerüstbau werden Seiten für die Vorgänge „Create“ (Erstellen), „Read“ (Lesen), „Update“ (Aktualisieren) und „Delete“ (Löschen), kurz CRUD-Vorgänge, für das Filmmodell erstellt.
Klicken Sie mit der rechten Maustaste auf den Ordner Pages>Hinzufügen>Neuer Ordner.
Nennen Sie den Ordner Movies.
Klicken Sie mit der rechten Maustaste auf den Ordner Pages/Movies>Hinzufügen>Neues Gerüstelement.
Wählen Sie im Dialogfeld Neues Gerüst hinzufügen den Eintrag Razor Pages mit Entity Framework (CRUD)>Hinzufügen aus.
Vervollständigen Sie das Dialogfeld Add Razor Pages using Entity Framework (CRUD) (Razor-Seiten mithilfe des Entity Frameworks (CRUD) hinzufügen):
Wählen Sie in der Dropdownliste Modellklasse den Eintrag Film (RazorPagesMovie.Models) aus.
Wählen Sie in der Zeile Datenkontextklasse das + -Zeichen (Pluszeichen) aus.
Im Dialogfeld Datenkontext hinzufügen wird der Klassenname RazorPagesMovie.Data.RazorPagesMovieContext generiert.
Wählen Sie in der Dropdownliste Datenbankanbieter die Option SQL Server aus.
Wählen Sie Hinzufügen.
Die Datei appsettings.json wird mit der Verbindungszeichenfolge aktualisiert, die zum Herstellen einer Verbindung mit einer lokalen Datenbank verwendet wird.
Öffnen Sie eine Befehlsshell im Projektverzeichnis, das die Dateien Program.cs und .csproj enthält. Führen Sie den folgenden Befehl aus:
Verwenden von SQLite für die Entwicklung und von SQL Server für die Produktion
Wenn SQLite ausgewählt wurde, ist der von der Vorlage generierte Code für die Entwicklung bereit. Der folgende Code zeigt, wie Sie die SQLite-Verbindungszeichenfolge in der Entwicklung und SQL Server in der Produktion auswählen.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Der Code oben ruft UseDeveloperExceptionPage nicht in der Entwicklung auf, weil WebApplicationUseDeveloperExceptionPage im Entwicklungsmodus aufruft.
Fügen Sie das NuGet Paket Microsoft.EntityFrameworkCore.Sqlite hinzu, das für das Gerüstbautool erforderlich ist.
Klicken Sie im Lösungstoolfenster bei gedrückter Ctrl-Taste auf das Projekt RazorPagesMovie und wählen Sie dann In Terminal öffnen aus.
Das Terminalfenster wird mit der Eingabeaufforderung in dem Projektverzeichnis geöffnet, das die Program.cs und .csproj Dateien enthält.
Klicken Sie bei gedrückter Steuerungstaste auf den Ordner Pages>Hinzufügen>Neuer Ordner.
Nennen Sie den Ordner Movies.
Klicken Sie bei gedrückter Steuerungstaste auf den Ordner Pages/Movies>Hinzufügen>Neuer Gerüstbau aus.
Klicken Sie im Dialogfeld Add New Scaffolding (Neuen Gerüstbau hinzufügen) auf Razor-Seiten mithilfe des Entity Frameworks (CRUD)>Weiter.
Vervollständigen Sie das Dialogfeld Add Razor Pages using Entity Framework (CRUD) (Razor-Seiten mithilfe des Entity Frameworks (CRUD) hinzufügen):
Geben Sie in der zu verwendenden ModellklasseMovie ein.
Benennen Sie die Klasse RazorPagesMovie.Data.RazorPagesMovieContext in der Zeile Zu verwendende DbContext-Klasse: .
Wählen Sie Fertig stellen aus.
Der Gerüstbauprozess kann einige Zeit in Anspruch nehmen, da erforderliche Pakete automatisch heruntergeladen und dem Projekt hinzugefügt werden.
Die Datei appsettings.json wird mit der Verbindungszeichenfolge aktualisiert, die zum Herstellen einer Verbindung mit einer lokalen Datenbank verwendet wird.
Verwenden von SQLite für die Entwicklung und von SQL Server für die Produktion
Wenn SQLite ausgewählt wurde, ist der von der Vorlage generierte Code für die Entwicklung bereit. Der folgende Code zeigt, wie Sie die SQLite-Verbindungszeichenfolge in der Entwicklung und SQL Server in der Produktion auswählen.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Der Code oben ruft UseDeveloperExceptionPage nicht in der Entwicklung auf, weil WebApplicationUseDeveloperExceptionPage im Entwicklungsmodus aufruft.
Erstellte und aktualisierte Dateien
Der Gerüstbauprozess erstellt die folgenden Dateien:
Pages/Movies: „Create“, „Delete“, „Details“, „Edit“ und „Index“.
Data/RazorPagesMovieContext.cs
Die erstellten Daten werden im nächsten Tutorial erläutert.
Der Gerüstbauprozess fügt der Datei Program.cs den folgenden hervorgehobenen Code hinzu:
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Die Änderungen an Program.cs werden später in diesem Tutorial erläutert.
Erstellen des anfängliche, Datenbankschema mithilfe des EF-Features „Migrationen“
Das Feature „Migrationen“ in Entity Framework Core ermöglicht Folgendes:
Erstellen des anfänglichen Datenbankschemas
Schrittweises Aktualisieren des Datenbankschemas, um es mit dem Datenmodell der App synchron zu halten. In der Datenbank vorhandene Daten werden beibehalten.
In diesem Abschnitt wird das Fenster Paket-Manager-Konsole (Package Manager Console, PMC) für Folgendes verwendet:
Fügen Sie eine anfängliche Migration hinzu.
Aktualisieren Sie die Datenbank mit der anfänglichen Migration.
Wählen Sie im Menü Extras die Optionen NuGet-Paket-Manager>Paket-Manager-Konsole aus.
Geben Sie in der PMC den folgenden Befehl ein:
Add-Migration InitialCreate
Mit dem Befehl Add-Migration wird Code generiert, um das anfängliche Datenbankschema zu erstellen. Das Schema basiert auf dem Modell, das in DbContext angegeben ist. Das Argument InitialCreate wird verwendet, um die Migration zu benennen. Es kann jeder Name verwendet werden, aber per Konvention wird ein Name ausgewählt, der die Migration beschreibt.
Es wird die folgende Warnung angezeigt, die in einem späteren Schritt behandelt wird:
No type was specified for the decimal column 'Price' on entity type 'Movie'. Dadurch werden Werte automatisch abgeschnitten, falls diese nicht der Standardgenauigkeit und -skalierung entsprechen. Explicitly specify the SQL server column type that can accommodate all the values using 'HasColumnType()'. (Für die Spalte „Price“ mit Dezimalwerten für den Entitätstyp „Movie“ wurde kein Typ 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 „ForHasColumnType()“ sämtliche Werte unterstützen kann.)
Geben Sie in der PMC den folgenden Befehl ein:
Update-Database
Der Update-Database-Befehl führt die Up-Methode in Migrationen aus, die nicht angewendet wurden. In diesem Fall führt der Befehl die Up-Methode in der Datei Migrations/<time-stamp>_InitialCreate.cs aus, mit der die Datenbank erstellt wird.
Klicken Sie mit der rechten Maustaste auf das Projekt RazorPagesMovie.csproj und wählen Sie dann Im integrierten Terminal öffnen aus.
Das Terminalfenster wird mit der Eingabeaufforderung in dem Projektverzeichnis geöffnet, das die Program.cs und .csproj Dateien enthält.
Führen Sie den folgenden .NET-CLI-Befehl aus:
dotnet ef migrations add InitialCreate
Mit dem Befehl migrations wird Code generiert, um das anfängliche Datenbankschema zu erstellen. Das Schema basiert auf dem Modell, das in DbContext angegeben ist. Das Argument InitialCreate wird verwendet, um die Migrationen zu benennen. Es kann jeder Name verwendet werden, aber per Konvention wird ein Name ausgewählt, der die Migration beschreibt.
Führen Sie den folgenden .NET-CLI-Befehl aus:
dotnet ef database update
Der update-Befehl führt die Up-Methode in Migrationen aus, die nicht angewendet wurden. In diesem Fall führt update die Up-Methode in der Datei Migrations/<time-stamp>_InitialCreate.cs aus, mit der die Datenbank erstellt wird.
Hinweis
Für SQLite wird der Spaltentyp für das Price-Feld auf TEXT festgelegt. Dies wird in einem späteren Schritt aufgelöst.
Klicken Sie bei gedrückter Ctrl-Taste auf das Projekt RazorPagesMovie und wählen Sie dann In Terminal öffnen aus.
Das Terminalfenster wird mit der Eingabeaufforderung in dem Projektverzeichnis geöffnet, das die Program.cs und .csproj Dateien enthält.
Führen Sie die folgenden .NET-CLI-Befehle aus:
dotnet tool uninstall --global dotnet-ef
dotnet tool install --global dotnet-ef
dotnet ef migrations add InitialCreate
dotnet ef database update
Die Befehle tool installieren die neuesten Entity Framework Core-Tools, nachdem Sie alle früheren Versionen deinstalliert haben, sofern diese vorhanden sind.
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.
Mit dem Befehl migrations wird Code generiert, um das anfängliche Datenbankschema zu erstellen. Das Schema basiert auf dem Modell, das in DbContext angegeben ist. Das Argument InitialCreate wird verwendet, um die Migrationen zu benennen. Es kann jeder Name verwendet werden, aber per Konvention wird ein Name ausgewählt, der die Migration beschreibt.
Der update-Befehl führt die Up-Methode in Migrationen aus, die nicht angewendet wurden. In diesem Fall führt update die Up-Methode in der Datei Migrations/<time-stamp>_InitialCreate.cs aus, mit der die Datenbank erstellt wird.
Hinweis
Für SQLite wird der Spaltentyp für das Price-Feld auf TEXT festgelegt. Dies wird in einem späteren Schritt aufgelöst.
Es wird die folgende Warnung angezeigt, die in einem späteren Schritt behandelt wird:
No type was specified for the decimal column 'Price' on entity type 'Movie'. Dadurch werden Werte automatisch abgeschnitten, falls diese nicht der Standardgenauigkeit und -skalierung entsprechen. Explicitly specify the SQL server column type that can accommodate all the values using 'HasColumnType()'. (Für die Spalte „Price“ mit Dezimalwerten für den Entitätstyp „Movie“ wurde kein Typ 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 „ForHasColumnType()“ sämtliche Werte unterstützen kann.)
Gibt an, welche Entitäten im Datenmodell enthalten sind.
Koordiniert die EF Core-Funktionen (Create, Read, Update und Delete) für das Movie-Modell.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using RazorPagesMovie.Models;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie> Movie { get; set; } = default!;
}
}
Der vorangehende Code erstellt eine DbSet<Movie>-Eigenschaft für die Entitätenmenge. In der Terminologie von Entity Framework entspricht eine Entitätenmenge in der Regel einer Datenbanktabelle. Entitäten entsprechen Zeilen in Tabellen.
Der Name der Verbindungszeichenfolge wird an den Kontext übergeben, indem Sie eine Methode auf einem DbContextOptions-Objekt aufrufen. Für die lokale Entwicklung liest das -Konfigurationssystem die Verbindungszeichenfolge aus der Datei appsettings.json.
Testen der App
Führen Sie die App aus, und fügen Sie /Movies an die URL im Browser an (http://localhost:port/movies).
Möglicherweise wird eine Fehlermeldung wie diese angezeigt:
SqlException: Cannot open database "RazorPagesMovieContext-GUID" requested by the login. The login failed.
Login failed for user 'User-name'.
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.
Testen Sie die Links Edit (Bearbeiten), Details und Delete (Löschen).
Im nächsten Tutorial finden Sie Erläuterungen zu den Dateien, die durch den Gerüstbau erstellt wurden.
Überprüfen des mit Dependency Injection registrierten Kontexts
ASP.NET Core wird mit Dependency Injection erstellt. Dienste wie der EF Core-Datenbankkontext werden per Dependency Injection beim Anwendungsstart registriert. Komponenten, die diese Dienste erfordern (z. B. Razor Pages), werden über Konstruktorparameter bereitgestellt. Der Konstruktorcode, der eine Datenbankkontextinstanz abruft, wird später in diesem Tutorial erläutert.
Das Tool für den Gerüstbau hat automatisch einen Datenbankkontext erstellt und diesen beim Dependency Injection-Container registriert. Der Datei Program.cs wird der folgende hervorgehobene Code durch den Gerüstbauprozess hinzugefügt:
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Problembehandlung mit dem fertiggestellten Beispiel
In diesem Tutorial werden Klassen für die Verwaltung von Filmen in einer Datenbank hinzugefügt. Die Modellklassen der App verwenden Entity Framework Core (EF Core), um mit der Datenbank zu arbeiten. EF Core ist ein objektrelationaler Mapper (O/RM), der den Datenzugriff vereinfacht. Sie schreiben zuerst die Modellklassen. Anschließend erstellt EF Core die Datenbank.
Die Modellklassen werden als POCO-Klassen (von „Plain-Old CLR Objects“) bezeichnet, da sie keinerlei Abhängigkeit von EF Core aufweisen. Sie definieren die Eigenschaften einer Datei, die in der Datenbank gespeichert ist.
Klicken Sie im Solution Explorer mit der rechten Maustaste auf das Projekt RazorPagesMovie >Hinzufügen>Neuer Ordner. Geben Sie dem Ordner den Namen Modelsanmelden.
Klicken Sie mit der rechten Maustaste auf den Ordner Models. Wählen Sie Hinzufügen>Klasse aus. Nennen Sie die Klasse Movie.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
Die Movie-Klasse enthält:
Die Datenbank benötigt das Feld ID für den primären Schlüssel.
Ein [DataType]-Attribut, das den Datentyp in der ReleaseDate-Eigenschaft angibt. Mit diesem Attribut:
Der Benutzer muss keine Zeitinformationen in das Datumsfeld eingeben.
Nur das Datum wird angezeigt, keine Zeitinformationen.
Das Fragezeichen nach string gibt an, dass die Eigenschaft Nullwerte zulässt. Weitere Informationen finden Sie unter Nullable-Verweistypen.
DataAnnotations werden in einem späteren Tutorial behandelt.
Erstellen Sie das Projekt, um sicherzustellen, dass keine Kompilierungsfehler vorliegen.
Fügen Sie einen Ordner mit dem Namen Models hinzu.
Fügen Sie zum Ordner Models eine Klasse mit dem Namen Movie.cs hinzu.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
Die Movie-Klasse enthält:
Ein ID-Feld zum Bereitstellen eines Primärschlüssels für die Datenbank.
Ein [DataType]-Attribut, das den Datentyp im ReleaseDate-Feld angibt. Mit diesem Attribut:
Es ist nicht erforderlich, dass der Benutzer Zeitinformationen in das Datumsfeld eingibt.
Nur das Datum wird angezeigt, keine Zeitinformationen.
Das Fragezeichen nach string gibt an, dass die Eigenschaft Nullwerte zulässt. Weitere Informationen finden Sie unter Nullable-Verweistypen.
DataAnnotations werden in einem späteren Tutorial behandelt.
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.
Klicken Sie im Lösungstoolfenster bei gedrückter Ctrl-Taste auf das Projekt RazorPagesMovie und wählen Sie dann Hinzufügen>Neuer Ordner ... aus. Benennen Sie den Ordner Models.
Klicken Sie bei gedrückter Steuerungstaste auf den Ordner Models, und wählen Sie dann Hinzufügen>Neue Klasse... aus.
Führen Sie im Dialogfeld Neue Datei folgende Aktionen aus:
Klicken Sie im linken Bereich auf Allgemein.
Klicken Sie im mittleren Bereich auf Leere Klasse.
Geben Sie der Klasse den Namen Movie, und wählen sie Erstellen aus.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
Die Movie-Klasse enthält:
Ein ID-Feld zum Bereitstellen eines Primärschlüssels für die Datenbank.
Ein [DataType]-Attribut, das den Datentyp im ReleaseDate-Feld angibt. 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.
Erstellen Sie das Projekt, um sicherzustellen, dass keine Kompilierungsfehler vorliegen.
Erstellen des Gerüsts für das Filmmodell
In diesem Abschnitt wird das Gerüst für das Filmmodell erstellt. Mit dem Tool für den Gerüstbau werden Seiten für die Vorgänge „Create“ (Erstellen), „Read“ (Lesen), „Update“ (Aktualisieren) und „Delete“ (Löschen), kurz CRUD-Vorgänge, für das Filmmodell erstellt.
Klicken Sie mit der rechten Maustaste auf den Ordner Pages>Hinzufügen>Neuer Ordner.
Nennen Sie den Ordner Movies.
Klicken Sie mit der rechten Maustaste auf den Ordner Pages/Movies>Hinzufügen>Neues Gerüstelement.
Wählen Sie im Dialogfeld Neues Gerüst hinzufügen den Eintrag Razor Pages mit Entity Framework (CRUD)>Hinzufügen aus.
Vervollständigen Sie das Dialogfeld Add Razor Pages using Entity Framework (CRUD) (Razor-Seiten mithilfe des Entity Frameworks (CRUD) hinzufügen):
Wählen Sie in der Dropdownliste Modellklasse den Eintrag Film (RazorPagesMovie.Models) aus.
Wählen Sie in der Zeile Datenkontextklasse das + -Zeichen (Pluszeichen) aus.
Im Dialogfeld Datenkontext hinzufügen wird der Klassenname RazorPagesMovie.Data.RazorPagesMovieContext generiert.
Wählen Sie in der Dropdownliste Datenbankanbieter die Option SQL Server aus.
Wählen Sie Hinzufügen.
Die Datei appsettings.json wird mit der Verbindungszeichenfolge aktualisiert, die zum Herstellen einer Verbindung mit einer lokalen Datenbank verwendet wird.
Öffnen Sie eine Befehlsshell im Projektverzeichnis, das die Dateien Program.cs und .csproj enthält. Führen Sie den folgenden Befehl aus:
Verwenden von SQLite für die Entwicklung und von SQL Server für die Produktion
Wenn SQLite ausgewählt wurde, ist der von der Vorlage generierte Code für die Entwicklung bereit. Der folgende Code zeigt, wie Sie die SQLite-Verbindungszeichenfolge in der Entwicklung und SQL Server in der Produktion auswählen.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Der Code oben ruft UseDeveloperExceptionPage nicht in der Entwicklung auf, weil WebApplicationUseDeveloperExceptionPage im Entwicklungsmodus aufruft.
Fügen Sie das NuGet Paket Microsoft.EntityFrameworkCore.Sqlite hinzu, das für das Gerüstbautool erforderlich ist.
Klicken Sie im Lösungstoolfenster bei gedrückter Ctrl-Taste auf das Projekt RazorPagesMovie und wählen Sie dann In Terminal öffnen aus.
Das Terminalfenster wird mit der Eingabeaufforderung in dem Projektverzeichnis geöffnet, das die Program.cs und .csproj Dateien enthält.
Klicken Sie bei gedrückter Steuerungstaste auf den Ordner Pages>Hinzufügen>Neuer Ordner.
Nennen Sie den Ordner Movies.
Klicken Sie bei gedrückter Steuerungstaste auf den Ordner Pages/Movies>Hinzufügen>Neuer Gerüstbau aus.
Klicken Sie im Dialogfeld Add New Scaffolding (Neuen Gerüstbau hinzufügen) auf Razor-Seiten mithilfe des Entity Frameworks (CRUD)>Weiter.
Vervollständigen Sie das Dialogfeld Add Razor Pages using Entity Framework (CRUD) (Razor-Seiten mithilfe des Entity Frameworks (CRUD) hinzufügen):
Geben Sie in der zu verwendenden ModellklasseMovie ein.
Benennen Sie die Klasse RazorPagesMovie.Data.RazorPagesMovieContext in der Zeile Zu verwendende DbContext-Klasse: .
Wählen Sie Fertig stellen aus.
Der Gerüstbauprozess kann einige Zeit in Anspruch nehmen, da erforderliche Pakete automatisch heruntergeladen und dem Projekt hinzugefügt werden.
Die Datei appsettings.json wird mit der Verbindungszeichenfolge aktualisiert, die zum Herstellen einer Verbindung mit einer lokalen Datenbank verwendet wird.
Verwenden von SQLite für die Entwicklung und von SQL Server für die Produktion
Wenn SQLite ausgewählt wurde, ist der von der Vorlage generierte Code für die Entwicklung bereit. Der folgende Code zeigt, wie Sie die SQLite-Verbindungszeichenfolge in der Entwicklung und SQL Server in der Produktion auswählen.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Der Code oben ruft UseDeveloperExceptionPage nicht in der Entwicklung auf, weil WebApplicationUseDeveloperExceptionPage im Entwicklungsmodus aufruft.
Erstellte und aktualisierte Dateien
Der Gerüstbauprozess erstellt die folgenden Dateien:
Pages/Movies: „Create“, „Delete“, „Details“, „Edit“ und „Index“.
Data/RazorPagesMovieContext.cs
Die erstellten Daten werden im nächsten Tutorial erläutert.
Der Gerüstbauprozess fügt der Datei Program.cs den folgenden hervorgehobenen Code hinzu:
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Die Änderungen an Program.cs werden später in diesem Tutorial erläutert.
Erstellen des anfängliche, Datenbankschema mithilfe des EF-Features „Migrationen“
Das Feature „Migrationen“ in Entity Framework Core ermöglicht Folgendes:
Erstellen des anfänglichen Datenbankschemas
Schrittweises Aktualisieren des Datenbankschemas, um es mit dem Datenmodell der App synchron zu halten. In der Datenbank vorhandene Daten werden beibehalten.
In diesem Abschnitt wird das Fenster Paket-Manager-Konsole (Package Manager Console, PMC) für Folgendes verwendet:
Fügen Sie eine anfängliche Migration hinzu.
Aktualisieren Sie die Datenbank mit der anfänglichen Migration.
Wählen Sie im Menü Extras die Optionen NuGet-Paket-Manager>Paket-Manager-Konsole aus.
Geben Sie in der PMC die folgenden Befehle ein:
Add-Migration InitialCreate
Update-Database
Mit dem Befehl Add-Migration wird Code generiert, um das anfängliche Datenbankschema zu erstellen. Das Schema basiert auf dem Modell, das in DbContext angegeben ist. Das Argument InitialCreate wird verwendet, um die Migration zu benennen. Es kann jeder Name verwendet werden, aber per Konvention wird ein Name ausgewählt, der die Migration beschreibt.
Der Update-Database-Befehl führt die Up-Methode in Migrationen aus, die nicht angewendet wurden. In diesem Fall führt der Befehl die Up-Methode in der Datei Migrations/<time-stamp>_InitialCreate.cs aus, mit der die Datenbank erstellt wird.
Klicken Sie mit der rechten Maustaste auf das Projekt RazorPagesMovie.csproj und wählen Sie dann Im integrierten Terminal öffnen aus.
Das Terminalfenster wird mit der Eingabeaufforderung in dem Projektverzeichnis geöffnet, das die Program.cs und .csproj Dateien enthält.
Führen Sie die folgenden .NET-CLI-Befehle aus:
dotnet ef migrations add InitialCreate
dotnet ef database update
Mit dem Befehl migrations wird Code generiert, um das anfängliche Datenbankschema zu erstellen. Das Schema basiert auf dem Modell, das in DbContext angegeben ist. Das Argument InitialCreate wird verwendet, um die Migrationen zu benennen. Es kann jeder Name verwendet werden, aber per Konvention wird ein Name ausgewählt, der die Migration beschreibt.
Der update-Befehl führt die Up-Methode in Migrationen aus, die nicht angewendet wurden. In diesem Fall führt update die Up-Methode in der Datei Migrations/<time-stamp>_InitialCreate.cs aus, mit der die Datenbank erstellt wird.
Hinweis
Für SQLite wird der Spaltentyp für das Price-Feld auf TEXT festgelegt. Dies wird in einem späteren Schritt aufgelöst.
Klicken Sie bei gedrückter Ctrl-Taste auf das Projekt RazorPagesMovie und wählen Sie dann In Terminal öffnen aus.
Das Terminalfenster wird mit der Eingabeaufforderung in dem Projektverzeichnis geöffnet, das die Program.cs und .csproj Dateien enthält.
Führen Sie die folgenden .NET-CLI-Befehle aus:
dotnet tool uninstall --global dotnet-ef
dotnet tool install --global dotnet-ef
dotnet ef migrations add InitialCreate
dotnet ef database update
Die Befehle tool installieren die neuesten Entity Framework Core-Tools, nachdem Sie alle früheren Versionen deinstalliert haben, sofern diese vorhanden sind.
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.
Mit dem Befehl migrations wird Code generiert, um das anfängliche Datenbankschema zu erstellen. Das Schema basiert auf dem Modell, das in DbContext angegeben ist. Das Argument InitialCreate wird verwendet, um die Migrationen zu benennen. Es kann jeder Name verwendet werden, aber per Konvention wird ein Name ausgewählt, der die Migration beschreibt.
Der update-Befehl führt die Up-Methode in Migrationen aus, die nicht angewendet wurden. In diesem Fall führt update die Up-Methode in der Datei Migrations/<time-stamp>_InitialCreate.cs aus, mit der die Datenbank erstellt wird.
Hinweis
Für SQLite wird der Spaltentyp für das Price-Feld auf TEXT festgelegt. Dies wird in einem späteren Schritt aufgelöst.
Es wird die folgende Warnung angezeigt, die in einem späteren Schritt behandelt wird:
No type was specified for the decimal column 'Price' on entity type 'Movie'. Dadurch werden Werte automatisch abgeschnitten, falls diese nicht der Standardgenauigkeit und -skalierung entsprechen. Explicitly specify the SQL server column type that can accommodate all the values using 'HasColumnType()'. (Für die Spalte „Price“ mit Dezimalwerten für den Entitätstyp „Movie“ wurde kein Typ 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 „ForHasColumnType()“ sämtliche Werte unterstützen kann.)
Gibt an, welche Entitäten im Datenmodell enthalten sind.
Koordiniert die EF Core-Funktionen (Create, Read, Update und Delete) für das Movie-Modell.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using RazorPagesMovie.Models;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie> Movie { get; set; } = default!;
}
}
Der vorangehende Code erstellt eine DbSet<Movie>-Eigenschaft für die Entitätenmenge. In der Terminologie von Entity Framework entspricht eine Entitätenmenge in der Regel einer Datenbanktabelle. Entitäten entsprechen Zeilen in Tabellen.
Der Name der Verbindungszeichenfolge wird an den Kontext übergeben, indem Sie eine Methode auf einem DbContextOptions-Objekt aufrufen. Für die lokale Entwicklung liest das -Konfigurationssystem die Verbindungszeichenfolge aus der Datei appsettings.json.
Testen der App
Führen Sie die App aus, und fügen Sie /Movies an die URL im Browser an (http://localhost:port/movies).
Möglicherweise wird eine Fehlermeldung wie diese angezeigt:
SqlException: Cannot open database "RazorPagesMovieContext-GUID" requested by the login. The login failed.
Login failed for user 'User-name'.
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.
Testen Sie die Links Edit (Bearbeiten), Details und Delete (Löschen).
Im nächsten Tutorial finden Sie Erläuterungen zu den Dateien, die durch den Gerüstbau erstellt wurden.
Überprüfen des mit Dependency Injection registrierten Kontexts
ASP.NET Core wird mit Dependency Injection erstellt. Dienste wie der EF Core-Datenbankkontext werden per Dependency Injection beim Anwendungsstart registriert. Komponenten, die diese Dienste erfordern (z. B. Razor Pages), werden über Konstruktorparameter bereitgestellt. Der Konstruktorcode, der eine Datenbankkontextinstanz abruft, wird später in diesem Tutorial erläutert.
Das Tool für den Gerüstbau hat automatisch einen Datenbankkontext erstellt und diesen beim Dependency Injection-Container registriert. Der Datei Program.cs wird der folgende hervorgehobene Code durch den Gerüstbauprozess hinzugefügt:
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Problembehandlung mit dem fertiggestellten Beispiel
In diesem Tutorial werden Klassen für die Verwaltung von Filmen in einer Datenbank hinzugefügt. Die Modellklassen der App verwenden Entity Framework Core (EF Core), um mit der Datenbank zu arbeiten. EF Core ist ein objektrelationaler Mapper (O/RM), der den Datenzugriff vereinfacht. Sie schreiben zuerst die Modellklassen. Anschließend erstellt EF Core die Datenbank.
Die Modellklassen werden als POCO-Klassen (von „Plain-Old CLR Objects“) bezeichnet, da sie keinerlei Abhängigkeit von EF Core aufweisen. Sie definieren die Eigenschaften einer Datei, die in der Datenbank gespeichert ist.
Klicken Sie im Solution Explorer mit der rechten Maustaste auf das Projekt RazorPagesMovie >Hinzufügen>Neuer Ordner. Geben Sie dem Ordner den Namen Modelsanmelden.
Klicken Sie mit der rechten Maustaste auf den Ordner Models. Wählen Sie Hinzufügen>Klasse aus. Nennen Sie die Klasse Movie.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; } = string.Empty;
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; } = string.Empty;
public decimal Price { get; set; }
}
}
Die Movie-Klasse enthält:
Die Datenbank benötigt das Feld ID für den primären Schlüssel.
Ein [DataType]-Attribut, das den Datentyp in der ReleaseDate-Eigenschaft angibt. Mit diesem Attribut:
Der Benutzer muss keine Zeitinformationen in das Datumsfeld eingeben.
Nur das Datum wird angezeigt, keine Zeitinformationen.
Fügen Sie einen Ordner mit dem Namen Models hinzu.
Fügen Sie zum Ordner Models eine Klasse mit dem Namen Movie.cs hinzu.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; } = string.Empty;
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; } = string.Empty;
public decimal Price { get; set; }
}
}
Die Movie-Klasse enthält:
Ein ID-Feld zum Bereitstellen eines Primärschlüssels für die Datenbank.
Ein [DataType]-Attribut, das den Datentyp im ReleaseDate-Feld angibt. Mit diesem Attribut:
Es ist nicht erforderlich, dass der Benutzer Zeitinformationen in das Datumsfeld eingibt.
Nur das Datum wird angezeigt, keine Zeitinformationen.
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.
Klicken Sie im Lösungstoolfenster mit der rechten Maustaste auf das Projekt RazorPagesMovie und wählen Sie dann Hinzufügen>Neuer Ordner … aus. Nennen Sie den Ordner Models.
Klicken Sie mit der rechten Maustaste auf den Ordner Models, und wählen Sie Hinzufügen>Neue Datei aus.
Führen Sie im Dialogfeld Neue Datei folgende Aktionen aus:
Klicken Sie im linken Bereich auf Allgemein.
Klicken Sie im mittleren Bereich auf Leere Klasse.
Geben Sie der Klasse den Namen Movie, und wählen sie Erstellen aus.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; } = string.Empty;
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; } = string.Empty;
public decimal Price { get; set; }
}
}
Die Movie-Klasse enthält:
Ein ID-Feld zum Bereitstellen eines Primärschlüssels für die Datenbank.
Ein [DataType]-Attribut, das den Datentyp im ReleaseDate-Feld angibt. 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.
Erstellen Sie das Projekt, um sicherzustellen, dass keine Kompilierungsfehler vorliegen.
Erstellen des Gerüsts für das Filmmodell
In diesem Abschnitt wird das Gerüst für das Filmmodell erstellt. Mit dem Tool für den Gerüstbau werden Seiten für die Vorgänge „Create“ (Erstellen), „Read“ (Lesen), „Update“ (Aktualisieren) und „Delete“ (Löschen), kurz CRUD-Vorgänge, für das Filmmodell erstellt.
Fügen Sie das NuGet Paket Microsoft.EntityFrameworkCore.Design hinzu, das für das Gerüstbautool erforderlich ist.
Wählen Sie im Menü Extras die Option NuGet-Paket-Manager>NuGet-Pakete für Projektmappe verwalten aus.
Wählen Sie die Registerkarte Durchsuchen aus.
Geben Sie Microsoft.EntityFrameworkCore.Design ein, und wählen Sie diese Option aus der Liste aus.
Aktivieren Sie Projekt, und wählen Sie dann Installieren aus.
Wählen Sie im Dialogfeld Zustimmung zur Lizenz die Option Annehmen aus.
Erstellen Sie den Ordner Pages/Movies:
Klicken Sie mit der rechten Maustaste auf den Ordner Pages>Hinzufügen>Neuer Ordner.
Nennen Sie den Ordner Movies.
Klicken Sie mit der rechten Maustaste auf den Ordner Pages/Movies>Hinzufügen>Neues Gerüstelement.
Wählen Sie im Dialogfeld Neues Gerüst hinzufügen den Eintrag Razor Pages mit Entity Framework (CRUD)>Hinzufügen aus.
Vervollständigen Sie das Dialogfeld Add Razor Pages using Entity Framework (CRUD) (Razor-Seiten mithilfe des Entity Frameworks (CRUD) hinzufügen):
Wählen Sie in der Dropdownliste Modellklasse den Eintrag Film (RazorPagesMovie.Models) aus.
Wählen Sie in der Zeile Datenkontextklasse das + -Zeichen (Pluszeichen) aus.
Im Dialogfeld Datenkontext hinzufügen wird der Klassenname RazorPagesMovie.Data.RazorPagesMovieContext generiert.
Wählen Sie Hinzufügen.
Wenn Sie eine Fehlermeldung erhalten, die besagt, dass Sie das Paket Microsoft.EntityFrameworkCore.SqlServer installieren müssen, wiederholen Sie die Schritte beginnend mit Hinzufügen>Neues Gerüstbauelement.
Die Datei appsettings.json wird mit der Verbindungszeichenfolge aktualisiert, die zum Herstellen einer Verbindung mit einer lokalen Datenbank verwendet wird.
Öffnen Sie eine Befehlsshell im Projektverzeichnis, das die Dateien Program.cs und .csproj enthält. Führen Sie den folgenden Befehl aus:
Verwenden von SQLite für die Entwicklung und von SQL Server für die Produktion
Wenn SQLite ausgewählt wurde, ist der von der Vorlage generierte Code für die Entwicklung bereit. Der folgende Code zeigt, wie Sie die SQLite-Verbindungszeichenfolge in der Entwicklung und SQL Server in der Produktion auswählen.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Der Code oben ruft UseDeveloperExceptionPage nicht in der Entwicklung auf, weil WebApplicationUseDeveloperExceptionPage im Entwicklungsmodus aufruft.
Erstellen Sie den Ordner Pages/Movies:
Klicken Sie mit der rechten Maustaste auf den Ordner Pages>Hinzufügen>Neuer Ordner.
Nennen Sie den Ordner Movies.
Klicken Sie mit der rechten Maustaste auf den Ordner Pages/Movies>Hinzufügen>Neuer Gerüstbau.....
Klicken Sie im Dialogfeld Add New Scaffolding (Neuen Gerüstbau hinzufügen) auf Razor-Seiten mithilfe des Entity Frameworks (CRUD)>Weiter.
Vervollständigen Sie das Dialogfeld Add Razor Pages using Entity Framework (CRUD) (Razor-Seiten mithilfe des Entity Frameworks (CRUD) hinzufügen):
Geben Sie in der zu verwendenden ModellklasseMovie ein.
Benennen Sie die Klasse RazorPagesMovie.Data.RazorPagesMovieContext in der Zeile Zu verwendende DbContext-Klasse: .
Wählen Sie Fertig stellen aus.
Die Datei appsettings.json wird mit der Verbindungszeichenfolge aktualisiert, die zum Herstellen einer Verbindung mit einer lokalen Datenbank verwendet wird.
Verwenden von SQLite für die Entwicklung und von SQL Server für die Produktion
Wenn SQLite ausgewählt wurde, ist der von der Vorlage generierte Code für die Entwicklung bereit. Der folgende Code zeigt, wie Sie die SQLite-Verbindungszeichenfolge in der Entwicklung und SQL Server in der Produktion auswählen.
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
if (builder.Environment.IsDevelopment())
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMovieContext")));
}
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Der Code oben ruft UseDeveloperExceptionPage nicht in der Entwicklung auf, weil WebApplicationUseDeveloperExceptionPage im Entwicklungsmodus aufruft.
Erstellte und aktualisierte Dateien
Der Gerüstbauprozess erstellt die folgenden Dateien:
Pages/Movies: „Create“, „Delete“, „Details“, „Edit“ und „Index“.
Data/RazorPagesMovieContext.cs
Die erstellten Daten werden im nächsten Tutorial erläutert.
Der Gerüstbauprozess fügt der Datei Program.cs den folgenden hervorgehobenen Code hinzu:
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Die Änderungen an Program.cs werden später in diesem Tutorial erläutert.
Erstellen des anfängliche, Datenbankschema mithilfe des EF-Features „Migrationen“
Das Feature „Migrationen“ in Entity Framework Core ermöglicht Folgendes:
Erstellen des anfänglichen Datenbankschemas
Schrittweises Aktualisieren des Datenbankschemas, um es mit dem Datenmodell der App synchron zu halten. In der Datenbank vorhandene Daten werden beibehalten.
In diesem Abschnitt wird das Fenster Paket-Manager-Konsole (Package Manager Console, PMC) für Folgendes verwendet:
Fügen Sie eine anfängliche Migration hinzu.
Aktualisieren Sie die Datenbank mit der anfänglichen Migration.
Wählen Sie im Menü Extras die Optionen NuGet-Paket-Manager>Paket-Manager-Konsole aus.
Geben Sie in der PMC die folgenden Befehle ein:
Add-Migration InitialCreate
Update-Database
Klicken Sie im Lösungstoolfenster mit der rechten Maustaste auf das Projekt RazorPagesMovie und wählen Sie dann Öffnen in Terminal.
Das Terminalfenster wird mit der Eingabeaufforderung in dem Projektverzeichnis geöffnet, das die Program.cs und .csproj Dateien enthält.
Führen Sie die folgenden .NET-CLI-Befehle aus:
dotnet tool install --global dotnet-ef
dotnet ef migrations add InitialCreate
dotnet ef database update
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.
Hinweis
Für SQLite wird der Spaltentyp für das Price-Feld auf TEXT festgelegt. Dies wird in einem späteren Schritt aufgelöst.
Mit den vorherigen Befehlen installieren Sie die Entity Framework Core-Tools und führen den Befehl migrations aus, um Code zu generieren, mit dem das erste Datenbankschema erstellt wird.
Es wird die folgende Warnung angezeigt, die in einem späteren Schritt behandelt wird:
No type was specified for the decimal column 'Price' on entity type 'Movie'. Dadurch werden Werte automatisch abgeschnitten, falls diese nicht der Standardgenauigkeit und -skalierung entsprechen. Explicitly specify the SQL server column type that can accommodate all the values using 'HasColumnType()'. (Für die Spalte „Price“ mit Dezimalwerten für den Entitätstyp „Movie“ wurde kein Typ 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 „ForHasColumnType()“ sämtliche Werte unterstützen kann.)
Mit dem Befehl migrations wird Code generiert, um das anfängliche Datenbankschema zu erstellen. Das Schema basiert auf dem Modell, das in DbContext angegeben ist. Das Argument InitialCreate wird verwendet, um die Migrationen zu benennen. Es kann jeder Name verwendet werden, aber per Konvention wird ein Name ausgewählt, der die Migration beschreibt.
Der update-Befehl führt die Up-Methode in Migrationen aus, die nicht angewendet wurden. In diesem Fall führt update die Up-Methode in der Datei Migrations/<time-stamp>_InitialCreate.cs aus, mit der die Datenbank erstellt wird.
Überprüfen des mit Dependency Injection registrierten Kontexts
ASP.NET Core wird mit Dependency Injection erstellt. Dienste wie der EF Core-Datenbankkontext werden per Dependency Injection beim Anwendungsstart registriert. Komponenten, die diese Dienste erfordern (z. B. Razor Pages), werden über Konstruktorparameter bereitgestellt. Der Konstruktorcode, der eine Datenbankkontextinstanz abruft, wird später in diesem Tutorial erläutert.
Das Tool für den Gerüstbau hat automatisch einen Datenbankkontext erstellt und diesen beim Dependency Injection-Container registriert. Der Datei Program.cs wird der folgende hervorgehobene Code durch den Gerüstbauprozess hinzugefügt:
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("RazorPagesMovieContext") ?? throw new InvalidOperationException("Connection string 'RazorPagesMovieContext' not found.")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Gibt an, welche Entitäten im Datenmodell enthalten sind.
Koordiniert die EF Core-Funktionen (Create, Read, Update und Delete) für das Movie-Modell.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using RazorPagesMovie.Models;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie>? Movie { get; set; }
}
}
Der vorangehende Code erstellt eine DbSet<Movie>-Eigenschaft für die Entitätenmenge. In der Terminologie von Entity Framework entspricht eine Entitätenmenge in der Regel einer Datenbanktabelle. Entitäten entsprechen Zeilen in Tabellen.
Der Name der Verbindungszeichenfolge wird an den Kontext übergeben, indem Sie eine Methode auf einem DbContextOptions-Objekt aufrufen. Für die lokale Entwicklung liest das -Konfigurationssystem die Verbindungszeichenfolge aus der Datei appsettings.json.
Testen der App
Führen Sie die App aus, und fügen Sie /Movies an die URL im Browser an (http://localhost:port/movies).
Möglicherweise wird eine Fehlermeldung wie diese angezeigt:
SqlException: Cannot open database "RazorPagesMovieContext-GUID" requested by the login. The login failed.
Login failed for user 'User-name'.
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.
Testen Sie die Links Edit (Bearbeiten), Details und Delete (Löschen).
Im nächsten Tutorial finden Sie Erläuterungen zu den Dateien, die durch den Gerüstbau erstellt wurden.
Problembehandlung mit dem fertiggestellten Beispiel
In diesem Abschnitt werden Klassen für die Verwaltung von Filmen in einer Datenbank hinzugefügt. Die Modellklassen der App verwenden Entity Framework Core (EF Core), um mit der Datenbank zu arbeiten. EF Core ist ein objektrelationaler Mapper (O/RM), der den Datenzugriff vereinfacht. Sie schreiben zuerst die Modellklassen. Anschließend erstellt EF Core die Datenbank.
Die Modellklassen werden als POCO-Klassen (von „Plain-Old CLR Objects“) bezeichnet, da sie keinerlei Abhängigkeit von EF Core aufweisen. Sie definieren die Eigenschaften einer Datei, die in der Datenbank gespeichert ist.
Klicken Sie im Solution Explorer mit der rechten Maustaste auf das Projekt RazorPagesMovie >Hinzufügen>Neuer Ordner. Geben Sie dem Ordner den Namen Modelsanmelden.
Klicken Sie mit der rechten Maustaste auf den Ordner Models. Wählen Sie Hinzufügen>Klasse aus. Nennen Sie die Klasse Movie.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System;
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}
Die Movie-Klasse enthält:
Die Datenbank benötigt das Feld ID für den primären Schlüssel.
[DataType(DataType.Date)]: Das Attribut [DataType] 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.
Fügen Sie einen Ordner mit dem Namen Models hinzu.
Fügen Sie zum Ordner Models eine Klasse mit dem Namen Movie.cs hinzu.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System;
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}
Die Movie-Klasse enthält:
Die Datenbank benötigt das Feld ID für den primären Schlüssel.
[DataType(DataType.Date)]: Das Attribut [DataType] gibt den Typ der Daten (Date) an. Mit diesem Attribut:
Es ist nicht erforderlich, dass der Benutzer Zeitinformationen in das Datumsfeld eingibt.
Nur das Datum wird angezeigt, keine Zeitinformationen.
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.
Wenn Sie einen Gerüstbaufehler erhalten, überprüfen Sie den Zielframeworkmoniker (TFM), der mit der NuGet-Paketversion in der Projektdatei übereinstimmt. Beispielsweise werden in der folgenden Projektdatei die .NET-Version 5.0 und aufgeführten NuGet-Pakete verwendet:
Klicken Sie im Lösungstoolfenster bei gedrückter Ctrl-Taste auf das Projekt RazorPagesMovie und wählen Sie dann Hinzufügen>Neuer Ordner ... aus. Benennen Sie den Ordner Models.
Klicken Sie bei gedrückter Steuerungstaste auf den Ordner Models, und wählen Sie Hinzufügen>Neue Datei aus.
Führen Sie im Dialogfeld Neue Datei folgende Aktionen aus:
Klicken Sie im linken Bereich auf Allgemein.
Klicken Sie im mittleren Bereich auf Leere Klasse.
Geben Sie der Klasse den Namen Film, und wählen sie Neu aus.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System;
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}
Die Movie-Klasse enthält:
Die Datenbank benötigt das Feld ID für den primären Schlüssel.
[DataType(DataType.Date)]: Das Attribut [DataType] gibt den Typ der Daten (Date) an. Mit diesem Attribut:
Es ist nicht erforderlich, dass der Benutzer Zeitinformationen in das Datumsfeld eingibt.
Nur das Datum wird angezeigt, keine Zeitinformationen.
DataAnnotations werden in einem späteren Tutorial behandelt.
Erstellen Sie das Projekt, um sicherzustellen, dass keine Kompilierungsfehler vorliegen.
Erstellen des Gerüsts für das Filmmodell
In diesem Abschnitt wird das Gerüst für das Filmmodell erstellt. Mit dem Tool für den Gerüstbau werden Seiten für die Vorgänge „Create“ (Erstellen), „Read“ (Lesen), „Update“ (Aktualisieren) und „Delete“ (Löschen), kurz CRUD-Vorgänge, für das Filmmodell erstellt.
Klicken Sie mit der rechten Maustaste auf den Ordner Pages>Hinzufügen>Neuer Ordner.
Nennen Sie den Ordner Movies.
Klicken Sie mit der rechten Maustaste auf den Ordner Pages/Movies>Hinzufügen>Neues Gerüstelement.
Wählen Sie im Dialogfeld Gerüst hinzufügen den Eintrag Razor Pages mit Entity Framework (CRUD)>Hinzufügen aus.
Vervollständigen Sie das Dialogfeld Add Razor Pages using Entity Framework (CRUD) (Razor-Seiten mithilfe des Entity Frameworks (CRUD) hinzufügen):
Wählen Sie in der Dropdownliste Modellklasse den Eintrag Film (RazorPagesMovie.Models) aus.
Wählen Sie in der Zeile Datenkontextklasse das + -Zeichen (Pluszeichen) aus.
Im Dialogfeld Datenkontext hinzufügen wird der Klassenname RazorPagesMovie.Data.RazorPagesMovieContext generiert.
Wählen Sie Hinzufügen.
Die Datei appsettings.json wird mit der Verbindungszeichenfolge aktualisiert, die zum Herstellen einer Verbindung mit einer lokalen Datenbank verwendet wird.
Öffnen Sie eine Befehlsshell im Projektverzeichnis, das die Dateien Program.cs, Startup.cs und .csproj enthält. Führen Sie den folgenden Befehl aus:
Verwenden von SQLite für die Entwicklung und von SQL Server für die Produktion
Wenn SQLite ausgewählt wurde, ist der von der Vorlage generierte Code für die Entwicklung bereit. Der folgende Code zeigt das Einfügen von IWebHostEnvironment in Startup. IWebHostEnvironment wird eingefügt, sodass ConfigureServices SQLite bei der Entwicklung und SQL Server für die Produktion verwenden kann.
public class Startup
{
public Startup(IConfiguration configuration, IWebHostEnvironment env)
{
Environment = env;
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public IWebHostEnvironment Environment { get; }
public void ConfigureServices(IServiceCollection services)
{
if (Environment.IsDevelopment())
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(
Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("MovieContext")));
}
services.AddRazorPages();
}
public void Configure(IApplicationBuilder app)
{
if (Environment.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
}
}
Erstellen Sie den Ordner Pages/Movies:
Klicken Sie bei gedrückter Steuerungstaste auf den Ordner Pages>Hinzufügen>Neuer Ordner.
Nennen Sie den Ordner Movies.
Klicken Sie bei gedrückter Steuerungstaste auf den Ordner Pages/Movies>Hinzufügen>Neuer Gerüstbau aus.
Klicken Sie im Dialogfeld Add New Scaffolding (Neuen Gerüstbau hinzufügen) auf Razor-Seiten mithilfe des Entity Frameworks (CRUD)>Weiter.
Vervollständigen Sie das Dialogfeld Add Razor Pages using Entity Framework (CRUD) (Razor-Seiten mithilfe des Entity Frameworks (CRUD) hinzufügen):
Benennen Sie die Klasse RazorPagesMovie.Data.RazorPagesMovieContext in der Zeile Zu verwendende DbContext-Klasse: .
Wählen Sie Fertig stellen aus.
Die Datei appsettings.json wird mit der Verbindungszeichenfolge aktualisiert, die zum Herstellen einer Verbindung mit einer lokalen Datenbank verwendet wird.
Verwenden von SQLite für die Entwicklung und von SQL Server für die Produktion
Wenn SQLite ausgewählt wurde, ist der von der Vorlage generierte Code für die Entwicklung bereit. Der folgende Code zeigt das Einfügen von IWebHostEnvironment in Startup. IWebHostEnvironment wird eingefügt, sodass ConfigureServices SQLite bei der Entwicklung und SQL Server für die Produktion verwenden kann.
public class Startup
{
public Startup(IConfiguration configuration, IWebHostEnvironment env)
{
Environment = env;
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public IWebHostEnvironment Environment { get; }
public void ConfigureServices(IServiceCollection services)
{
if (Environment.IsDevelopment())
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(
Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("MovieContext")));
}
services.AddRazorPages();
}
public void Configure(IApplicationBuilder app)
{
if (Environment.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
}
}
Erstellte und aktualisierte Dateien
Der Gerüstbauprozess erstellt die folgenden Dateien:
Pages/Movies: „Create“, „Delete“, „Details“, „Edit“ und „Index“.
Data/RazorPagesMovieContext.cs
Aktualisierte Dateien
Startup.cs
Die erstellten und aktualisierten Daten werden im nächsten Abschnitt erläutert.
Erstellen des anfängliche, Datenbankschema mithilfe des EF-Features „Migrationen“
Das Feature „Migrationen“ in Entity Framework Core ermöglicht Folgendes:
Erstellen des anfänglichen Datenbankschemas
Schrittweises Aktualisieren des Datenbankschemas, um es mit dem Datenmodell der Anwendung synchron zu halten. In der Datenbank vorhandene Daten werden beibehalten.
In diesem Abschnitt wird das Fenster Paket-Manager-Konsole (Package Manager Console, PMC) für Folgendes verwendet:
Fügen Sie eine anfängliche Migration hinzu.
Aktualisieren Sie die Datenbank mit der anfänglichen Migration.
Wählen Sie im Menü Extras die Optionen NuGet-Paket-Manager>Paket-Manager-Konsole aus.
Geben Sie in der PMC die folgenden Befehle ein:
Add-Migration InitialCreate
Update-Database
Führen Sie die folgenden .NET-CLI-Befehle aus:
dotnet ef migrations add InitialCreate
dotnet ef database update
Hinweis
Für SQLite wird der Spaltentyp für das Price-Feld auf TEXT festgelegt. Dies wird in einem späteren Schritt aufgelöst.
Bei SQL Server wird durch obige Befehle die folgende Warnung erstellt: "No type was specified for the decimal column 'Price' on entity type 'Movie'. Dadurch werden Werte automatisch abgeschnitten, falls diese nicht der Standardgenauigkeit und -skalierung entsprechen. Explicitly specify the SQL server column type that can accommodate all the values using 'HasColumnType()'." („Für die Spalte „Price“ mit Dezimalwerten beim Entitätstyp „Movie“ wurde kein Typ angegeben. Dadurch werden Werte automatisch abgeschnitten, falls diese nicht der Standardgenauigkeit und -skalierung entsprechen. Geben Sie den Spaltentyp von SQL-Server an, der durch „ForHasColumnType()“ sämtliche Werte unterstützen kann.")
Ignorieren Sie die Warnung, da sie in einem späteren Schritt behandelt wird.
Mit dem Befehl migrations wird Code generiert, um das anfängliche Datenbankschema zu erstellen. Das Schema basiert auf dem Modell, das in DbContext angegeben ist. Das Argument InitialCreate wird verwendet, um die Migrationen zu benennen. Es kann jeder Name verwendet werden, aber per Konvention wird ein Name ausgewählt, der die Migration beschreibt.
Der update-Befehl führt die Up-Methode in Migrationen aus, die nicht angewendet wurden. In diesem Fall führt update die Up-Methode in der Datei Migrations/<time-stamp>_InitialCreate.cs aus, mit der die Datenbank erstellt wird.
Überprüfen des mit Dependency Injection registrierten Kontexts
ASP.NET Core wird mit Dependency Injection erstellt. Dienste wie der EF Core-Datenbankkontext werden per Dependency Injection beim Anwendungsstart registriert. Komponenten, die diese Dienste erfordern (z. B. Razor Pages), werden über Konstruktorparameter bereitgestellt. Der Konstruktorcode, der eine Datenbankkontextinstanz abruft, wird später in diesem Tutorial erläutert.
Das Tool für den Gerüstbau hat automatisch einen Datenbankkontext erstellt und diesen beim Dependency Injection-Container registriert.
Untersuchen Sie die Methode Startup.ConfigureServices. Die hervorgehobene Zeile wurde vom Gerüst hinzugefügt:
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages();
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("RazorPagesMovieContext")));
}
Der RazorPagesMovieContext koordiniert die EF Core-Funktionen (Create, Read, Update und Delete) für das Movie-Modell. Der Datenkontext (RazorPagesMovieContext) wird aus Microsoft.EntityFrameworkCore.DbContext abgeleitet. Der Datenkontext gibt an, welche Entitäten im Datenmodell enthalten sind.
using Microsoft.EntityFrameworkCore;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (
DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie> Movie { get; set; }
}
}
Der vorangehende Code erstellt eine DbSet<Movie>-Eigenschaft für die Entitätenmenge. In der Terminologie von Entity Framework entspricht eine Entitätenmenge in der Regel einer Datenbanktabelle. Entitäten entsprechen Zeilen in Tabellen.
Der Name der Verbindungszeichenfolge wird an den Kontext übergeben, indem Sie eine Methode auf einem DbContextOptions-Objekt aufrufen. Für die lokale Entwicklung liest das -Konfigurationssystem die Verbindungszeichenfolge aus der Datei appsettings.json.
Untersuchen Sie die Methode Up.
Testen der App
Führen Sie die App aus, und fügen Sie /Movies an die URL im Browser an (http://localhost:port/movies).
Möglicherweise wird eine Fehlermeldung wie diese angezeigt:
SqlException: Cannot open database "RazorPagesMovieContext-GUID" requested by the login. The login failed.
Login failed for user 'User-name'.
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.
Testen Sie die Links Edit (Bearbeiten), Details und Delete (Löschen).
SQL Protokollierung von Entity Framework Core
Die Konfiguration der Protokollierung wird meistens im Abschnitt Logging der appsettings.{Environment}.json-Dateien angegeben. Um SQL Anweisungen zu protokollieren, fügen Sie "Microsoft.EntityFrameworkCore.Database.Command": "Information" der Datei appsettings.Development.json hinzu:
In diesem Abschnitt werden Klassen für die Verwaltung von Filmen hinzugefügt. Die Modellklassen der App verwenden Entity Framework Core (EF Core), um mit der Datenbank zu arbeiten. EF Core ist ein objektrelationaler Mapper (O/RM), der den Datenzugriff vereinfacht.
Die Modellklassen werden als POCO-Klassen (von „Plain-Old CLR Objects“) bezeichnet, da sie keinerlei Abhängigkeit von EF Core aufweisen. Sie definieren die Eigenschaften einer Datei, die in der Datenbank gespeichert ist.
Klicken Sie mit der rechten Maustaste auf das Projekt RazorPagesMovie >Hinzufügen>Neuer Ordner. Geben Sie dem Ordner den Namen Modelsanmelden.
Klicken Sie mit der rechten Maustaste auf den Ordner Models. Wählen Sie Hinzufügen>Klasse aus. Nennen Sie die Klasse Movie.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System;
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}
Die Movie-Klasse enthält:
Die Datenbank benötigt das Feld ID für den primären Schlüssel.
[DataType(DataType.Date)]: Das DataType-Attribut gibt den Typ der Daten (Date) an. Mit diesem Attribut:
Es ist nicht erforderlich, dass der Benutzer Zeitinformationen in das Datumsfeld eingibt.
Nur das Datum wird angezeigt, keine Zeitinformationen.
DataAnnotations werden in einem späteren Tutorial behandelt.
Fügen Sie einen Ordner mit dem Namen Models hinzu.
Fügen Sie zum Ordner Models eine Klasse mit dem Namen Movie.cs hinzu.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System;
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}
Die Movie-Klasse enthält:
Die Datenbank benötigt das Feld ID für den primären Schlüssel.
[DataType(DataType.Date)]: Das DataType-Attribut gibt den Typ der Daten (Date) an. Mit diesem Attribut:
Es ist nicht erforderlich, dass der Benutzer Zeitinformationen in das Datumsfeld eingibt.
Nur das Datum wird angezeigt, keine Zeitinformationen.
DataAnnotations werden in einem späteren Tutorial behandelt.
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.
Wenn Sie einen Gerüstbaufehler erhalten, überprüfen Sie den Zielframeworkmoniker (TFM), der mit der NuGet-Paketversion in der Projektdatei übereinstimmt. Beispielsweise enthält die folgende Projektdatei die Version 3.1 für .NET Core und die aufgeführten NuGet-Pakete:
Erstellen Sie im Projekt RazorPagesMovie einen neuen Ordner mit dem Namen Data.
Fügen Sie dem Ordner Data (Daten) die folgende RazorPagesMovieContext-Klasse hinzu:
using Microsoft.EntityFrameworkCore;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (
DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie> Movie { get; set; }
}
}
Der vorangehende Code erstellt eine DbSet-Eigenschaft für die Entitätenmenge. In der Terminologie von Entity Framework entspricht eine Entitätenmenge in der Regel einer Datenbanktabelle, und eine Entität entspricht einer Zeile in einer Tabelle. Der Code wird erst kompiliert, wenn Abhängigkeiten in einem späteren Schritt hinzugefügt werden.
Hinzufügen einer Datenbank-Verbindungszeichenfolge
Fügen Sie zur Datei appsettings.json wie im folgenden hervorgehobenen Code dargestellt eine Verbindungszeichenfolge hinzu:
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages();
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(Configuration.GetConnectionString("RazorPagesMovieContext")));
}
Klicken Sie im Lösungstoolfenster mit der Ctrl-Taste auf das Projekt RazorPagesMovie und wählen Sie dann Hinzufügen>Neuer Ordner ... aus. Nennen Sie den Ordner Models.
Klicken Sie mit der rechten Maustaste auf den Ordner Models, und wählen Sie Hinzufügen>Neue Datei aus.
Führen Sie im Dialogfeld Neue Datei folgende Aktionen aus:
Klicken Sie im linken Bereich auf Allgemein.
Klicken Sie im mittleren Bereich auf Leere Klasse.
Geben Sie der Klasse den Namen Film, und wählen sie Neu aus.
Fügen Sie der Klasse Movie die folgenden Eigenschaften hinzu:
using System;
using System.ComponentModel.DataAnnotations;
namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}
Die Movie-Klasse enthält:
Die Datenbank benötigt das Feld ID für den primären Schlüssel.
[DataType(DataType.Date)]: Das DataType-Attribut gibt den Typ der Daten (Date) an. Mit diesem Attribut:
Es ist nicht erforderlich, dass der Benutzer Zeitinformationen in das Datumsfeld eingibt.
Nur das Datum wird angezeigt, keine Zeitinformationen.
DataAnnotations werden in einem späteren Tutorial behandelt.
Erstellen Sie das Projekt, um sicherzustellen, dass keine Kompilierungsfehler vorliegen.
Erstellen des Gerüsts für das Filmmodell
In diesem Abschnitt wird das Gerüst für das Filmmodell erstellt. Mit dem Tool für den Gerüstbau werden Seiten für die Vorgänge „Create“ (Erstellen), „Read“ (Lesen), „Update“ (Aktualisieren) und „Delete“ (Löschen), kurz CRUD-Vorgänge, für das Filmmodell erstellt.
Klicken Sie mit der rechten Maustaste auf den Ordner Pages>Hinzufügen>Neuer Ordner.
Nennen Sie den Ordner Movies.
Klicken Sie mit der rechten Maustaste auf den Ordner Pages/Movies>Hinzufügen>Neues Gerüstelement.
Wählen Sie im Dialogfeld Gerüst hinzufügen den Eintrag Razor Pages mit Entity Framework (CRUD)>Hinzufügen aus.
Vervollständigen Sie das Dialogfeld Add Razor Pages using Entity Framework (CRUD) (Razor-Seiten mithilfe des Entity Frameworks (CRUD) hinzufügen):
Wählen Sie in der Dropdownliste Modellklasse den Eintrag Film (RazorPagesMovie.Models) aus.
Wählen Sie in der Zeile Datenkontextklasse das Zeichen + (plus) aus und ändern Sie den generierten Namen von RazorPagesMovie.Models.RazorPagesMovieContext in RazorPagesMovie.Data.RazorPagesMovieContext. Dieses Änderung ist nicht erforderlich. Sie erstellt die Datenbank-Kontextklasse mit dem korrekten Namespace.
Wählen Sie Hinzufügen.
Die Datei appsettings.json wird mit der Verbindungszeichenfolge aktualisiert, die zum Herstellen einer Verbindung mit einer lokalen Datenbank verwendet wird.
Öffnen Sie ein Befehlsfenster im Projektverzeichnis, das die Dateien Program.cs, Startup.cs und .csproj enthält.
Verwenden von SQLite für die Entwicklung und von SQL Server für die Produktion
Wenn SQLite ausgewählt wurde, ist der von der Vorlage generierte Code für die Entwicklung bereit. Der folgende Code zeigt das Injizieren von IWebHostEnvironment in Startup. IWebHostEnvironment wird eingefügt, sodass ConfigureServices SQLite bei der Entwicklung und SQL Server für die Produktion verwenden kann.
public class Startup
{
public Startup(IConfiguration configuration, IWebHostEnvironment env)
{
Environment = env;
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public IWebHostEnvironment Environment { get; }
public void ConfigureServices(IServiceCollection services)
{
if (Environment.IsDevelopment())
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(
Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("MovieContext")));
}
services.AddRazorPages();
}
public void Configure(IApplicationBuilder app)
{
if (Environment.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
}
}
Erstellen Sie den Ordner Pages/Movies:
Klicken Sie mit der rechten Maustaste auf den Ordner Pages>Hinzufügen>Neuer Ordner.
Nennen Sie den Ordner Movies.
Klicken Sie mit der rechten Maustaste auf den Ordner Pages/Movies>Hinzufügen>Neuer Gerüstbau.....
Klicken Sie im Dialogfeld Add New Scaffolding (Neuen Gerüstbau hinzufügen) auf Razor-Seiten mithilfe des Entity Frameworks (CRUD)>Weiter.
Vervollständigen Sie das Dialogfeld Add Razor Pages using Entity Framework (CRUD) (Razor-Seiten mithilfe des Entity Frameworks (CRUD) hinzufügen):
Wählen Sie in der Dropdownliste Modellklasse den Eintrag Film (RazorPagesMovie.Models) aus, oder geben Sie ihn ein.
Geben Sie in der Zeile Datenkontextklasse den Namen der neuen Klasse „RazorPagesMovie.Data.RazorPagesMovieContext“ ein. Dieses Änderung ist nicht erforderlich. Sie erstellt die Datenbank-Kontextklasse mit dem korrekten Namespace.
Wählen Sie Hinzufügen.
Die Datei appsettings.json wird mit der Verbindungszeichenfolge aktualisiert, die zum Herstellen einer Verbindung mit einer lokalen Datenbank verwendet wird.
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.
Verwenden von SQLite für die Entwicklung und von SQL Server für die Produktion
Wenn SQLite ausgewählt wurde, ist der von der Vorlage generierte Code für die Entwicklung bereit. Der folgende Code zeigt das Injizieren von IWebHostEnvironment in Startup. IWebHostEnvironment wird eingefügt, sodass ConfigureServices SQLite bei der Entwicklung und SQL Server für die Produktion verwenden kann.
public class Startup
{
public Startup(IConfiguration configuration, IWebHostEnvironment env)
{
Environment = env;
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public IWebHostEnvironment Environment { get; }
public void ConfigureServices(IServiceCollection services)
{
if (Environment.IsDevelopment())
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlite(
Configuration.GetConnectionString("RazorPagesMovieContext")));
}
else
{
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("MovieContext")));
}
services.AddRazorPages();
}
public void Configure(IApplicationBuilder app)
{
if (Environment.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
}
}
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 dem GitHub Issue dotnet/docs #29262.
Führen Sie die folgenden .NET-CLI-Befehle aus:
dotnet ef migrations add InitialCreate
dotnet ef database update
Mit den vorherigen Befehlen wird die folgende Warnung erstellt: "No type was specified for the decimal column 'Price' on entity type 'Movie'. Dadurch werden Werte automatisch abgeschnitten, falls diese nicht der Standardgenauigkeit und -skalierung entsprechen. Explicitly specify the SQL server column type that can accommodate all the values using 'HasColumnType()'." („Für die Spalte „Price“ mit Dezimalwerten beim Entitätstyp „Movie“ wurde kein Typ angegeben. Dadurch werden Werte automatisch abgeschnitten, falls diese nicht der Standardgenauigkeit und -skalierung entsprechen. Geben Sie den Spaltentyp von SQL-Server an, der durch „ForHasColumnType()“ sämtliche Werte unterstützen kann.")
Ignorieren Sie die Warnung, da sie in einem späteren Schritt behandelt wird.
Mit dem Migrationsbefehl wird Code generiert, um das anfängliche Datenbankschema zu erstellen. Das Schema basiert auf dem Modell, das in DbContext angegeben ist. Das Argument InitialCreate wird verwendet, um die Migrationen zu benennen. Es kann jeder Name verwendet werden, aber per Konvention wird ein Name ausgewählt, der die Migration beschreibt.
Der update-Befehl führt die Up-Methode in Migrationen aus, die nicht angewendet wurden. In diesem Fall führt update die Up-Methode in der Datei Migrations/<time-stamp>_InitialCreate.cs aus, mit der die Datenbank erstellt wird.
Überprüfen des mit Dependency Injection registrierten Kontexts
ASP.NET Core wird mit Dependency Injection erstellt. Dienste wie der EF Core-Datenbankkontext werden per Dependency Injection beim Anwendungsstart registriert. Komponenten, die diese Dienste erfordern (z. B. Razor Pages), werden diese Dienste über Konstruktorparameter bereitgestellt. Der Konstruktorcode, der eine Datenbankkontextinstanz abruft, wird später in diesem Tutorial erläutert.
Das Tool für den Gerüstbau hat automatisch einen Datenbankkontext erstellt und diesen beim Dependency Injection-Container registriert.
Untersuchen Sie die Methode Startup.ConfigureServices. Die hervorgehobene Zeile wurde vom Gerüst hinzugefügt:
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages();
services.AddDbContext<RazorPagesMovieContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("RazorPagesMovieContext")));
}
Der RazorPagesMovieContext koordiniert die EF Core-Funktionen (Create, Read, Update und Delete) für das Movie-Modell. Der Datenkontext (RazorPagesMovieContext) wird aus Microsoft.EntityFrameworkCore.DbContext abgeleitet. Der Datenkontext gibt an, welche Entitäten im Datenmodell enthalten sind.
using Microsoft.EntityFrameworkCore;
namespace RazorPagesMovie.Data
{
public class RazorPagesMovieContext : DbContext
{
public RazorPagesMovieContext (
DbContextOptions<RazorPagesMovieContext> options)
: base(options)
{
}
public DbSet<RazorPagesMovie.Models.Movie> Movie { get; set; }
}
}
Der vorangehende Code erstellt eine DbSet<Movie>-Eigenschaft für die Entitätenmenge. In der Terminologie von Entity Framework entspricht eine Entitätenmenge in der Regel einer Datenbanktabelle. Entitäten entsprechen Zeilen in Tabellen.
Der Name der Verbindungszeichenfolge wird an den Kontext übergeben, indem Sie eine Methode auf einem DbContextOptions-Objekt aufrufen. Für die lokale Entwicklung liest das -Konfigurationssystem die Verbindungszeichenfolge aus der Datei appsettings.json.
Untersuchen Sie die Methode Up.
Testen der App
Führen Sie die App aus, und fügen Sie /Movies an die URL im Browser an (http://localhost:port/movies).
Wenn Sie eine Fehlermeldung erhalten, müssen Sie Folgendes tun:
SqlException: Cannot open database "RazorPagesMovieContext-GUID" requested by the login. The login failed.
Login failed for user 'User-name'.
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.
Testen Sie die Links Edit (Bearbeiten), Details und Delete (Löschen).
Im nächsten Tutorial finden Sie Erläuterungen zu den Dateien, die durch den Gerüstbau erstellt wurden.
Die Quelle für diesen Inhalt finden Sie auf GitHub, wo Sie auch Issues und Pull Requests erstellen und überprüfen können. Weitere Informationen finden Sie in unserem Leitfaden für Mitwirkende.