Část 4: Přidání modelu do aplikace ASP.NET Core MVC

Rick Anderson a Jon P Smith.

V tomto kurzu se přidávají třídy pro správu filmů v databázi. Tyto třídy jsou součástí aplikace MVC .

Tyto třídy modelu se používají s Entity Framework Core (EF Core) pro práci s databází. EF Core je rozhraní ORM (object-relational mapping), které zjednodušuje kód pro přístup k datům, který musíte napsat.

Vytvořené třídy modelu se označují jako třídy POCO z Plain Old CLR Objects. Třídy POCO nemají žádnou závislost na EF Core. Definují pouze vlastnosti dat, která mají být uložena v databázi.

V tomto kurzu se nejprve vytvoří třídy modelu a EF Core vytvoří databázi.

Přidání třídy datového modelu

Visual Studio

Klikněte pravým tlačítkem myši na složku > Přidat>třídu. Pojmenujte soubor Movie.cs.

Visual Studio Code

Přidejte soubor s názvem Movie.cs do složky Models .

Models/Movie.cs Aktualizujte soubor následujícím kódem:

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

Třída Movie obsahuje Id pole, které vyžaduje databáze pro primární klíč.

Atribut DataType pro ReleaseDate určuje typ dat (Date). S tímto atributem:

• Uživatel nemusí do pole kalendářního data zadávat informace o čase.
• Zobrazí se pouze datum, nikoli informace o čase.

Poznámky k datům jsou popsané v pozdějším kurzu.

Otazník po string značí, že vlastnost je nullable. Další informace naleznete v tématu Odkazové typy s možnou hodnotou Null.

Přidání balíčků NuGet

Visual Studio

Visual Studio automaticky nainstaluje požadované balíčky.

Sestavte projekt jako kontrolu chyb kompilátoru.

Visual Studio Code

Otevřete příkazové okno v adresáři projektu. Adresář projektu je adresář, který obsahuje soubory Program.cs a .csproj soubory.

Spusťte následující příkazy rozhraní příkazového řádku .NET:

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

Předchozí příkazy přidávají:

• Nástroje rozhraní příkazového řádku (CLI) proEF Core
• Nástroj pro generování uživatelského rozhraní aspnet-codegenerator.
• Nástroje pro čas návrhu pro EF Core
• EF Core Zprostředkovatel SQLite, který nainstaluje EF Core balíček jako závislost.
• Balíčky potřebné pro generování uživatelského rozhraní: Microsoft.VisualStudio.Web.CodeGeneration.Design a Microsoft.EntityFrameworkCore.SqlServer.

Pokyny ke konfiguraci více prostředí, které umožňují aplikaci konfigurovat kontexty databáze podle prostředí, naleznete v tématu prostředí ASP.NET Core runtime.

Note

Ve výchozím nastavení architektura binárních souborů .NET, které se mají nainstalovat, představuje aktuálně spuštěnou architekturu operačního systému. Pokud chcete zadat jinou architekturu operačního systému, přečtěte si téma instalace nástroje dotnet, možnost --arch. Další informace najdete v tématu o problému GitHubu dotnet/AspNetCore.Docs #29262.

V editoru Visual Studio Code stiskněte Ctrl+F5 ke spuštění aplikace bez ladění.

Na panelupod oblastí editoru vyberte kartu PROBLÉMY nebo v nabídce Zobrazení vyberte Problémy, pokud aktuálně není v zobrazení. Ověřte, že nedošlo k žádným chybám kompilace.

Stránky filmů vygenerované

Pomocí nástroje pro generování uživatelského rozhraní můžete vytvořit Createstránky , Read, Updatea Delete (CRUD) pro model filmu.

Visual Studio

V Průzkumník řešení klikněte pravým tlačítkem na složku Kontrolery a vyberte Přidat > novou vygenerovanou položku.

V dialogovém okně Přidat novou vygenerovanou položku :

• V levém podokně vyberte Nainstalované>>
• Vyberte kontroler MVC se zobrazeními pomocí Entity Frameworku.
• Vyberte Přidat.

Dokončete přidání kontroleru MVC se zobrazeními pomocí dialogového okna Entity Framework :

• V rozevíracím seznamu Třída modelu vyberte Movie (MvcMovie.Models).
• V řádku třídy kontextu dat vyberte znaménko + (plus).
  • V dialogovém okně Přidat kontext dat se vygeneruje název třídy MvcMovie.Data.MvcMovieContext .
  • Vyberte Přidat.
• V rozevíracím seznamu Poskytovatel databáze vyberte SQL Server.
• Zobrazení a název kontroleru: Ponechte výchozí nastavení.
• Vyberte Přidat.

Pokud se zobrazí chybová zpráva, vyberte Přidat podruhé a zkuste to znovu.

Generování uživatelského rozhraní přidá následující balíčky:

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

Generování uživatelského rozhraní vytvoří následující:

• Ovladač filmů: Controllers/MoviesController.cs
• Razor zobrazit soubory pro stránky Vytvořit, Odstranit, Podrobnosti, Upravit a Index : Views/Movies/*.cshtml
• Třída kontextu databáze: Data/MvcMovieContext.cs

Generování uživatelského rozhraní aktualizuje následující:

• Vloží požadované odkazy na balíčky do MvcMovie.csproj souboru projektu.
• Zaregistruje kontext databáze v Program.cs souboru.
• Přidá do appsettings.json souboru připojovací řetězec databáze.

Automatické vytváření těchto souborů a aktualizací souborů se označuje jako generování uživatelského rozhraní.

Vygenerované stránky se zatím nedají použít, protože databáze neexistuje. Spuštění aplikace a výběr odkazu Movie App má za následek nemožnost otevřít databázi nebo žádnou takovou tabulku: Chybová zpráva Film .

Sestavte aplikaci, abyste ověřili, že nedošlo k žádným chybám.

Visual Studio Code

Otevřete příkazové okno v adresáři projektu. Adresář projektu je adresář, který obsahuje soubory Program.cs a .csproj soubory.

V systému macOS a Linux exportujte cestu nástroje pro generování uživatelského rozhraní:

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

Spusťte následující příkaz:

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

Následující tabulka podrobně popisuje parametry generátoru kódu ASP.NET Core:

Parameter	Description
-m	Název modelu
-dc	Kontext dat.
--relativeFolderPath	Relativní cesta k výstupní složce pro vytvoření souborů.
--useDefaultLayout|-udl	Pro zobrazení by se mělo použít výchozí rozložení.
--referenceScriptLibraries	Přidá _ValidationScriptsPartial stránky pro úpravy a vytváření.
--databaseProvider sqlite	Zadaná DbContext hodnota by měla místo SQL Serveru používat SQLite.

h Pomocí přepínače získejte nápovědu k aspnet-codegenerator controller příkazu:

dotnet aspnet-codegenerator controller -h

Další informace naleznete v tématu dotnet aspnet-codegenerator

Generování uživatelského rozhraní vytvoří následující:

• Ovladač filmů: Controllers/MoviesController.cs
• Razor zobrazit soubory pro stránky Vytvořit, Odstranit, Podrobnosti, Upravit a Index : Views/Movies/*.cshtml
• Třída kontextu databáze: Data/MvcMovieContext.cs

Generování uživatelského rozhraní aktualizuje následující:

• Zaregistruje kontext databáze v Program.cs souboru.
• Přidá do appsettings.json souboru připojovací řetězec databáze.

Automatické vytváření těchto souborů a aktualizací souborů se označuje jako generování uživatelského rozhraní.

Vygenerované stránky se zatím nedají použít, protože databáze neexistuje. Spuštění aplikace a výběr odkazu Movie App má za následek nemožnost otevřít databázi nebo žádnou takovou tabulku: Chybová zpráva Film .

Sestavte aplikaci, abyste ověřili, že nedošlo k žádným chybám.

Použití SQLite pro vývoj, SQL Server pro produkční prostředí

Následující zvýrazněný kód Program.cs ukazuje, jak používat SQLite ve vývoji a SQL Serveru v produkčním prostředí.

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

Počáteční migrace

EF Core K vytvoření databáze použijte funkci Migrace. Migrace je sada nástrojů, které vytvářejí a aktualizují databázi tak, aby odpovídaly datovému modelu.

Visual Studio

V nabídce Nástroje vyberte Správce balíčků> Správce balíčků Konzola NuGet .

V konzole Správce balíčků (PMC) zadejte následující příkaz:

Add-Migration InitialCreate

• Add-Migration InitialCreate: Vygeneruje Migrations/{timestamp}_InitialCreate.cs soubor migrace. Argumentem InitialCreate je název migrace. Libovolný název lze použít, ale podle konvence je vybraný název, který popisuje migraci. Protože se jedná o první migraci, vygenerovaná třída obsahuje kód pro vytvoření schématu databáze. Schéma databáze je založeno na modelu zadaném MvcMovieContext ve třídě.

Zobrazí se následující upozornění, které je vyřešeno v pozdějším kroku:

Nebyl zadán žádný typ úložiště pro desetinnou vlastnost Price u typu entity Movie. To způsobí, že se hodnoty bezobslužně zkrátí, pokud se nevejdou do výchozí přesnosti a měřítka. Explicitně zadejte typ sloupce SERVERU SQL, který může obsahovat všechny hodnoty v onModelCreating pomocí HasColumnType, určit přesnost a škálování pomocí HasPrecision nebo nakonfigurovat převaděč hodnot pomocí HasConversion.

V PMC zadejte následující příkaz:

Update-Database

• Update-Database: Aktualizuje databázi na nejnovější migraci, kterou vytvořil předchozí příkaz. Tento příkaz spustí metodu UpMigrations/{time-stamp}_InitialCreate.cs v souboru, která vytvoří databázi.

Další informace o nástrojích PMC pro EF Corenaleznete v referenčních informacích EF Core k nástrojům – PMC v sadě Visual Studio.

Visual Studio Code

Spusťte následující příkaz rozhraní příkazového řádku .NET:

dotnet ef migrations add InitialCreate

• ef migrations add InitialCreate: Vygeneruje Migrations/{timestamp}_InitialCreate.cs soubor migrace. Argumentem InitialCreate je název migrace. Libovolný název lze použít, ale podle konvence je vybraný název, který popisuje migraci. Toto je první migrace, takže vygenerovaná třída obsahuje kód pro vytvoření schématu databáze. Schéma databáze je založeno na modelu zadaném MvcMovieContext ve třídě v Data/MvcMovieContext.cs souboru.

Zobrazí se následující upozornění, které je vyřešeno v pozdějším kroku:

Nebyl zadán žádný typ úložiště pro desetinnou vlastnost Price u typu entity Movie. To způsobí, že se hodnoty bezobslužně zkrátí, pokud se nevejdou do výchozí přesnosti a měřítka. Explicitně zadejte typ sloupce SERVERU SQL, který může obsahovat všechny hodnoty v onModelCreating pomocí HasColumnType, určit přesnost a škálování pomocí HasPrecision nebo nakonfigurovat převaděč hodnot pomocí HasConversion.

Spusťte následující příkaz rozhraní příkazového řádku .NET:

dotnet ef database update

• ef database update: Aktualizuje databázi na nejnovější migraci, kterou vytvořil předchozí příkaz. Tento příkaz spustí metodu UpMigrations/{time-stamp}_InitialCreate.cs v souboru, která vytvoří databázi.

Další informace o údržbě více poskytovatelů, jako je Microsoft SQL Server a SQLite, najdete v tématu Migrace s více poskytovateli.

Otestování aplikace

Visual Studio

Spusťte aplikaci a vyberte odkaz Filmová aplikace .

Pokud se zobrazí výjimka podobná následující, pravděpodobně jste příkaz v Update-Database migrace vynechali:

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

Visual Studio Code

Spusťte aplikaci a vyberte odkaz Filmová aplikace .

Pokud se zobrazí výjimka podobná následující, pravděpodobně jste příkaz v dotnet ef database update migrace vynechali:

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

Note

Do pole pravděpodobně nebudete moct zadávat desetinné čárky Price . Aby bylo možné podporovat ověřování jQuery pro neanglické národní prostředí, které používají čárku (",") pro desetinnou čárku a pro jiné formáty kalendářních dat než v ANGLIČTINĚ, musí být aplikace globalizována. Pokyny ke globalizaci najdete v tomto problému na GitHubu.

Prozkoumání vygenerované třídy kontextu databáze a registrace

Pomocí EF Coremodelu se provádí přístup k datům. Model se skládá z tříd entit a kontextového objektu, který představuje relaci s databází. Kontextový objekt umožňuje dotazování a ukládání dat. Kontext databáze je odvozen z Microsoft.EntityFrameworkCore.DbContext a určuje entity, které se mají zahrnout do datového modelu.

Generování uživatelského rozhraní vytvoří Data/MvcMovieContext.cs třídu kontextu databáze:

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

Předchozí kód vytvoří DbSet<Movie> vlastnost, která představuje filmy v databázi.

Injekce závislostí

ASP.NET Core se sestavuje pomocí injektáže závislostí (DI). Služby, jako je kontext databáze, jsou zaregistrované v adresáři DI v Program.cs. Tyto služby jsou poskytovány komponentám, které je vyžadují prostřednictvím parametrů konstruktoru.

Controllers/MoviesController.cs V souboru konstruktor používá injektáž závislostí k vložení MvcMovieContext kontextu databáze do kontroleru. Kontext databáze se používá v každé z metod CRUD v kontroleru.

Generování uživatelského rozhraní vygenerovalo následující zvýrazněný kód v Program.cs:

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

Konfigurační systém ASP.NET Core přečte připojovací řetězec databáze "MvcMovieContext".

Prozkoumání vygenerované databáze připojovací řetězec

Generování uživatelského rozhraní přidalo do appsettings.json souboru připojovací řetězec:

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

V případě místního vývoje ASP.NET Core klíč ze ConnectionString souboru.

Třída InitialCreate

Migrations/{timestamp}_InitialCreate.cs Prozkoumejte soubor migrace:

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

V předchozím kódu:

• InitialCreate.Up vytvoří tabulku Movie a nakonfiguruje Id jako primární klíč.
• InitialCreate.Down vrátí změny schématu provedené migrací Up .

Injektáž závislostí v kontroleru

Controllers/MoviesController.cs Otevřete soubor a prozkoumejte konstruktor:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

Konstruktor používá injektáž závislostí k vložení kontextu databáze (MvcMovieContext) do kontroleru. Kontext databáze se používá v každé z metod CRUD v kontroleru.

Otestujte stránku Vytvořit . Zadejte a odešlete data.

Otestujte stránky Upravit, Podrobnosti a Odstranit .

Modely silného typu a direktiva @model

Dříve v tomto kurzu jste viděli, jak může kontroler předávat data nebo objekty do zobrazení pomocí slovníku ViewData . Slovník ViewData je dynamický objekt, který poskytuje pohodlný pozdní způsob předávání informací do zobrazení.

MVC poskytuje možnost předat objekty modelu silného typu do zobrazení. Tento přístup silného typu umožňuje kontrolu kódu v čase kompilace. Mechanismus generování uživatelského rozhraní předal model silného MoviesController typu ve třídě a zobrazeních.

Prozkoumejte vygenerovanou Details metodu Controllers/MoviesController.cs v souboru:

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

Parametr id se obecně předává jako směrovací data. Například https://localhost:{PORT}/movies/details/1 sady:

• Kontroler na movies kontroler, první segment adresy URL.
• Akce na details, druhý segment adresy URL.
• Hodnota id 1, poslední segment adresy URL.

Dá id se předat pomocí řetězce dotazu, jak je znázorněno v následujícím příkladu:

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

Parametr id je definován jako typ s možnou hodnotou null (int?) v případech, kdy není zadána id hodnota.

Výraz lambda se předá FirstOrDefaultAsync metodě pro výběr entit filmů, které odpovídají hodnotě řetězce směrování nebo dotazu.

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

Pokud se film najde, předá se do Movie zobrazení instance Details modelu:

return View(movie);

Prozkoumejte obsah Views/Movies/Details.cshtml souboru:

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

Příkaz @model v horní části souboru zobrazení určuje typ objektu, který zobrazení očekává. Po vytvoření kontroleru videa se zahrnul následující @model příkaz:

@model MvcMovie.Models.Movie

Tato @model direktiva umožňuje přístup k filmu, který kontroler předal do zobrazení. Objekt Model je silně zadán. Například v Details.cshtml zobrazení kód předá každé pole DisplayNameFor videa pomocným rutině HTML DisplayFor se silným typem Model objektu. Metody Create a Edit zobrazení také předávají Movie objekt modelu.

Index.cshtml Prozkoumejte zobrazení a metodu Index v kontroleru Filmy. Všimněte si, jak kód vytvoří List objekt při volání View metody. Kód předá tento Movies seznam z Index metody akce do zobrazení:

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

Kód vrátí podrobnosti o problému, pokud Movie je vlastnost kontextu dat null.

Po vytvoření řadiče filmů obsahovalo generování uživatelského rozhraní v horní části @model souboru následující Index.cshtml příkaz:

@model IEnumerable<MvcMovie.Models.Movie>

Direktiva @model umožňuje přístup k seznamu filmů, které řadič předal zobrazení pomocí objektu silného Model typu. Například v Index.cshtml zobrazení kód prochází filmy s příkazem nad objektem foreach silného typu Model :

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

Vzhledem k tomu, že Model objekt je silně zadán jako IEnumerable<Movie> objekt, každá položka ve smyčce je zadána jako Movie. Kromě dalších výhod kompilátor ověřuje typy používané v kódu.

Dodatečné zdroje

• Entity Framework Core pro začátečníky
• Pomocné rutiny značek
• Globalizace a lokalizace

Předchozí: Přidání dalšího zobrazení: Práce s SQL