4. rész, modell hozzáadása egy ASP.NET Core MVC-alkalmazáshoz

Által Rick Anderson és Jon P Smith.

Ebben az oktatóanyagban osztályokat adunk hozzá az adatbázisokban lévő filmek kezeléséhez. Ezek az osztályok az MVC alkalmazás "Model" része.

Ezek a modellosztályok az Entity Framework Core (EF Core) használatával működnek együtt egy adatbázissal. EF Core Egy objektum-relációs leképezési (ORM) keretrendszer, amely leegyszerűsíti az írandó adatelérési kódot.

A létrehozott modellosztályokat POCO-osztályoknak nevezzük a Plain Old CLR Objectsből. A POCO-osztályok nem függenek a EF Core. Csak az adatbázisban tárolandó adatok tulajdonságait határozzák meg.

Ebben az oktatóanyagban a modellosztályok jönnek létre először, és EF Core létrehozza az adatbázist.

Adatmodell-osztály hozzáadása

Visual Studio

Kattintson a jobb gombbal a Models mappára >Hozzáadás>Osztály. A fájl neve legyen Movie.cs.

Visual Studio Code

Adjon hozzá egy, a Movie.cs mappához elnevezett fájlt.

Frissítse a Models/Movie.cs fájlt a következő kóddal:

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

Az Movie osztály tartalmaz egy Id mezőt, amelyet az adatbázis az elsődleges kulcshoz szükséges.

A DataType rajta lévő ReleaseDate attribútum megadja az adatok típusát (Date). Ezzel az attribútummal:

• A felhasználónak nem kell időadatokat megadnia a dátum mezőben.
• Csak a dátum jelenik meg, az időadatok nem.

A DataAnnotations egy későbbi oktatóanyagban kerülnek tárgyalásra.

Az string utáni kérdőjel azt jelzi, hogy a tulajdonság null értékű. További információért tekintse meg: Null értékű hivatkozástípusok.

NuGet-csomagok hozzáadása

Visual Studio

A Visual Studio automatikusan telepíti a szükséges csomagokat.

Állítsa össze a projektet fordítóhibák ellenőrzéseként.

Visual Studio Code

Nyisson meg egy parancsablakot a projektkönyvtárban. A projektkönyvtár az a könyvtár, amely a Program.cs és .csproj fájlokat tartalmazza.

Futtassa a következő .NET CLI-parancsokat:

dotnet tool uninstall --global dotnet-aspnet-codegenerator
dotnet tool install --global dotnet-aspnet-codegenerator
dotnet tool uninstall --global dotnet-ef
dotnet tool install --global dotnet-ef
dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet add package Microsoft.EntityFrameworkCore.SQLite
dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools

Az előző parancsok hozzáadják a következőt:

• A EF Core parancssori felületének (CLI) eszközei
• Az aspnet-codegenerator keretrendszert építő eszköz.
• Tervezési időeszközök EF Core
• A EF Core SQLite-szolgáltató, amely függőségként telepíti a EF Core csomagot.
• Állványzathoz szükséges csomagok: Microsoft.VisualStudio.Web.CodeGeneration.Design és Microsoft.EntityFrameworkCore.SqlServer.

Ha több olyan környezetkonfigurációról szeretne útmutatást adni, amely lehetővé teszi az alkalmazások számára az adatbázis-környezetek környezet szerinti konfigurálását, tekintse meg ASP.NET Core futtatókörnyezeteket.

Note

Alapértelmezés szerint a telepíteni kívánt .NET bináris fájlok architektúrája a jelenleg futó operációsrendszer-architektúrát jelöli. Ha másik operációsrendszer-architektúrát szeretne megadni, tekintse meg dotnet eszköz telepítését, az --arch lehetőséget. További információ: GitHub-probléma dotnet/AspNetCore.Docs #29262.

A Visual Studio Code-ban nyomja le a Ctrl+F5 billentyűkombinációt az alkalmazás hibakeresés nélküli futtatásához.

A szerkesztőterület alatti Panel válassza a PROBLÉMÁK lapot, vagy a Nézet menüben válassza a Problémák lehetőséget, ha jelenleg nincs nézetben. Ellenőrizze, hogy nincsenek-e fordítási hibák.

Filmoldalak előkészítése

Használja a keretrendszer eszközt a Create, Read, Update, és Delete (CRUD) oldalak készítéséhez a film modell számára.

Visual Studio

A Megoldáskezelőben kattintson a jobb gombbal a Vezérlők mappára, és válassza az Új állványozott elem hozzáadása >lehetőséget.

Az Új vázolt elem hozzáadása párbeszédpanelen:

• A bal oldali panelen válassza a Telepített>közös>MVC lehetőséget.
• Válassza ki a nézetekkel rendelkező MVC-vezérlőt az Entity Framework használatával.
• Válassza a Hozzáadás lehetőséget.

Töltse ki az Entity Frameworköt használó nézetekkel rendelkező MVC-vezérlő hozzáadása párbeszédpanelt:

• A Modell osztály legördülő menüjében válassza a Mozgókép (MvcMovie.Models) lehetőséget.
• Az Data context class sorban válassza ki a + (plusz) jelet.
  • Az Adatkörnyezet hozzáadása párbeszédpanelen létre jön az MvcMovie.Data.MvcMovieContext osztálynév.
  • Válassza a Hozzáadás lehetőséget.
• Az Adatbázis-szolgáltató legördülő listában válassza SQL Serverlehetőséget.
• Nézetek és vezérlő neve: Tartsa meg az alapértelmezett értéket.
• Válassza a Hozzáadás lehetőséget.

Ha hibaüzenet jelenik meg, válassza az Add a second time to try it again (Második próbálkozás hozzáadása) lehetőséget.

Az állványzat a következő csomagokat adja hozzá:

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

Az állványzat a következőket hozza létre:

• Filmvezérlő: Controllers/MoviesController.cs
• Razor fájlok megtekintése létrehozási, törlési, részleteki, szerkesztési és indexelési lapokhoz: Views/Movies/*.cshtml
• Adatbázis környezeti osztálya: Data/MvcMovieContext.cs

Az állványzat a következőket frissíti:

• Beszúrja a szükséges csomaghivatkozásokat a MvcMovie.csproj projektfájlba.
• Regisztrálja az adatbázis-környezetet a Program.cs fájlban.
• Hozzáad egy adatbázis-kapcsolati sztringet a appsettings.json fájlhoz.

Ezeknek a fájloknak és fájlfrissítéseknek az automatikus létrehozását állványzatnak nevezzük.

Az állványozott lapok még nem használhatók, mert az adatbázis nem létezik. Az alkalmazás futtatása és a Filmalkalmazás hivatkozásra történő kattintás az adatbázis nem nyitható meg vagy nincs ilyen tábla: Movie hibaüzenetet eredményez.

Hozza létre az alkalmazást annak ellenőrzéséhez, hogy nincsenek-e hibák.

Visual Studio Code

Nyisson meg egy parancsablakot a projektkönyvtárban. A projektkönyvtár az a könyvtár, amely a Program.cs és .csproj fájlokat tartalmazza.

MacOS és Linux rendszeren exportálja az állványzat eszközútvonalát:

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

Futtassa a következő parancsot:

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

Az alábbi táblázat a ASP.NET Core-kódgenerátor paramétereit ismerteti:

Parameter	Description
-m	A modell neve.
-dc	Az adatkörnyezet.
--relativeFolderPath	A fájlok létrehozásához a relatív kimeneti mappa elérési útja.
--useDefaultLayout|-udl	A nézetekhez az alapértelmezett elrendezést kell használni.
--referenceScriptLibraries	Hozzáadja _ValidationScriptsPartial a lapok szerkesztéséhez és létrehozásához.
--databaseProvider sqlite	Adja meg DbContext , hogy az SQLite-t kell használnia az SQL Server helyett.

Használja a h kapcsolót, hogy segítséget kapjon a aspnet-codegenerator controller parancshoz:

dotnet aspnet-codegenerator controller -h

További információ: dotnet aspnet-codegenerator

Az állványzat a következőket hozza létre:

• Filmvezérlő: Controllers/MoviesController.cs
• Razor fájlok megtekintése létrehozási, törlési, részleteki, szerkesztési és indexelési lapokhoz: Views/Movies/*.cshtml
• Adatbázis környezeti osztálya: Data/MvcMovieContext.cs

Az állványzat a következőket frissíti:

• Az adatbázis-környezet regisztrálása a Program.cs fájlban
• Hozzáad egy adatbázis-kapcsolati sztringet a appsettings.json fájlhoz.

Ezeknek a fájloknak és fájlfrissítéseknek az automatikus létrehozását állványzatnak nevezzük.

Az állványozott lapok még nem használhatók, mert az adatbázis nem létezik. Az alkalmazás futtatása és a Filmalkalmazás hivatkozásra történő kattintás az adatbázis nem nyitható meg vagy nincs ilyen tábla: Movie hibaüzenetet eredményez.

Hozza létre az alkalmazást annak ellenőrzéséhez, hogy nincsenek-e hibák.

SQLite használata fejlesztéshez, SQL Server éles környezetben

Az alábbi kiemelt kód bemutatja Program.cs hogyan használható az SQLite a fejlesztésben és az SQL Server termelési környezetben.

var builder = WebApplication.CreateBuilder(args);

if (builder.Environment.IsDevelopment())
{
    builder.Services.AddDbContext<MvcMovieContext>(options =>
        options.UseSqlite(builder.Configuration.GetConnectionString("MvcMovieContext")));
}
else
{
    builder.Services.AddDbContext<MvcMovieContext>(options =>
        options.UseSqlServer(builder.Configuration.GetConnectionString("ProductionMvcMovieContext")));
}

Kezdeti migrálás

Az adatbázis létrehozásához használja a EF CoreMigrálás funkciót . A migráció egy olyan eszközkészlet, amely létrehoz és frissít egy adatbázist az adatmodellel összhangban.

Visual Studio

Az Eszközök menüben válassza a NuGet Package Manager Csomagkezelő>konzolt .

A Package Manager-konzolon (PMC) adja meg a következő parancsot:

Add-Migration InitialCreate

• Add-Migration InitialCreate: Migrálási Migrations/{timestamp}_InitialCreate.cs fájlt hoz létre. A InitialCreate argumentum a migráció neve. Bármilyen név használható, de konvenció szerint az áttelepítést leíró név van kiválasztva. Mivel ez az első migrálás, a létrehozott osztály az adatbázisséma létrehozásához szükséges kódot tartalmazza. Az adatbázisséma az osztályban MvcMovieContext megadott modellen alapul.

A következő figyelmeztetés jelenik meg, amely egy későbbi lépésben lesz kezelve:

Az 'Movie' entitástípus 'Price' nevű tizedes tulajdonságához nincs megadva tárolótípus. Ez az értékek csonkolásához vezet, ha nem illeszkednek az alapértelmezett pontossághoz és mértékhez. Explicit módon adja meg azt az SQL Server-oszloptípust, amely képes az "OnModelCreating" összes értékének elhelyezésére a HasColumnType használatával, adja meg a pontosságot és a skálázást a HasPrecision használatával, vagy konfiguráljon egy értékkonvertert a "HasConversion" használatával.

A PMC-ben adja meg a következő parancsot:

Update-Database

• Update-Database: Frissíti az adatbázist a legújabb migrálásra, amelyet az előző parancs hozott létre. Ez a parancs futtatja a metódust Up a Migrations/{time-stamp}_InitialCreate.cs fájlban, amely létrehozza az adatbázist.

A PMC-eszközökkel kapcsolatos további információkért EF Corelásd EF Core az eszközökre vonatkozó referencia - PMC-t a Visual Studióban.

Visual Studio Code

Futtassa a következő .NET CLI-parancsot:

dotnet ef migrations add InitialCreate

• ef migrations add InitialCreate: Migrálási Migrations/{timestamp}_InitialCreate.cs fájlt hoz létre. A InitialCreate argumentum a migráció neve. Bármilyen név használható, de konvenció szerint az áttelepítést leíró név van kiválasztva. Ez az első migrálás, ezért a létrehozott osztály az adatbázisséma létrehozásához szükséges kódot tartalmazza. Az adatbázisséma az osztályban, a MvcMovieContextData/MvcMovieContext.cs fájlban megadott modellen alapul.

A következő figyelmeztetés jelenik meg, amely egy későbbi lépésben lesz kezelve:

Az 'Movie' entitástípus 'Price' nevű tizedes tulajdonságához nincs megadva tárolótípus. Ez az értékek csonkolásához vezet, ha nem illeszkednek az alapértelmezett pontossághoz és mértékhez. Explicit módon adja meg azt az SQL Server-oszloptípust, amely képes az "OnModelCreating" összes értékének elhelyezésére a HasColumnType használatával, adja meg a pontosságot és a skálázást a HasPrecision használatával, vagy konfiguráljon egy értékkonvertert a "HasConversion" használatával.

Futtassa a következő .NET CLI-parancsot:

dotnet ef database update

• ef database update: Frissíti az adatbázist a legújabb migrálásra, amelyet az előző parancs hozott létre. Ez a parancs futtatja a metódust Up a Migrations/{time-stamp}_InitialCreate.cs fájlban, amely létrehozza az adatbázist.

További információ több szolgáltató, például a Microsoft SQL Server és az SQLite fenntartásáról: Migrálás több szolgáltatóval.

Az alkalmazás tesztelése

Visual Studio

Futtassa az alkalmazást, és válassza a Filmalkalmazás hivatkozást.

Ha a következőhöz hasonló kivételt kap, előfordulhat, hogy a Update-Database kihagyta a parancsot:

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

Visual Studio Code

Futtassa az alkalmazást, és válassza a Filmalkalmazás hivatkozást.

Ha a következőhöz hasonló kivételt kap, előfordulhat, hogy a dotnet ef database update kihagyta a parancsot:

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

Note

Előfordulhat, hogy nem tud tizedesvesszőt beírni a Price mezőbe. Az olyan nem angol nyelvű területi beállítások jQuery-érvényesítésének támogatásához, amelyek vesszőt (",") használnak tizedesvesszőhöz és nem US-English dátumformátumokhoz, az alkalmazást globalizálni kell. A globalizációval kapcsolatos utasításokért tekintse meg a ésGitHub-problémát.

A létrehozott adatbázis környezeti osztályának és regisztrációjának vizsgálata

Ezzel EF Coreaz adathozzáférést egy modell használatával hajtja végre. A modell entitásosztályokból és környezeti objektumból áll, amelyek az adatbázissal való munkamenetet jelölik. A környezeti objektum lehetővé teszi az adatok lekérdezését és mentését. Az adatbázis-környezet a Microsoft.EntityFrameworkCore.DbContext fájlból származik, és megadja az adatmodellbe felvenni kívánt entitásokat.

Az állványzat létrehozza az Data/MvcMovieContext.cs adatbázis környezeti osztályát:

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

Az előző kód létrehoz egy DbSet Movie< tulajdonságot>, amely az adatbázisban lévő filmeket jelöli.

Függőséginjektálás

ASP.NET Core függőséginjektálással (DI) épül fel. Az olyan szolgáltatások, mint az adatbázis-környezet, a DI-ben vannak regisztrálva.Program.cs Ezeket a szolgáltatásokat konstruktorparamétereken keresztül biztosítjuk azoknak az összetevőknek, amelyek megkövetelik őket.

A fájlban a Controllers/MoviesController.cs konstruktor függőséginjektálással injektálja az MvcMovieContext adatbázis-környezetet a vezérlőbe. Az adatbázis-környezet a vezérlőben található CRUD-metódusok mindegyikében használatos.

Az előzetes kódgenerálás a következő kiemelt kódot generálta a(z) Program.cs alatt.

Visual Studio

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<MvcMovieContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("MvcMovieContext") ?? throw new InvalidOperationException("Connection string 'MvcMovieContext' not found.")));

Visual Studio Code

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<MvcMovieContext>(options =>
    options.UseSqlite(builder.Configuration.GetConnectionString("MvcMovieContext")));

A ASP.NET Core konfigurációs rendszer beolvassa az "MvcMovieContext" adatbázis kapcsolati sztringet.

A létrehozott adatbázis kapcsolati sztringjének vizsgálata

Az állványzat hozzáadott egy kapcsolati karakterláncot a appsettings.json fájlhoz.

Visual Studio

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "MvcMovieContext": "Server=(localdb)\\mssqllocaldb;Database=MvcMovieContext-4ebefa10-de29-4dea-b2ad-8a8dc6bcf374;Trusted_Connection=True;MultipleActiveResultSets=true"
  }
}

Visual Studio Code

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "MvcMovieContext": "Data Source=MvcMovie.db"
  }
}

A helyi fejlesztéshez a ASP.NET Core konfigurációs rendszer beolvassa a ConnectionString kulcsot a appsettings.json fájlból.

Az InitialCreate osztály

Vizsgálja meg a migrálási Migrations/{timestamp}_InitialCreate.cs fájlt:

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

Az előző kódban:

• InitialCreate.Up létrehozza a Movie táblát Id , és elsődleges kulcsként konfigurálja.
• InitialCreate.Down Visszaállítja a migrálás által végrehajtott sémamódosításokat Up .

Függőséginjektálás a vezérlőben

Nyissa meg a Controllers/MoviesController.cs fájlt, és vizsgálja meg a konstruktort:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

A konstruktor függőséginjektálással injektálja az adatbázis-környezetet (MvcMovieContext) a vezérlőbe. Az adatbázis-környezet a vezérlőben található CRUD-metódusok mindegyikében használatos.

Tesztelje a Létrehozás lapot. Adja meg és küldje el az adatokat.

Tesztelje a Szerkesztés, a Részletek és a Törlés lapot.

Erősen típusozott modellek és az @model irányelv

Az oktatóanyag korábbi részében láthatta, hogyan adhat át egy vezérlő adatokat vagy objektumokat egy nézetnek a ViewData szótár használatával. A ViewData szótár egy dinamikus objektum, amely kényelmes, késői kötésű módot biztosít az információk nézetbe való továbbítására.

Az MVC lehetővé teszi, hogy szorosan típusos modell objektumokat adjon át egy nézetnek. Ez a szigorúan típusos megközelítés lehetővé teszi a fordítási időben történő kód ellenőrzést. Az sablon mechanizmus egy erősen típusos modellt továbbított a MoviesController osztályban és nézetekben.

Vizsgálja meg a fájlban létrehozott Details metódust 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);
}

A id paramétert általában útvonaladatokként adjuk át. Például https://localhost:{PORT}/movies/details/1 készletek:

• A movies vezérlő első URL-szegmense a vezérlő számára.
• A második URL-szegmensre irányuló detailsművelet.
• A id 1-re van beállítva, az utolsó URL-szegmens.

A id lekérdezési sztringgel is átadható, ahogyan az alábbi példában is látható:

https://localhost:{PORT}/movies/details?id=1

A id paraméter null értékű típusként (int?) van definiálva abban az esetben, ha az id érték nincs megadva.

Egy lambda kifejezést adnak át a FirstOrDefaultAsync metódusnak, hogy kiválassza azokat a mozgókép-entitásokat, amelyek megfelelnek az útvonali adatoknak vagy a lekérdezési karakterlánc értéknek.

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

Ha egy filmet találunk, a Movie modell egy példányát átadjuk a Details nézetnek.

return View(movie);

Vizsgálja meg a Views/Movies/Details.cshtml fájl tartalmát:

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

A @model nézetfájl tetején található utasítás határozza meg a nézet által várt objektum típusát. A filmvezérlő létrehozásakor a következő @model utasítás lett belefoglalva:

@model MvcMovie.Models.Movie

Ez az @model irányelv hozzáférést biztosít ahhoz a filmhez, amelyet a vezérlő átadott a nézetnek. Az Model objektum erősen be van gépelve. Például a Details.cshtml nézetben a kód átadja az egyes film mezőket az DisplayNameFor és DisplayFor HTML Segítőknek az erősen típusos Model objektummal. A Create metódusok és Edit nézetek egy modellobjektumot Movie is átadnak.

Vizsgálja meg a Index.cshtml nézetet és a metódust Index a Filmek vezérlőben. Figyelje meg, hogy a kód hogyan hoz létre objektumot List , amikor meghívja a metódust View . A kód a műveletmetódusból a Movies nézetbe továbbítja a Index listát:

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

A kód a probléma részleteit adja vissza, ha az Movie adatkörnyezet tulajdonsága null.

A filmek vezérlőjének létrehozásakor a sablon a következő @model utasítást tartalmazta a Index.cshtml fájl tetején:

@model IEnumerable<MvcMovie.Models.Movie>

Az @model irányelv lehetővé teszi a filmek listájához való hozzáférést, amelyet a vezérlő egy erősen típusos Model objektummal adott át a nézetnek. A nézetben például a Index.cshtml kód egy utasítással foreach végighalad a filmeken az erősen gépelt Model objektumon:

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

Mivel az Model objektum erősen típusos IEnumerable<Movie> objektumként van típusosítva, a ciklus minden eleme Movie típusú. A fordító többek között ellenőrzi a kódban használt típusokat.

További erőforrások

• Entity Framework Core kezdőknek
• Segítők címkézése
• Globalizáció és lokalizáció

Előző: Következő nézet hozzáadása: Az SQL használata