Del 4, lägg till en modell i en ASP.NET Core MVC-app

I den här självstudien har klasser lagts till för att hantera filmer i en databas. Dessa klasser är "Model"-delen av MVC-appen.

Dessa modellklasser används med Entity Framework Core (EF Core) för att arbeta med en databas. EF Core är ett ramverk för objektrelationsmappning (ORM) som förenklar den dataåtkomstkod som du måste skriva.

De modellklasser som skapas kallas POCO-klasser , från Plain Old CLR Objects. POCO-klasser har inget beroende av EF Core. De definierar bara egenskaperna för de data som ska lagras i databasen.

I den här självstudien skapas modellklasser först och EF Core skapar databasen.

Lägga till en datamodellklass

Uppdatera filen Models/Movie.cs med följande kod:

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

Klassen Movie innehåller ett Id fält som krävs av databasen för den primära nyckeln.

Attributet DataType på ReleaseDate anger typen av data (Date). Med det här attributet:

• Användaren behöver inte ange tidsinformation i datumfältet.
• Endast datumet visas, inte tidsinformation.

DataAnnotations behandlas i en senare handledning.

Frågetecknet efter string anger att egenskapen är null. För mer information, se nullbara referenstyper.

Lägga till NuGet-paket

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

Strukturera filmsidor

Använd verktyget scaffolding för att skapa Create, Read, Updateoch Delete (CRUD) sidor för filmmodellen.

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

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

dotnet aspnet-codegenerator controller -h

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

Inledande migrering

EF Core Använd migreringsfunktionen för att skapa databasen. Migreringar är en uppsättning verktyg som skapar och uppdaterar en databas som matchar datamodellen.

Add-Migration InitialCreate

Update-Database

dotnet ef migrations add InitialCreate

dotnet ef database update

Testa appen

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

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

Granska den genererade databaskontextklassen och registreringen

Med EF Coreutförs dataåtkomst med hjälp av en modell. En modell består av entitetsklasser och ett kontextobjekt som representerar en session med databasen. Med kontextobjektet kan du köra frågor mot och spara data. Databaskontexten härleds från Microsoft.EntityFrameworkCore.DbContext och anger de entiteter som ska ingå i datamodellen.

Byggnadsställningar skapar databaskontextklassen Data/MvcMovieContext.cs :

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

Föregående kod skapar en DbSet<Movie-egenskap> som representerar filmerna i databasen.

Beroendeinsprutning

ASP.NET Core skapas med beroendeinmatning (DI). Tjänster, till exempel databaskontexten, registreras med DI i Program.cs. Dessa tjänster tillhandahålls till komponenter som kräver dem via konstruktorparametrar.

Controllers/MoviesController.cs I filen använder konstruktorn Dependency Injection för att injicera databaskontexten MvcMovieContext i kontrollern. Databaskontexten används i var och en av de CRUD- metoderna i kontrollanten.

Scaffolding genererade följande markerade kod i 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.")));

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

Konfigurationssystemet ASP.NET Core läser databasanslutningssträngen "MvcMovieContext".

Granska den genererade databasanslutningssträngen

Scaffolding lade till en anslutningssträng i appsettings.json filen:

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

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

För lokal utveckling läser konfigurationssystemet ASP.NET Core nyckeln från ConnectionString-filen.

Klassen InitialCreate

Granska migreringsfilen Migrations/{timestamp}_InitialCreate.cs :

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

I koden ovan:

• InitialCreate.Up skapar tabellen Film och konfigurerar Id som primär nyckel.
• InitialCreate.Down återställer schemaändringarna som gjorts av migreringen Up .

Beroendeinmatning i kontrollanten

Controllers/MoviesController.cs Öppna filen och granska konstruktorn:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

Konstruktorn använder beroendeinmatning för att mata in databaskontexten (MvcMovieContext) i kontrollanten. Databaskontexten används i var och en av de CRUD- metoderna i kontrollanten.

Testa Skapa-sidan. Ange och skicka data.

Testa sidorna Redigera, Information och Ta bort .

Starkt skrivna modeller och @model direktivet

Tidigare i den här självstudien såg du hur en kontrollant kan skicka data eller objekt till en vy med hjälp av ViewData ordlistan. Ordlistan ViewData är ett dynamiskt objekt som ger ett bekvämt sent bundet sätt att skicka information till en vy.

MVC ger möjlighet att skicka starkt typerade modellobjekt till en vy. Med det här starkt typade tillvägagångssättet möjliggörs kompileringskontroll. Scaffolding-mekanismen överförde en starkt typad modell i klassen och vyerna i MoviesController.

Granska den genererade Details metoden i Controllers/MoviesController.cs filen:

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

Parametern id skickas vanligtvis som routningsdata. Till exempel https://localhost:{PORT}/movies/details/1 sätter:

• Kontrollern till kontrollern movies, det första URL-segmentet.
• Åtgärden för details, den andra URL-segmentet.
• Från id till 1, det sista URL-segmentet.

id Kan skickas med en frågesträng, som i följande exempel:

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

Parametern id definieras som en nullbar typ (int?) i de fall då id värdet inte anges.

Ett lambda-uttryck skickas till FirstOrDefaultAsync metoden för att välja filmentiteter som matchar routningsdata eller frågesträngsvärdet.

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

Om en film hittas skickas en instans av Movie modellen till Details vyn:

return View(movie);

Granska innehållet i Views/Movies/Details.cshtml filen:

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

Instruktionen @model överst i vyfilen anger vilken typ av objekt som vyn förväntar sig. När filmkontrollanten skapades inkluderades följande @model instruktion:

@model MvcMovie.Models.Movie

Det här @model direktivet ger åtkomst till filmen som kontrollanten skickade till vyn. Objektet Model är starkt typat. I Details.cshtml-vyn skickar koden varje filmfält till DisplayNameFor och DisplayFor HTML-hjälpare med det starkt typerade Model-objektet. Metoderna Create och Edit vyerna skickar också ett Movie modellobjekt.

Granska Index.cshtml vyn och Index metoden i filmmodulens kontroll. Observera hur koden skapar ett List objekt när den anropar View metoden. Koden skickar den här Movies listan från Index åtgärdsmetoden till vyn:

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

Koden returnerar probleminformation om Movie egenskapen för datakontexten är null.

När filmkontrollern skapades innehöll scaffold följande @model sats överst i Index.cshtml filen.

@model IEnumerable<MvcMovie.Models.Movie>

Direktivet @model ger åtkomst till listan över filmer som kontrollanten skickade till vyn med hjälp av ett Model objekt som är starkt skrivet. I vyn loopar koden till exempel Index.cshtml igenom filmerna med en foreach instruktion över det starkt typerade Model objektet:

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

Eftersom objektet Model är starkt skrivet som ett IEnumerable<Movie> objekt, skrivs varje objekt i loopen som Movie. Kompilatorn validerar bland annat de typer som används i koden.

Ytterligare resurser

• Entity Framework Core för nybörjare
• Tag Helpers
• Globalisering och lokalisering

I den här självstudien har klasser lagts till för att hantera filmer i en databas. Dessa klasser är "Model"-delen av MVC-appen.

Dessa modellklasser används med Entity Framework Core (EF Core) för att arbeta med en databas. EF Core är ett ramverk för objektrelationsmappning (ORM) som förenklar den dataåtkomstkod som du måste skriva.

De modellklasser som skapas kallas POCO-klasser , från Plain Old CLR Objects. POCO-klasser har inget beroende av EF Core. De definierar bara egenskaperna för de data som ska lagras i databasen.

I den här självstudien skapas modellklasser först och EF Core skapar databasen.

Lägga till en datamodellklass

Uppdatera filen Models/Movie.cs med följande kod:

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

Klassen Movie innehåller ett Id fält som krävs av databasen för den primära nyckeln.

Attributet DataType på ReleaseDate anger typen av data (Date). Med det här attributet:

• Användaren behöver inte ange tidsinformation i datumfältet.
• Endast datumet visas, inte tidsinformation.

DataAnnotations behandlas i en senare handledning.

Frågetecknet efter string anger att egenskapen är null. För mer information, se nullbara referenstyper.

Lägga till NuGet-paket

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

Strukturera filmsidor

Använd verktyget scaffolding för att skapa Create, Read, Updateoch Delete (CRUD) sidor för filmmodellen.

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

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

dotnet aspnet-codegenerator controller -h

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

Inledande migrering

EF Core Använd migreringsfunktionen för att skapa databasen. Migreringar är en uppsättning verktyg som skapar och uppdaterar en databas som matchar datamodellen.

Add-Migration InitialCreate
Update-Database

dotnet ef migrations add InitialCreate

dotnet ef database update

Testa appen

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

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

Granska den genererade databaskontextklassen och registreringen

Med EF Coreutförs dataåtkomst med hjälp av en modell. En modell består av entitetsklasser och ett kontextobjekt som representerar en session med databasen. Med kontextobjektet kan du köra frågor mot och spara data. Databaskontexten härleds från Microsoft.EntityFrameworkCore.DbContext och anger de entiteter som ska ingå i datamodellen.

Byggnadsställningar skapar databaskontextklassen Data/MvcMovieContext.cs :

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

Föregående kod skapar en DbSet<Movie-egenskap> som representerar filmerna i databasen.

Beroendeinsprutning

ASP.NET Core skapas med beroendeinmatning (DI). Tjänster, till exempel databaskontexten, registreras med DI i Program.cs. Dessa tjänster tillhandahålls till komponenter som kräver dem via konstruktorparametrar.

Controllers/MoviesController.cs I filen använder konstruktorn Dependency Injection för att injicera databaskontexten MvcMovieContext i kontrollern. Databaskontexten används i var och en av de CRUD- metoderna i kontrollanten.

Scaffolding genererade följande markerade kod i Program.cs:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<MvcMovieContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("MvcMovieContext")));

var builder = WebApplication.CreateBuilder(args);

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

Konfigurationssystemet ASP.NET Core läser databasanslutningssträngen "MvcMovieContext".

Granska den genererade databasanslutningssträngen

Scaffolding lade till en anslutningssträng i appsettings.json filen:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "MvcMovieContext": "Data Source=MvcMovieContext-ea7a4069-f366-4742-bd1c-3f753a804ce1.db"
  }
}

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

För lokal utveckling läser konfigurationssystemet ASP.NET Core nyckeln från ConnectionString-filen.

Klassen InitialCreate

Granska migreringsfilen Migrations/{timestamp}_InitialCreate.cs :

using System;
using Microsoft.EntityFrameworkCore.Migrations;

#nullable disable

namespace MvcMovie.Migrations
{
    public partial class InitialCreate : Migration
    {
        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);
                });
        }

        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "Movie");
        }
    }
}

I koden ovan:

• InitialCreate.Up skapar tabellen Film och konfigurerar Id som primär nyckel.
• InitialCreate.Down återställer schemaändringarna som gjorts av migreringen Up .

Beroendeinmatning i kontrollanten

Controllers/MoviesController.cs Öppna filen och granska konstruktorn:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

Konstruktorn använder beroendeinmatning för att mata in databaskontexten (MvcMovieContext) i kontrollanten. Databaskontexten används i var och en av de CRUD- metoderna i kontrollanten.

Testa Skapa-sidan. Ange och skicka data.

Testa sidorna Redigera, Information och Ta bort .

Starkt skrivna modeller och @model direktivet

Tidigare i den här självstudien såg du hur en kontrollant kan skicka data eller objekt till en vy med hjälp av ViewData ordlistan. Ordlistan ViewData är ett dynamiskt objekt som ger ett bekvämt sent bundet sätt att skicka information till en vy.

MVC ger möjlighet att skicka starkt typerade modellobjekt till en vy. Med det här starkt typade tillvägagångssättet möjliggörs kompileringskontroll. Scaffolding-mekanismen överförde en starkt typad modell i klassen och vyerna i MoviesController.

Granska den genererade Details metoden i Controllers/MoviesController.cs filen:

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

Parametern id skickas vanligtvis som routningsdata. Till exempel https://localhost:5001/movies/details/1 sätter:

• Kontrollern till kontrollern movies, det första URL-segmentet.
• Åtgärden för details, den andra URL-segmentet.
• Från id till 1, det sista URL-segmentet.

id Kan skickas med en frågesträng, som i följande exempel:

https://localhost:5001/movies/details?id=1

Parametern id definieras som en nullbar typ (int?) i de fall då id värdet inte anges.

Ett lambda-uttryck skickas till FirstOrDefaultAsync metoden för att välja filmentiteter som matchar routningsdata eller frågesträngsvärdet.

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

Om en film hittas skickas en instans av Movie modellen till Details vyn:

return View(movie);

Granska innehållet i Views/Movies/Details.cshtml filen:

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

Instruktionen @model överst i vyfilen anger vilken typ av objekt som vyn förväntar sig. När filmkontrollanten skapades inkluderades följande @model instruktion:

@model MvcMovie.Models.Movie

Det här @model direktivet ger åtkomst till filmen som kontrollanten skickade till vyn. Objektet Model är starkt typat. I Details.cshtml-vyn skickar koden varje filmfält till DisplayNameFor och DisplayFor HTML-hjälpare med det starkt typerade Model-objektet. Metoderna Create och Edit vyerna skickar också ett Movie modellobjekt.

Granska Index.cshtml vyn och Index metoden i filmmodulens kontroll. Observera hur koden skapar ett List objekt när den anropar View metoden. Koden skickar den här Movies listan från Index åtgärdsmetoden till vyn:

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

Koden returnerar probleminformation om Movie egenskapen för datakontexten är null.

När filmkontrollern skapades innehöll scaffold följande @model sats överst i Index.cshtml filen.

@model IEnumerable<MvcMovie.Models.Movie>

Direktivet @model ger åtkomst till listan över filmer som kontrollanten skickade till vyn med hjälp av ett Model objekt som är starkt skrivet. I vyn loopar koden till exempel Index.cshtml igenom filmerna med en foreach instruktion över det starkt typerade Model objektet:

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

Eftersom objektet Model är starkt skrivet som ett IEnumerable<Movie> objekt, skrivs varje objekt i loopen som Movie. Kompilatorn validerar bland annat de typer som används i koden.

Ytterligare resurser

• Entity Framework Core för nybörjare
• Tag Helpers
• Globalisering och lokalisering

I den här självstudien har klasser lagts till för att hantera filmer i en databas. Dessa klasser är "Model"-delen av MVC-appen.

Dessa modellklasser används med Entity Framework Core (EF Core) för att arbeta med en databas. EF Core är ett ramverk för objektrelationsmappning (ORM) som förenklar den dataåtkomstkod som du måste skriva.

De modellklasser som skapas kallas POCO-klasser , från Plain Old CLR Objects. POCO-klasser har inget beroende av EF Core. De definierar bara egenskaperna för de data som ska lagras i databasen.

I den här självstudien skapas modellklasser först och EF Core skapar databasen.

Lägga till en datamodellklass

Uppdatera filen Models/Movie.cs med följande kod:

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

Klassen Movie innehåller ett Id fält som krävs av databasen för den primära nyckeln.

Attributet DataType på ReleaseDate anger typen av data (Date). Med det här attributet:

• Användaren behöver inte ange tidsinformation i datumfältet.
• Endast datumet visas, inte tidsinformation.

DataAnnotations behandlas i en senare handledning.

Frågetecknet efter string anger att egenskapen är null. För mer information, se nullbara referenstyper.

Lägga till NuGet-paket

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

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

Strukturera filmsidor

Använd verktyget scaffolding för att skapa Create, Read, Updateoch Delete (CRUD) sidor för filmmodellen.

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

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

dotnet aspnet-codegenerator controller -h

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

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

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

dotnet aspnet-codegenerator controller -h

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

Inledande migrering

EF Core Använd migreringsfunktionen för att skapa databasen. Migreringar är en uppsättning verktyg som skapar och uppdaterar en databas som matchar datamodellen.

Add-Migration InitialCreate
Update-Database

dotnet ef migrations add InitialCreate

dotnet ef database update

Testa appen

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

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

Granska den genererade databaskontextklassen och registreringen

Med EF Coreutförs dataåtkomst med hjälp av en modell. En modell består av entitetsklasser och ett kontextobjekt som representerar en session med databasen. Med kontextobjektet kan du köra frågor mot och spara data. Databaskontexten härleds från Microsoft.EntityFrameworkCore.DbContext och anger de entiteter som ska ingå i datamodellen.

Byggnadsställningar skapar databaskontextklassen Data/MvcMovieContext.cs :

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

Föregående kod skapar en DbSet<Movie-egenskap> som representerar filmerna i databasen.

Beroendeinsprutning

ASP.NET Core skapas med beroendeinmatning (DI). Tjänster, till exempel databaskontexten, registreras med DI i Program.cs. Dessa tjänster tillhandahålls till komponenter som kräver dem via konstruktorparametrar.

Controllers/MoviesController.cs I filen använder konstruktorn Dependency Injection för att injicera databaskontexten MvcMovieContext i kontrollern. Databaskontexten används i var och en av de CRUD- metoderna i kontrollanten.

Scaffolding genererade följande markerade kod i Program.cs:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<MvcMovieContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("MvcMovieContext")));

var builder = WebApplication.CreateBuilder(args);

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

Konfigurationssystemet ASP.NET Core läser databasanslutningssträngen "MvcMovieContext".

Granska den genererade databasanslutningssträngen

Scaffolding lade till en anslutningssträng i appsettings.json filen:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "MvcMovieContext": "Data Source=MvcMovieContext-ea7a4069-f366-4742-bd1c-3f753a804ce1.db"
  }
}

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

För lokal utveckling läser konfigurationssystemet ASP.NET Core nyckeln från ConnectionString-filen.

Klassen InitialCreate

Granska migreringsfilen Migrations/{timestamp}_InitialCreate.cs :

using System;
using Microsoft.EntityFrameworkCore.Migrations;

#nullable disable

namespace MvcMovie.Migrations
{
    public partial class InitialCreate : Migration
    {
        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);
                });
        }

        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "Movie");
        }
    }
}

I koden ovan:

• InitialCreate.Up skapar tabellen Film och konfigurerar Id som primär nyckel.
• InitialCreate.Down återställer schemaändringarna som gjorts av migreringen Up .

Beroendeinmatning i kontrollanten

Controllers/MoviesController.cs Öppna filen och granska konstruktorn:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

Konstruktorn använder beroendeinmatning för att mata in databaskontexten (MvcMovieContext) i kontrollanten. Databaskontexten används i var och en av de CRUD- metoderna i kontrollanten.

Testa Skapa-sidan. Ange och skicka data.

Testa sidorna Redigera, Information och Ta bort .

Starkt skrivna modeller och @model direktivet

Tidigare i den här självstudien såg du hur en kontrollant kan skicka data eller objekt till en vy med hjälp av ViewData ordlistan. Ordlistan ViewData är ett dynamiskt objekt som ger ett bekvämt sent bundet sätt att skicka information till en vy.

MVC ger möjlighet att skicka starkt typerade modellobjekt till en vy. Med det här starkt typade tillvägagångssättet möjliggörs kompileringskontroll. Scaffolding-mekanismen överförde en starkt typad modell i klassen och vyerna i MoviesController.

Granska den genererade Details metoden i Controllers/MoviesController.cs filen:

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

Parametern id skickas vanligtvis som routningsdata. Till exempel https://localhost:5001/movies/details/1 sätter:

• Kontrollern till kontrollern movies, det första URL-segmentet.
• Åtgärden för details, den andra URL-segmentet.
• Från id till 1, det sista URL-segmentet.

id Kan skickas med en frågesträng, som i följande exempel:

https://localhost:5001/movies/details?id=1

Parametern id definieras som en nullbar typ (int?) i de fall då id värdet inte anges.

Ett lambda-uttryck skickas till FirstOrDefaultAsync metoden för att välja filmentiteter som matchar routningsdata eller frågesträngsvärdet.

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

Om en film hittas skickas en instans av Movie modellen till Details vyn:

return View(movie);

Granska innehållet i Views/Movies/Details.cshtml filen:

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

Instruktionen @model överst i vyfilen anger vilken typ av objekt som vyn förväntar sig. När filmkontrollanten skapades inkluderades följande @model instruktion:

@model MvcMovie.Models.Movie

Det här @model direktivet ger åtkomst till filmen som kontrollanten skickade till vyn. Objektet Model är starkt typat. I Details.cshtml-vyn skickar koden varje filmfält till DisplayNameFor och DisplayFor HTML-hjälpare med det starkt typerade Model-objektet. Metoderna Create och Edit vyerna skickar också ett Movie modellobjekt.

Granska Index.cshtml vyn och Index metoden i filmmodulens kontroll. Observera hur koden skapar ett List objekt när den anropar View metoden. Koden skickar den här Movies listan från Index åtgärdsmetoden till vyn:

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

Koden returnerar probleminformation om Movie egenskapen för datakontexten är null.

När filmkontrollern skapades innehöll scaffold följande @model sats överst i Index.cshtml filen.

@model IEnumerable<MvcMovie.Models.Movie>

Direktivet @model ger åtkomst till listan över filmer som kontrollanten skickade till vyn med hjälp av ett Model objekt som är starkt skrivet. I vyn loopar koden till exempel Index.cshtml igenom filmerna med en foreach instruktion över det starkt typerade Model objektet:

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

Eftersom objektet Model är starkt skrivet som ett IEnumerable<Movie> objekt, skrivs varje objekt i loopen som Movie. Kompilatorn validerar bland annat de typer som används i koden.

Ytterligare resurser

• Entity Framework Core för nybörjare
• Tag Helpers
• Globalisering och lokalisering

I den här självstudien har klasser lagts till för att hantera filmer i en databas. Dessa klasser är "Model"-delen av MVC-appen.

Dessa modellklasser används med Entity Framework Core (EF Core) för att arbeta med en databas. EF Core är ett ramverk för objektrelationsmappning (ORM) som förenklar den dataåtkomstkod som du måste skriva.

De modellklasser som skapas kallas POCO-klasser , från Plain Old CLR Objects. POCO-klasser har inget beroende av EF Core. De definierar bara egenskaperna för de data som ska lagras i databasen.

I den här självstudien skapas modellklasser först och EF Core skapar databasen.

Lägga till en datamodellklass

Uppdatera filen Models/Movie.cs med följande kod:

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

Klassen Movie innehåller ett Id fält som krävs av databasen för den primära nyckeln.

Attributet DataType på ReleaseDate anger typen av data (Date). Med det här attributet:

• Användaren behöver inte ange tidsinformation i datumfältet.
• Endast datumet visas, inte tidsinformation.

DataAnnotations behandlas i en senare handledning.

Frågetecknet efter string anger att egenskapen är null. För mer information, se nullbara referenstyper.

Lägga till NuGet-paket

Install-Package Microsoft.EntityFrameworkCore.Design
Install-Package Microsoft.EntityFrameworkCore.SqlServer

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

Skapa projektet som en kontroll av kompilatorfel.

Strukturera filmsidor

Använd verktyget scaffolding för att skapa Create, Read, Updateoch Delete (CRUD) sidor för filmmodellen.

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

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

dotnet aspnet-codegenerator controller -h

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

Scaffolding skapar följande:

• En filmkontroller: Controllers/MoviesController.cs
• Razor visa filer för sidorna Skapa, Ta bort, Information, Redigera och Index : Views/Movies/*.cshtml
• En databaskontextklass: Data/MvcMovieContext.cs

Automatisk skapande av dessa filer och filuppdateringar kallas scaffolding.

Det går inte att använda de autogenererade sidorna ännu eftersom databasen inte finns. Om du kör appen och väljer länken Filmapp visas ett Felmeddelande om att det inte går att öppna databasen eller att det inte finns någon sådan tabell: Felmeddelande om film .

Skapa appen

Skapa appen. Kompilatorn genererar flera varningar om hur null värden hanteras. Mer information finns i det här GitHub-problemet och referenstyper som kan ogiltigförklaras .

För att ta bort varningarna från nullbara referenstyper, ta bort följande rad från MvcMovie.csproj-filen:

<Nullable>enable</Nullable>

Vi hoppas kunna åtgärda problemet i nästa version.

Inledande migrering

EF Core Använd migreringsfunktionen för att skapa databasen. Migreringar är en uppsättning verktyg som skapar och uppdaterar en databas som matchar datamodellen.

Add-Migration InitialCreate
Update-Database

  dotnet tool install --global dotnet-ef

dotnet ef migrations add InitialCreate
dotnet ef database update

Testa appen

Kör appen och välj länken Filmapp .

Om du får ett undantag som liknar följande kan du ha missat migreringssteget:

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

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

Granska den genererade databaskontextklassen och registreringen

Med EF Coreutförs dataåtkomst med hjälp av en modell. En modell består av entitetsklasser och ett kontextobjekt som representerar en session med databasen. Med kontextobjektet kan du köra frågor mot och spara data. Databaskontexten härleds från Microsoft.EntityFrameworkCore.DbContext och anger de entiteter som ska ingå i datamodellen.

Byggnadsställningar skapar databaskontextklassen Data/MvcMovieContext.cs :

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

Föregående kod skapar en DbSet<Movie-egenskap> som representerar filmerna i databasen.

Beroendeinsprutning

ASP.NET Core skapas med beroendeinmatning (DI). Tjänster, till exempel databaskontexten, registreras med DI i Program.cs. Dessa tjänster tillhandahålls till komponenter som kräver dem via konstruktorparametrar.

Controllers/MoviesController.cs I filen använder konstruktorn Dependency Injection för att injicera databaskontexten MvcMovieContext i kontrollern. Databaskontexten används i var och en av de CRUD- metoderna i kontrollanten.

Scaffolding genererade följande markerade kod i Program.cs:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<MvcMovieContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("MvcMovieContext")));

var builder = WebApplication.CreateBuilder(args);

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

Konfigurationssystemet ASP.NET Core läser databasanslutningssträngen "MvcMovieContext".

Granska den genererade databasanslutningssträngen

Scaffolding lade till en anslutningssträng i appsettings.json filen:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "MvcMovieContext": "Server=(localdb)\\mssqllocaldb;Database=MvcMovieContext-7dc5;Trusted_Connection=True;MultipleActiveResultSets=true"
  }
}

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

För lokal utveckling läser konfigurationssystemet ASP.NET Core nyckeln från ConnectionString-filen.

Klassen InitialCreate

Granska migreringsfilen Migrations/{timestamp}_InitialCreate.cs :

using System;
using Microsoft.EntityFrameworkCore.Migrations;

#nullable disable

namespace MvcMovie.Migrations
{
    public partial class InitialCreate : Migration
    {
        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);
                });
        }

        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "Movie");
        }
    }
}

I koden ovan:

• InitialCreate.Up skapar tabellen Film och konfigurerar Id som primär nyckel.
• InitialCreate.Down återställer schemaändringarna som gjorts av migreringen Up .

Beroendeinmatning i kontrollanten

Controllers/MoviesController.cs Öppna filen och granska konstruktorn:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

Konstruktorn använder beroendeinmatning för att mata in databaskontexten (MvcMovieContext) i kontrollanten. Databaskontexten används i var och en av de CRUD- metoderna i kontrollanten.

Testa Skapa-sidan. Ange och skicka data.

Testa sidorna Redigera, Information och Ta bort .

Starkt skrivna modeller och @model direktivet

Tidigare i den här självstudien såg du hur en kontrollant kan skicka data eller objekt till en vy med hjälp av ViewData ordlistan. Ordlistan ViewData är ett dynamiskt objekt som ger ett bekvämt sent bundet sätt att skicka information till en vy.

MVC ger möjlighet att skicka starkt typerade modellobjekt till en vy. Med det här starkt typade tillvägagångssättet möjliggörs kompileringskontroll. Scaffolding-mekanismen överförde en starkt typad modell i klassen och vyerna i MoviesController.

Granska den genererade Details metoden i Controllers/MoviesController.cs filen:

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

Parametern id skickas vanligtvis som routningsdata. Till exempel https://localhost:5001/movies/details/1 sätter:

• Kontrollern till kontrollern movies, det första URL-segmentet.
• Åtgärden för details, den andra URL-segmentet.
• Från id till 1, det sista URL-segmentet.

id Kan skickas med en frågesträng, som i följande exempel:

https://localhost:5001/movies/details?id=1

Parametern id definieras som en nullbar typ (int?) i de fall då id värdet inte anges.

Ett lambda-uttryck skickas till FirstOrDefaultAsync metoden för att välja filmentiteter som matchar routningsdata eller frågesträngsvärdet.

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

Om en film hittas skickas en instans av Movie modellen till Details vyn:

return View(movie);

Granska innehållet i Views/Movies/Details.cshtml filen:

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

Instruktionen @model överst i vyfilen anger vilken typ av objekt som vyn förväntar sig. När filmkontrollanten skapades inkluderades följande @model instruktion:

@model MvcMovie.Models.Movie

Det här @model direktivet ger åtkomst till filmen som kontrollanten skickade till vyn. Objektet Model är starkt typat. I Details.cshtml-vyn skickar koden varje filmfält till DisplayNameFor och DisplayFor HTML-hjälpare med det starkt typerade Model-objektet. Metoderna Create och Edit vyerna skickar också ett Movie modellobjekt.

Granska Index.cshtml vyn och Index metoden i filmmodulens kontroll. Observera hur koden skapar ett List objekt när den anropar View metoden. Koden skickar den här Movies listan från Index åtgärdsmetoden till vyn:

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

När filmkontrollern skapades innehöll scaffold följande @model sats överst i Index.cshtml filen.

@model IEnumerable<MvcMovie.Models.Movie>

Direktivet @model ger åtkomst till listan över filmer som kontrollanten skickade till vyn med hjälp av ett Model objekt som är starkt skrivet. I vyn loopar koden till exempel Index.cshtml igenom filmerna med en foreach instruktion över det starkt typerade Model objektet:

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

Eftersom objektet Model är starkt skrivet som ett IEnumerable<Movie> objekt, skrivs varje objekt i loopen som Movie. Kompilatorn validerar bland annat de typer som används i koden.

Ytterligare resurser

• Entity Framework Core för nybörjare
• Tag Helpers
• Globalisering och lokalisering

I den här självstudien har klasser lagts till för att hantera filmer i en databas. Dessa klasser är "Model"-delen av MVC-appen.

Dessa modellklasser används med Entity Framework Core (EF Core) för att arbeta med en databas. EF Core är ett ramverk för objektrelationsmappning (ORM) som förenklar den dataåtkomstkod som du måste skriva.

De modellklasser som skapas kallas POCO-klasser , från Plain Old CLR Objects. POCO-klasser har inget beroende av EF Core. De definierar bara egenskaperna för de data som ska lagras i databasen.

I den här självstudien skapas modellklasser först och EF Core skapar databasen.

Lägga till en datamodellklass

Uppdatera filen Models/Movie.cs med följande kod:

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

Klassen Movie innehåller ett Id fält som krävs av databasen för den primära nyckeln.

Attributet DataType på ReleaseDate anger typen av data (Date). Med det här attributet:

• Användaren behöver inte ange tidsinformation i datumfältet.
• Endast datumet visas, inte tidsinformation.

DataAnnotations behandlas i en senare handledning.

Lägga till NuGet-paket

Install-Package Microsoft.EntityFrameworkCore.Design

dotnet tool install --global dotnet-ef
dotnet tool install --global dotnet-aspnet-codegenerator
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

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net5.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore" Version="5.0.0-*" />
    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="5.0.0-*" />
    <PackageReference Include="Microsoft.AspNetCore.Identity.UI" Version="5.0.0-*" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.0-*" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="5.0.0-*" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="5.0.0-*" />
    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="5.0.0-*" />
  </ItemGroup>

</Project>

dotnet tool install --global dotnet-aspnet-codegenerator

Skapa projektet som en kontroll av kompilatorfel.

Strukturera filmsidor

Använd verktyget scaffolding för att skapa Create, Read, Updateoch Delete (CRUD) sidor för filmmodellen.

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

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

dotnet aspnet-codegenerator controller -h

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)
    {
        services.AddControllersWithViews();

        services.AddDbContext<MvcMovieContext>(options =>
        {
            var connectionString = Configuration.GetConnectionString("MvcMovieContext");

            if (Environment.IsDevelopment())
            {
                options.UseSqlite(connectionString);
            }
            else
            {
                options.UseSqlServer(connectionString);
            }
        });
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Home/Error");
            app.UseHsts();
        }
        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllerRoute(
                name: "default",
                pattern: "{controller=Home}/{action=Index}/{id?}");
        });
    }
}

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

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

dotnet aspnet-codegenerator controller -h

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)
    {
        services.AddControllersWithViews();

        services.AddDbContext<MvcMovieContext>(options =>
        {
            var connectionString = Configuration.GetConnectionString("MvcMovieContext");

            if (Environment.IsDevelopment())
            {
                options.UseSqlite(connectionString);
            }
            else
            {
                options.UseSqlServer(connectionString);
            }
        });
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Home/Error");
            app.UseHsts();
        }
        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllerRoute(
                name: "default",
                pattern: "{controller=Home}/{action=Index}/{id?}");
        });
    }
}

Scaffolding skapar följande:

• En filmkontroller: Controllers/MoviesController.cs
• Razor visa filer för sidorna Skapa, Ta bort, Information, Redigera och Index : Views/Movies/*.cshtml
• En databaskontextklass: Data/MvcMovieContext.cs

Automatisk skapande av dessa filer och filuppdateringar kallas för strukturskapande.

Det går inte att använda de autogenererade sidorna ännu eftersom databasen inte finns. Om du kör appen och väljer länken Filmapp visas ett Felmeddelande om att det inte går att öppna databasen eller att det inte finns någon sådan tabell: Felmeddelande om film .

Inledande migrering

EF Core Använd migreringsfunktionen för att skapa databasen. Migreringar är en uppsättning verktyg som skapar och uppdaterar en databas för att matcha datamodellen.

Add-Migration InitialCreate
Update-Database

  dotnet tool install --global dotnet-ef

dotnet ef migrations add InitialCreate
dotnet ef database update

Testa appen

Kör appen och välj länken Filmapp .

Om du får ett undantag som liknar följande kan du ha missat migreringssteget:

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

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

Granska den genererade databaskontextklassen och registreringen

Med EF Coreutförs dataåtkomst med hjälp av en modell. En modell består av entitetsklasser och ett kontextobjekt som representerar en session med databasen. Med kontextobjektet kan du köra frågor mot och spara data. Databaskontexten härleds från Microsoft.EntityFrameworkCore.DbContext och anger de entiteter som ska ingå i datamodellen.

Byggnadsställningar skapar databaskontextklassen Data/MvcMovieContext.cs :

using Microsoft.EntityFrameworkCore;
using MvcMovie.Models;

namespace MvcMovie.Data
{
    public class MvcMovieContext : DbContext
    {
        public MvcMovieContext (DbContextOptions<MvcMovieContext> options)
            : base(options)
        {
        }

        public DbSet<Movie> Movie { get; set; }
    }
}

Föregående kod skapar en DbSet<Movie-egenskap> som representerar filmerna i databasen.

ASP.NET Core skapas med beroendeinmatning (DI). Tjänster, till exempel databaskontexten, måste registreras med DI i Startup. Komponenter som kräver dessa tjänster tillhandahålls via konstruktorparametrar.

Controllers/MoviesController.cs I filen använder konstruktorn Dependency Injection för att injicera databaskontexten MvcMovieContext i kontrollern. Databaskontexten används i var och en av de CRUD- metoderna i kontrollanten.

Scaffolding genererade följande markerade kod i Startup.ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();

    services.AddDbContext<MvcMovieContext>(options =>
    options.UseSqlServer(Configuration.GetConnectionString("MvcMovieContext")));
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    
    services.AddDbContext<MvcMovieContext>(options =>
    options.UseSqlite(Configuration.GetConnectionString("MvcMovieContext")));
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    
    services.AddDbContext<MvcMovieContext>(options =>
    options.UseSqlite(Configuration.GetConnectionString("MvcMovieContext")));
}

Konfigurationssystemet ASP.NET Core läser databasanslutningssträngen "MvcMovieContext".

Granska den genererade databasanslutningssträngen

Scaffolding lade till en anslutningssträng i appsettings.json filen:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "MvcMovieContext": "Server=(localdb)\\mssqllocaldb;Database=MvcMovieContext-1;Trusted_Connection=True;MultipleActiveResultSets=true"
  }
}

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

För lokal utveckling läser konfigurationssystemet ASP.NET Core nyckeln från ConnectionString-filen.

Klassen InitialCreate

Granska migreringsfilen Migrations/{timestamp}_InitialCreate.cs :

public partial class InitialCreate : Migration
{
    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);
            });
    }

    protected override void Down(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.DropTable(
            name: "Movie");
    }
}

I koden ovan:

• InitialCreate.Up skapar tabellen Film och konfigurerar Id som primär nyckel.
• InitialCreate.Down återställer schemaändringarna som gjorts av migreringen Up .

Beroendeinmatning i kontrollanten

Controllers/MoviesController.cs Öppna filen och granska konstruktorn:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

Konstruktorn använder beroendeinmatning för att mata in databaskontexten (MvcMovieContext) i kontrollanten. Databaskontexten används i var och en av de CRUD- metoderna i kontrollanten.

Testa Skapa-sidan. Ange och skicka data.

Testa sidorna Redigera, Information och Ta bort .

Starkt skrivna modeller och @model direktivet

Tidigare i den här självstudien såg du hur en kontrollant kan skicka data eller objekt till en vy med hjälp av ViewData ordlistan. Ordlistan ViewData är ett dynamiskt objekt som ger ett bekvämt sent bundet sätt att skicka information till en vy.

MVC ger möjlighet att skicka starkt typerade modellobjekt till en vy. Med det här starkt typade tillvägagångssättet möjliggörs kompileringskontroll. Scaffolding-mekanismen överförde en starkt typad modell i klassen och vyerna i MoviesController.

Granska den genererade Details metoden i Controllers/MoviesController.cs filen:

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

Parametern id skickas vanligtvis som routningsdata. Till exempel https://localhost:5001/movies/details/1 sätter:

• Kontrollern till kontrollern movies, det första URL-segmentet.
• Åtgärden för details, den andra URL-segmentet.
• Från id till 1, det sista URL-segmentet.

id Kan skickas med en frågesträng, som i följande exempel:

https://localhost:5001/movies/details?id=1

Parametern id definieras som en nullbar typ (int?) i de fall då id värdet inte anges.

Ett lambda-uttryck skickas till FirstOrDefaultAsync metoden för att välja filmentiteter som matchar routningsdata eller frågesträngsvärdet.

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

Om en film hittas skickas en instans av Movie modellen till Details vyn:

return View(movie);

Granska innehållet i Views/Movies/Details.cshtml filen:

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

Instruktionen @model överst i vyfilen anger vilken typ av objekt som vyn förväntar sig. När filmkontrollanten skapades inkluderades följande @model instruktion:

@model MvcMovie.Models.Movie

Det här @model direktivet ger åtkomst till filmen som kontrollanten skickade till vyn. Objektet Model är starkt typat. I Details.cshtml-vyn skickar koden varje filmfält till DisplayNameFor och DisplayFor HTML-hjälpare med det starkt typerade Model-objektet. Metoderna Create och Edit vyerna skickar också ett Movie modellobjekt.

Granska Index.cshtml vyn och Index metoden i filmmodulens kontroll. Observera hur koden skapar ett List objekt när den anropar View metoden. Koden skickar den här Movies listan från Index åtgärdsmetoden till vyn:

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

När filmkontrollern skapades innehöll scaffold följande @model sats överst i Index.cshtml filen.

@model IEnumerable<MvcMovie.Models.Movie>

Direktivet @model ger åtkomst till listan över filmer som kontrollanten skickade till vyn med hjälp av ett Model objekt som är starkt skrivet. I vyn loopar koden till exempel Index.cshtml igenom filmerna med en foreach instruktion över det starkt typerade Model objektet:

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

Eftersom objektet Model är starkt skrivet som ett IEnumerable<Movie> objekt, skrivs varje objekt i loopen som Movie. Kompilatorn validerar bland annat de typer som används i koden.

SQL-loggning av Entity Framework Core

Loggningskonfiguration tillhandahålls ofta av avsnittet Logging i appsettings.{Environment}.json filer. Om du vill logga SQL-instruktioner lägger du till "Microsoft.EntityFrameworkCore.Database.Command": "Information" i filen appsettings.Development.json:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=MyDB-2;Trusted_Connection=True;MultipleActiveResultSets=true"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
     ,"Microsoft.EntityFrameworkCore.Database.Command": "Information"
    }
  },
  "AllowedHosts": "*"
}

Med föregående JSON visas SQL-uttryck på kommandoraden och i Visual Studio-utdatafönstret.

Mer information finns i Loggning i .NET och ASP.NET Core och det här GitHub-problemet.

Ytterligare resurser

• Entity Framework Core för nybörjare
• Tag Helpers
• Globalisering och lokalisering

I den här självstudien har klasser lagts till för att hantera filmer i en databas. Dessa klasser är "Model"-delen av MVC-appen.

Dessa modellklasser används med Entity Framework Core (EF Core) för att arbeta med en databas. EF Core är ett ramverk för objektrelationsmappning (ORM) som förenklar den dataåtkomstkod som du måste skriva.

De modellklasser som skapas kallas POCO-klasser , från Plain Old CLR Objects. POCO-klasser har inget beroende av EF Core. De definierar bara egenskaperna för de data som ska lagras i databasen.

I den här självstudien skapas modellklasser först och EF Core skapar databasen.

Lägga till en datamodellklass

Uppdatera filen Movie.cs med följande kod:

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

Klassen Movie innehåller ett Id fält som krävs av databasen för den primära nyckeln.

Attributet DataType på ReleaseDate anger typen av data (Date). Med det här attributet:

• Användaren behöver inte ange tidsinformation i datumfältet.
• Endast datumet visas, inte tidsinformation.

DataAnnotations behandlas i en senare handledning.

Lägga till NuGet-paket

Install-Package Microsoft.EntityFrameworkCore.SqlServer

dotnet tool install --global dotnet-ef --version 3.1.9
dotnet tool install --global dotnet-aspnet-codegenerator --version 3.1.4
dotnet add package Microsoft.EntityFrameworkCore.Sqlite --version 3.1.9
dotnet add package Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore --version 3.1.9
dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design --version 3.1.4
dotnet add package Microsoft.EntityFrameworkCore.Design --version 3.1.9
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 3.1.9
dotnet add package Microsoft.Extensions.Logging.Debug --version 3.1.9

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>netcoreapp3.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore" Version="3.1.0" />
    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="3.1.0" />
    <PackageReference Include="Microsoft.AspNetCore.Identity.UI" Version="3.1.0" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="3.1.0" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="3.1.0" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="3.1.0" />
    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="3.1.0" />
  </ItemGroup>

</Project>

Skapa en databaskontextklass

En databaskontextklass krävs för att samordna EF Core funktioner (Skapa, Läsa, Uppdatera, Ta bort) för Movie modellen. Databaskontexten härleds från Microsoft.EntityFrameworkCore.DbContext och anger de entiteter som ska ingå i datamodellen.

Skapa en datamapp.

Lägg till en Data/MvcMovieContext.cs fil med följande kod:

using Microsoft.EntityFrameworkCore;
using MvcMovie.Models;

namespace MvcMovie.Data
{
    public class MvcMovieContext : DbContext
    {
        public MvcMovieContext (DbContextOptions<MvcMovieContext> options)
            : base(options)
        {
        }

        public DbSet<Movie> Movie { get; set; }
    }
}

Föregående kod skapar egenskapen DbSet<Movie> för entitetsuppsättningen. I Entity Framework-terminologi motsvarar en entitetsuppsättning vanligtvis en databastabell. En entitet motsvarar en rad i tabellen.

Registrera databaskontexten

ASP.NET Core skapas med beroendeinmatning (DI). Tjänster (till exempel DB-kontexten EF Core ) måste registreras med DI under programstarten. Komponenter som kräver dessa tjänster (till exempel Razor Pages) tillhandahålls via konstruktorparametrar. Konstruktorkoden som hämtar en DB-kontextinstans visas senare i självstudien. I det här avsnittet registrerar du databaskontexten med DI-containern.

Lägg till följande using-instruktioner högst upp i Startup.cs:

using MvcMovie.Data;
using Microsoft.EntityFrameworkCore;

Lägg till följande markerade kod i Startup.ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();

    services.AddDbContext<MvcMovieContext>(options =>
    options.UseSqlServer(Configuration.GetConnectionString("MvcMovieContext")));
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    
    services.AddDbContext<MvcMovieContext>(options =>
    options.UseSqlite(Configuration.GetConnectionString("MvcMovieContext")));
}

Namnet på anslutningssträngen skickas till kontexten genom att anropa en metod för ett DbContextOptions-objekt. För lokal utveckling läser konfigurationssystemet ASP.NET Core anslutningssträngen appsettings.json från filen.

Granska databasanslutningssträngen

Lägg till en anslutningssträng i appsettings.json filen:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "MvcMovieContext": "Server=(localdb)\\mssqllocaldb;Database=MvcMovieContext-1;Trusted_Connection=True;MultipleActiveResultSets=true"
  }
}

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

Skapa projektet som en kontroll av kompilatorfel.

Strukturera filmsidor

Använd verktyget scaffolding för att skapa CRUD-sidor (Create, Read, Update och Delete) för filmmodellen.

Du kan inte använda de genererade sidorna ännu eftersom databasen inte finns. Om du kör appen och klickar på länken Filmapp får du ett felmeddelande om att det inte går att öppna databasen eller att det inte finns någon sådan tabell: Felmeddelande om film .

Inledande migrering

EF Core Använd migreringsfunktionen för att skapa databasen. Migreringar är en uppsättning verktyg som gör att du kan skapa och uppdatera en databas så att den matchar din datamodell.

Add-Migration InitialCreate
Update-Database

  dotnet tool install --global dotnet-ef

dotnet ef migrations add InitialCreate
dotnet ef database update

Klassen InitialCreate

Granska migreringsfilen Migrations/{timestamp}_InitialCreate.cs :

public partial class InitialCreate : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.CreateTable(
            name: "Movie",
            columns: table => new
            {
                Id = table.Column<int>(nullable: false)
                    .Annotation("SqlServer:ValueGenerationStrategy", 
                                 SqlServerValueGenerationStrategy.IdentityColumn),
                Title = table.Column<string>(nullable: true),
                ReleaseDate = table.Column<DateTime>(nullable: false),
                Genre = table.Column<string>(nullable: true),
                Price = table.Column<decimal>(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_Movie", x => x.Id);
            });
    }

    protected override void Down(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.DropTable(
            name: "Movie");
    }
}

Metoden Up skapar tabellen Film och konfigurerar Id som primärnyckel. Metoden Down återställer schemaändringarna som gjorts av migreringen Up .

Testa appen

• Kör appen och klicka på länken Filmapp .

  Om du får ett undantag som liknar något av följande:

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

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

Du missade förmodligen migreringssteget.

• Testa Skapa-sidan. Ange och skicka data.

  Note

  Du kanske inte kan ange decimaltecken i fältet Price. För att stödja jQuery-validering för språk som inte är engelska och som använder kommatecken (",") för en decimalpunkt och för datumformat som inte är US-English måste appen globaliseras. Globaliseringsinstruktioner finns i det här GitHub-problemet.

• Testa sidorna Redigera, Information och Ta bort .

Beroendeinmatning i kontrollanten

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

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)
    {
        services.AddControllersWithViews();

        services.AddDbContext<MvcMovieContext>(options =>
        {
            var connectionString = Configuration.GetConnectionString("MvcMovieContext");

            if (Environment.IsDevelopment())
            {
                options.UseSqlite(connectionString);
            }
            else
            {
                options.UseSqlServer(connectionString);
            }
        });
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Home/Error");
            app.UseHsts();
        }
        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllerRoute(
                name: "default",
                pattern: "{controller=Home}/{action=Index}/{id?}");
        });
    }
}

Starkt skrivna modeller och nyckelordet @model

Tidigare i den här självstudien såg du hur en kontrollant kan skicka data eller objekt till en vy med hjälp av ViewData ordlistan. Ordlistan ViewData är ett dynamiskt objekt som ger ett bekvämt sent bundet sätt att skicka information till en vy.

MVC ger också möjlighet att skicka starkt typerade modellobjekt till en vy. Med det här starkt typade tillvägagångssättet möjliggörs kompileringskontroll. Scaffoldingsystemet använde den här metoden (dvs. att skicka en starkt typad modell) med MoviesController-klassen och vyerna.

Granska den genererade Details metoden i Controllers/MoviesController.cs filen:

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

Parametern id skickas vanligtvis som routningsdata. https://localhost:5001/movies/details/1 Exempeluppsättningar:

• Kontrollern till kontroller movies (det första URL-segmentet).
• Åtgärden för details (det andra URL-segmentet).
• ID:t till 1 (det sista URL-segmentet).

Du kan också skicka in id med en frågesträng på följande sätt:

https://localhost:5001/movies/details?id=1

Parametern id definieras som en nullbar typ (int?) om ett ID-värde inte anges.

Ett lambda-uttryck skickas till FirstOrDefaultAsync för att välja filmentiteter som matchar routedata eller frågesträngsvärdet.

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

Om en film hittas skickas en instans av Movie modellen till Details vyn:

return View(movie);

Granska innehållet i Views/Movies/Details.cshtml filen:

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

Instruktionen @model överst i vyfilen anger vilken typ av objekt som vyn förväntar sig. När filmkontrollanten skapades inkluderades följande @model instruktion:

@model MvcMovie.Models.Movie

Det här @model direktivet ger åtkomst till filmen som kontrollanten skickade till vyn. Objektet Model är starkt typat. I Details.cshtml-vyn skickar koden varje filmfält till DisplayNameFor och DisplayFor HTML-hjälpare med det starkt typerade Model-objektet. Metoderna Create och Edit vyerna skickar också ett Movie modellobjekt.

Granska Index.cshtml vyn och Index metoden i filmmodulens kontroll. Observera hur koden skapar ett List objekt när den anropar View metoden. Koden skickar den här Movies listan från Index åtgärdsmetoden till vyn:

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

När filmkontrollern skapades innehöll scaffold följande @model sats överst i Index.cshtml filen.

@model IEnumerable<MvcMovie.Models.Movie>

Med @model direktivet kan du komma åt listan över filmer som kontrollanten skickade till vyn med hjälp av ett Model objekt som är starkt skrivet. I vyn loopar koden till exempel Index.cshtml igenom filmerna med en foreach instruktion över det starkt typerade Model objektet:

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

Eftersom objektet Model är starkt typat (som ett IEnumerable<Movie>-objekt) anges varje objekt i loopen som Movie. Det innebär bland annat att du får kompileringstidskontroll av koden.

Ytterligare resurser

• Entity Framework Core för nybörjare
• Tag Helpers
• Globalisering och lokalisering