Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
Note
Dit is niet de nieuwste versie van dit artikel. Zie de .NET 11-versie van dit artikel voor de huidige release.
In deze handleiding worden klassen toegevoegd om films in een database te beheren. Deze klassen zijn het onderdeel 'Model' van de MVC-app.
Deze modelklassen worden gebruikt met Entity Framework Core (EF Core) om met een database te werken. EF Core is een ORM-framework (object-relational mapping) dat de code voor gegevenstoegang vereenvoudigt die u moet schrijven.
De gemaakte modelklassen worden POCO--klassen genoemd, van Plain Old CLR-Objects. POCO-klassen hebben geen afhankelijkheid van EF Core. Ze definiëren alleen de eigenschappen van de gegevens die moeten worden opgeslagen in de database.
In deze zelfstudie worden eerst modelklassen gemaakt en EF Core de database maakt.
Een gegevensmodelklasse toevoegen
Klik met de rechtermuisknop op de map Modellen>>Klassetoevoegen. Geef het bestand de naam Movie.cs.
Werk het Models/Movie.cs-bestand bij met de volgende code:
using System.ComponentModel.DataAnnotations;
namespace MvcMovie.Models;
public class Movie
{
public int Id { get; set; }
public string? Title { get; set; }
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string? Genre { get; set; }
public decimal Price { get; set; }
}
De klasse Movie bevat een Id veld, dat vereist is voor de database voor de primaire sleutel.
Het kenmerk DataType op ReleaseDate geeft het type gegevens (Date) aan. Met dit kenmerk:
- De gebruiker hoeft geen tijdgegevens in te voeren in het datumveld.
- Alleen de datum wordt weergegeven, geen tijdinformatie.
DataAnnotations worden behandeld in een latere zelfstudie.
Het vraagteken na string geeft aan dat de eigenschap nullable is. Voor meer informatie, zie Nullbare referentietypen.
NuGet-pakketten toevoegen
Visual Studio installeert automatisch de vereiste pakketten.
Bouw het project als controle op compilerfouten.
Filmpagina's opzetten
Gebruik het scaffolding hulpprogramma om de Create-, Read-, Update- en Delete-pagina's (CRUD) voor het filmmodel te produceren.
Klik in Solution Explorer met de rechtermuisknop op de map Controllers en selecteer Add > New Scaffolded Item.
In het dialoogvenster Nieuw gescaffolde item toevoegen:
- Selecteer in het linkerdeelvenster Geïnstalleerd>Common>MVC.
- Selecteer MVC-controller met weergaven met behulp van Entity Framework.
- Selecteer Toevoegen.
Voltooi de MVC-controller toevoegen met weergaven, met behulp van het dialoogvenster Entity Framework:
- Selecteer in de vervolgkeuzelijst Modelklasse de optie Movie (MvcMovie.Models).
- Selecteer in de gegevenscontextklasse rij het + (plusteken).
- In het dialoogvenster Gegevenscontext toevoegen wordt de klassenaam MvcMovie.Data.MvcMovieContext gegenereerd.
- Selecteer Toevoegen.
- Selecteer in de vervolgkeuzelijst DatabaseproviderSQL Server.
- Weergaven en controllernaam: behoud de standaardwaarde.
- Selecteer Toevoegen.
Als u een foutbericht krijgt, selecteert u een tweede keer toevoegen om het opnieuw te proberen.
Met scaffolding worden de volgende pakketten toegevoegd:
Microsoft.EntityFrameworkCore.SqlServerMicrosoft.EntityFrameworkCore.ToolsMicrosoft.VisualStudio.Web.CodeGeneration.Design
Met scaffolding maakt u het volgende:
- Een filmscontroller:
Controllers/MoviesController.cs -
Razor bestanden weergeven voor pagina's maken, verwijderen, details, bewerken en Index:
Views/Movies/*.cshtml - Een databasecontextklasse:
Data/MvcMovieContext.cs
De scaffolding werkt het volgende bij:
- Voegt vereiste pakketverwijzingen in het
MvcMovie.csprojprojectbestand in. - Registreert de databasecontext in het
Program.cs-bestand. - Voegt een database-verbindingsreeks toe aan het bestand
appsettings.json.
Het automatisch maken van deze bestanden en bestandsupdates wordt bekend als scaffolding.
De pagina's in de scaffolded kunnen nog niet worden gebruikt omdat de database niet bestaat. Het uitvoeren van de app en het selecteren van de Film-app koppeling resulteert in een Kan de database niet openen of geen dergelijke tabel: Film foutbericht.
Bouw de app om te controleren of er geen fouten zijn.
Initiële migratie
Gebruik de functie EF CoreMigrations om de database te maken. Migraties is een verzameling hulpprogramma's waarmee een database wordt gemaakt en bijgewerkt zodat deze overeenkomt met het gegevensmodel.
Selecteer in het menu ToolsNuGet Pakketbeheer>Pakketbeheer Console .
Voer in de Pakketbeheer Console (PMC) de volgende opdracht in:
Add-Migration InitialCreate
-
Add-Migration InitialCreate: genereert eenMigrations/{timestamp}_InitialCreate.csmigratiebestand. Het argumentInitialCreateis de migratienaam. Elke naam kan worden gebruikt, maar volgens de conventie wordt een naam geselecteerd die de migratie beschrijft. Omdat dit de eerste migratie is, bevat de gegenereerde klasse code om het databaseschema te maken. Het databaseschema is gebaseerd op het model dat is opgegeven in de klasseMvcMovieContext.
De volgende waarschuwing wordt weergegeven, die in een latere stap wordt behandeld:
Er is geen winkeltype opgegeven voor de decimale eigenschap 'Prijs' voor entiteitstype 'Film'. Hierdoor worden waarden stilzwijgend afgekapt als ze niet in de standaardprecisie en schaal passen. Geef expliciet het kolomtype sql-server op dat alle waarden in 'OnModelCreating' kan bevatten met behulp van HasColumnType, geef precisie en schaal op met behulp van HasPrecision of configureer een waardeconversieprogramma met hasconversion.
Voer in de PMC de volgende opdracht in:
Update-Database
-
Update-Database: Hiermee wordt de database bijgewerkt naar de meest recente migratie; de database is met de vorige opdracht gemaakt. Met deze opdracht wordt de methodeUpuitgevoerd in hetMigrations/{time-stamp}_InitialCreate.cs-bestand, waarmee de database wordt gemaakt.
Zie EF Core voor meer informatie over de PMC-hulpprogramma's voor EF Core.
De app testen
Voer de app uit en selecteer de koppeling Movie App.
Als u een uitzondering krijgt die vergelijkbaar is met het volgende, hebt u mogelijk het Update-Database-commando gemist in stap van de-migraties:
SqlException: Cannot open database "MvcMovieContext-1" requested by the login. The login failed.
Note
Mogelijk kunt u geen decimale komma's invoeren in het veld Price. Ter ondersteuning van jQuery-validatie voor niet-Engelse landinstellingen die een komma (",") gebruiken voor een decimaalteken en voor niet-US-English datumnotaties, moet de app worden geglobaliseerd. Voor instructies voor globalisering, zie de GitHub issue.
De gegenereerde databasecontextklasse en -registratie onderzoeken
Met EF Corewordt gegevenstoegang uitgevoerd met behulp van een model. Een model bestaat uit entiteitsklassen en een contextobject dat een sessie met de database vertegenwoordigt. Met het contextobject kunt u gegevens opvragen en opslaan. De databasecontext is afgeleid van Microsoft. EntityFrameworkCore.DbContext en geeft de entiteiten op die moeten worden opgenomen in het gegevensmodel.
Met scaffolding wordt de contextklasse van de Data/MvcMovieContext.cs database gemaakt:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using MvcMovie.Models;
namespace MvcMovie.Data
{
public class MvcMovieContext : DbContext
{
public MvcMovieContext (DbContextOptions<MvcMovieContext> options)
: base(options)
{
}
public DbSet<MvcMovie.Models.Movie> Movie { get; set; } = default!;
}
}
Met de voorgaande code maakt u een eigenschap DbSet<Movie> die de films in de database vertegenwoordigt.
Afhankelijkheidsinjectie
ASP.NET Core is gebouwd met dependency injectie (DI). Services, zoals de databasecontext, worden geregistreerd bij DI in Program.cs. Deze services worden aangeboden aan componenten die ze nodig hebben via constructorparameters.
In het bestand Controllers/MoviesController.cs gebruikt de constructor afhankelijkheidsinjectie om de MvcMovieContext databasecontext in de controller te injecteren. De databasecontext wordt gebruikt in elk van de CRUD methoden in de controller.
Scaffolding heeft de volgende gemarkeerde code gegenereerd in Program.cs:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<MvcMovieContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("MvcMovieContext") ?? throw new InvalidOperationException("Connection string 'MvcMovieContext' not found.")));
Het ASP.NET Core-configuratiesysteem leest de database 'MvcMovieContext' verbindingsreeks.
Bekijk de gegenereerde database verbindingsreeks
Scaffolding heeft een verbindingsreeks toegevoegd aan het bestand appsettings.json:
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"AllowedHosts": "*",
"ConnectionStrings": {
"MvcMovieContext": "Server=(localdb)\\mssqllocaldb;Database=MvcMovieContext-4ebefa10-de29-4dea-b2ad-8a8dc6bcf374;Trusted_Connection=True;MultipleActiveResultSets=true"
}
}
Voor lokale ontwikkeling leest het ASP.NET Core-configuratiesysteem de sleutel ConnectionString uit het bestand appsettings.json.
De InitialCreate-klasse
Bekijk het Migrations/{timestamp}_InitialCreate.cs migratiebestand:
using System;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace MvcMovie.Migrations
{
/// <inheritdoc />
public partial class InitialCreate : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "Movie",
columns: table => new
{
Id = table.Column<int>(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
Title = table.Column<string>(type: "nvarchar(max)", nullable: true),
ReleaseDate = table.Column<DateTime>(type: "datetime2", nullable: false),
Genre = table.Column<string>(type: "nvarchar(max)", nullable: true),
Price = table.Column<decimal>(type: "decimal(18,2)", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_Movie", x => x.Id);
});
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "Movie");
}
}
}
In de voorgaande code:
-
InitialCreate.Upmaakt de tabel Movie aan en configureertIdals primaire sleutel. -
InitialCreate.Downworden de schemawijzigingen die door deUpmigratie zijn aangebracht, teruggezet.
Afhankelijkheidsinjectie in de controller
Open het bestand Controllers/MoviesController.cs en bekijk de constructor:
public class MoviesController : Controller
{
private readonly MvcMovieContext _context;
public MoviesController(MvcMovieContext context)
{
_context = context;
}
De constructor gebruikt afhankelijkheidsinjectie om de databasecontext (MvcMovieContext) in de controller te injecteren. De databasecontext wordt gebruikt in elk van de CRUD methoden in de controller.
Test de Creëer pagina. Voer gegevens in en verzend deze.
Test de bewerken, detailsen pagina's verwijderen.
Sterk getypte modellen en de @model richtlijn
Eerder in deze zelfstudie hebt u gezien hoe een controller gegevens of objecten aan een weergave kan doorgeven met behulp van de ViewData woordenlijst. De ViewData woordenlijst is een dynamisch object dat een handige, laat-gebonden manier biedt om informatie door te geven aan een weergave.
MVC biedt de mogelijkheid tot het doorgeven van sterk getypte modelobjecten aan een weergave. Deze sterk getypeerde benadering maakt controle van code tijdens de compileertijd mogelijk. Het scaffold-mechanisme heeft een sterk getypeerd model doorgegeven in de MoviesController-klasse en weergaven.
Bekijk de gegenereerde methode Details in het bestand Controllers/MoviesController.cs:
// GET: Movies/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null)
{
return NotFound();
}
var movie = await _context.Movie
.FirstOrDefaultAsync(m => m.Id == id);
if (movie == null)
{
return NotFound();
}
return View(movie);
}
De parameter id wordt over het algemeen doorgegeven als routegegevens. Bijvoorbeeld https://localhost:{PORT}/movies/details/1 reeksen:
- De controller voor de
movies-controller, het eerste URL-segment. - De actie voor
details, het tweede URL-segment. - Het
idtot 1, het laatste URL-segment.
De id kan worden doorgegeven met een querystring, zoals in het volgende voorbeeld:
https://localhost:{PORT}/movies/details?id=1
De parameter id wordt gedefinieerd als een nullable type (int?) in gevallen waarin de id waarde niet is opgegeven.
Een lambda-expressie wordt doorgegeven aan de methode FirstOrDefaultAsync om filmentiteiten te selecteren die overeenkomen met de routegegevens of querytekenreekswaarde.
var movie = await _context.Movie
.FirstOrDefaultAsync(m => m.Id == id);
Als er een film wordt gevonden, wordt een exemplaar van het Movie model doorgegeven aan de Details weergave:
return View(movie);
Bekijk de inhoud van het Views/Movies/Details.cshtml-bestand:
@model MvcMovie.Models.Movie
@{
ViewData["Title"] = "Details";
}
<h1>Details</h1>
<div>
<h4>Movie</h4>
<hr />
<dl class="row">
<dt class = "col-sm-2">
@Html.DisplayNameFor(model => model.Title)
</dt>
<dd class = "col-sm-10">
@Html.DisplayFor(model => model.Title)
</dd>
<dt class = "col-sm-2">
@Html.DisplayNameFor(model => model.ReleaseDate)
</dt>
<dd class = "col-sm-10">
@Html.DisplayFor(model => model.ReleaseDate)
</dd>
<dt class = "col-sm-2">
@Html.DisplayNameFor(model => model.Genre)
</dt>
<dd class = "col-sm-10">
@Html.DisplayFor(model => model.Genre)
</dd>
<dt class = "col-sm-2">
@Html.DisplayNameFor(model => model.Price)
</dt>
<dd class = "col-sm-10">
@Html.DisplayFor(model => model.Price)
</dd>
</dl>
</div>
<div>
<a asp-action="Edit" asp-route-id="@Model.Id">Edit</a> |
<a asp-action="Index">Back to List</a>
</div>
De @model-instructie boven aan het weergavebestand geeft het type object op dat door de weergave wordt verwacht. Toen de filmcontroller werd gemaakt, werd de volgende @model instructie opgenomen:
@model MvcMovie.Models.Movie
Deze @model richtlijn geeft toegang tot de film die door de controller aan de weergave is doorgegeven. Het Model-object is sterk getypeerd. In de Details.cshtml-weergave geeft de code bijvoorbeeld elk filmveld door aan de DisplayNameFor- en DisplayFor-HTML-helpers met het sterk getypeerde Model-object. De Create en Edit methoden en weergaven geven ook een Movie modelobject door.
Bekijk de Index.cshtml-weergave en de methode Index in de controller Films. U ziet hoe de code een List-object maakt wanneer deze de methode View aanroept. De code geeft deze Movies lijst door vanuit de actiemethode Index aan de weergave:
// GET: Movies
public async Task<IActionResult> Index()
{
return View(await _context.Movie.ToListAsync());
}
De code retourneert probleemdetails als de eigenschap Movie van de gegevenscontext null is.
Toen de filmcontroller werd gemaakt, bevatte scaffolding de volgende @model instructie bovenaan het Index.cshtml-bestand.
@model IEnumerable<MvcMovie.Models.Movie>
De @model-instructie maakt toegang mogelijk tot de lijst met films die de controller aan de weergave heeft doorgegeven door gebruik te maken van een sterk getypt Model-object. In de weergave Index.cshtml doorloopt de code bijvoorbeeld de films met een foreach-instructie over het sterk getypte Model-object.
@model IEnumerable<MvcMovie.Models.Movie>
@{
ViewData["Title"] = "Index";
}
<h1>Index</h1>
<p>
<a asp-action="Create">Create New</a>
</p>
<table class="table">
<thead>
<tr>
<th>
@Html.DisplayNameFor(model => model.Title)
</th>
<th>
@Html.DisplayNameFor(model => model.ReleaseDate)
</th>
<th>
@Html.DisplayNameFor(model => model.Genre)
</th>
<th>
@Html.DisplayNameFor(model => model.Price)
</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model) {
<tr>
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.ReleaseDate)
</td>
<td>
@Html.DisplayFor(modelItem => item.Genre)
</td>
<td>
@Html.DisplayFor(modelItem => item.Price)
</td>
<td>
<a asp-action="Edit" asp-route-id="@item.Id">Edit</a> |
<a asp-action="Details" asp-route-id="@item.Id">Details</a> |
<a asp-action="Delete" asp-route-id="@item.Id">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Omdat het Model-object sterk is getypt als een IEnumerable<Movie>-object, wordt elk item in de lus getypt als Movie. De compiler valideert onder andere de typen die in de code worden gebruikt.