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

V tomto kurzu se přidávají třídy pro správu filmů v databázi. Tyto třídy tvoří "Model" čá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 Modely, >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 Vynechatelné referenční typy.

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 aspnet-codegenerator pro generování kostry.
• Nástroje pro čas návrhu EF Core
• Poskytovatel SQLite, který nainstaluje balíček EF Core jako závislost.
• Balíčky potřebné pro generování struktury: Microsoft.VisualStudio.Web.CodeGeneration.Design a Microsoft.EntityFrameworkCore.SqlServer.

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

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, podívejte se na dotnet tool install, --arch možnost. Pro více informací se podívejte na GitHub issue dotnet/AspNetCore.Docs #29262.

V Visual Studio Code stisknutím klávesy Ctrl+F5 spusťte aplikaci 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.

Návrh stránek filmů

Pomocí nástroje pro generování základní kostry můžete vytvořit Create, Read, Update a Delete (CRUD) stránky pro model filmu.

Visual Studio

V Průzkumník řešení klikněte pravým tlačítkem na složku Controllers a vyberte Přidat > Nová scaffoldovaná položka.

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

• V levém podokně vyberte Nainstalované>Společné>MVC.
• 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řídy Model 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 Database provider 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.

Scaffolding přidá následující balíčky:

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

Vytváření základní struktury 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á řetězec připojení k databázi do souboru appsettings.json.

Automatické vytváření těchto souborů a jejich aktualizací se označuje jako scaffolding.

Stránky vytvořené pomocí šablony 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, kde budou vytvořeny soubory.
--useDefaultLayout|-udl	Pro zobrazení by se mělo použít výchozí rozložení.
--referenceScriptLibraries	Přidá _ValidationScriptsPartial na stránky pro úpravy a vytváření.
--databaseProvider sqlite	Zadejte, že DbContext by měl používat SQLite namísto SQL Serveru.

Použijte přepínač h pro zobrazení nápovědy k příkazu aspnet-codegenerator controller:

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

Scaffolding aktualizuje následující:

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

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 v Program.cs ukazuje, jak používat SQLite ve vývoji a SQL Server 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 Tools vyberte NuGet Správce balíčků>Správce balíčků Console .

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 ve třídě MvcMovieContext.

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 nepozorovaně zkrátí, pokud se nevejdou do výchozího nastavení přesnosti a škály. 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 Core naleznete v tématu EF Core tools reference - PMC v 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 specifikovaném ve třídě MvcMovieContext, v souboru Data/MvcMovieContext.cs.

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 nepozorovaně zkrátí, pokud se nevejdou do výchozí přesnosti a rozsahu. 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 jsou Microsoft SQL Server a SQLite, najdete v tématu Migrations 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 vynechali příkaz Update-Database v kroku migrace.

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 vynechali příkaz v kroku migrace dotnet ef database update:

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 dat než v angličtině, musí být aplikace globalizována. Pokyny ke globalizaci najdete v tématu tohoto GitHub problému.

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í scaffoldingu 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 je sestaven s použitím injektáže závislostí (DI). Služby, jako je například kontext databáze, jsou registrované přes 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.

Scaffolding 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 čte připojovací řetězec databáze "MvcMovieContext".

Prozkoumejte vygenerovaný řetězec připojení k databázi

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

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

Pro místní vývoj ASP.NET Core konfigurační systém přečte klíč ConnectionString ze souboru appsettings.json.

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 .

Injektování 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 využívá Dependency Injection k vložení kontextu databáze (MvcMovieContext) do kontroléru. 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 silně typované objekty modelu do zobrazení. Tento přístup silného typu umožňuje kontrolu kódu v čase kompilace. Mechanismus scaffoldingu předal model silného typování ve třídě MoviesController 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 nastavuje:

• Kontroler pro movies kontroler, první segment adresy URL.
• Akce pro details, druhý segment URL.
• Hodnota id až k 1, poslední segment adresy URL.

id lze předat pomocí řetězce dotazu, jak je uvedeno 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.

Lambda výraz se předává metodě FirstOrDefaultAsync k výběru filmových entit, které odpovídají směrovacím datům nebo hodnotě řetězce dotazu.

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

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

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ě typovaný. Například v Details.cshtml zobrazení kód předá každé pole filmu pomocníkům HTML DisplayNameFor a DisplayFor se silně typovaným Model objektem. Metody Create a Edit zobrazení také předávají Movie modelový objekt.

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í kontroleru pro filmy bylo v horní části souboru pomocí scaffoldingu zahrnuto následující prohlášení: @modelIndex.cshtml.

@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 pomocí příkazu, který iteruje přes foreach objekt 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ě typovaný jako IEnumerable<Movie>, každá položka ve smyčce je typovaná 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íci značek
• Globalizace a lokalizace

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