Parte 4, aggiungere un modello a un'app MVC core ASP.NET

In questa esercitazione vengono aggiunte classi per la gestione dei film in un database. Queste classi sono la parte "Model" dell'app MVC.

Queste classi di modello vengono usate con Entity Framework Core (EF Core) per lavorare con un database. EF Core è un framework ORM (Object-Relational Mapping) che semplifica il codice di accesso ai dati da scrivere.

Le classi di modello create sono note come classi POCO, da Plain Old CLR Objects. Le classi POCO non hanno alcuna dipendenza da EF Core. Definiscono solo le proprietà dei dati da archiviare nel database.

In questa esercitazione vengono create prima le classi di modelli e EF Core viene creato il database.

Aggiungere una classe del modello di dati

Aggiornare il Models/Movie.cs file con il codice seguente:

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

La classe Movie contiene un campo Id, richiesto dal database per la chiave primaria.

L'attributo DataType su ReleaseDate specifica il tipo di dati (Date). Con questo attributo:

• L'utente non deve immettere le informazioni sull'ora nel campo data.
• Viene visualizzata solo la data, non le informazioni temporali.

L'attributo DataAnnotations viene analizzato in un'esercitazione successiva.

Il punto interrogativo dopo string indica che la proprietà è nullable. Per altre informazioni, vedere Tipi di riferimento Nullable.

Aggiungere i pacchetti NuGet di

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 --prerelease
dotnet add package Microsoft.EntityFrameworkCore.SQLite --prerelease
dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design --prerelease
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --prerelease
dotnet add package Microsoft.EntityFrameworkCore.Tools --prerelease

Eseguire lo scaffolding delle pagine Movie

Usare lo strumento di scaffolding per produrre Createpagine , Read, Updatee Delete (CRUD) per il modello di film.

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

Migrazione iniziale

Usare la EF Corefunzionalità Migrazioni per creare il database. Le migrazioni sono un set di strumenti che creano e aggiornano un database in modo che corrispondano al modello di dati.

Add-Migration InitialCreate

Update-Database

dotnet ef migrations add InitialCreate

dotnet ef database update

Testare l'app

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

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

Esaminare la classe di contesto del database generata e la registrazione

Con EF Core, l'accesso ai dati viene eseguito usando un modello. Un modello è costituito da classi di entità e da un contesto dell'oggetto che rappresenta una sessione con il database che consente di eseguire query e salvare i dati. Il contesto di database viene derivato da Microsoft.EntityFrameworkCore.DbContext e specifica le entità da includere nel modello di dati.

Lo scaffolding crea la classe di contesto del Data/MvcMovieContext.cs database:

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

Il codice precedente crea una proprietà DbSet<Movie> che rappresenta i film nel database.

Inserimento delle dipendenze

ASP.NET Core viene compilato con l'inserimento di dipendenze. I servizi, ad esempio il contesto del database, vengono registrati con l'inserimento delle dipendenze in Program.cs. Questi servizi vengono forniti ai componenti che li richiedono tramite parametri del costruttore.

Controllers/MoviesController.cs Nel file il costruttore usa l'inserimento delle dipendenze per inserire il contesto del MvcMovieContext database nel controller. Il contesto di database viene usato in ognuno dei metodi CRUD nel controller.

Lo scaffolding ha generato il codice evidenziato seguente in Program.cs:

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

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

Il sistema di configurazione ASP.NET Core legge il database "MvcMovieContext" stringa di connessione.

Esaminare il database generato stringa di connessione

Lo scaffolding ha aggiunto un stringa di connessione al appsettings.json file:

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

Per lo sviluppo locale, il sistema di configurazione ASP.NET Core legge la ConnectionString chiave dal appsettings.json file.

Classe InitialCreate

Esaminare il file di Migrations/{timestamp}_InitialCreate.cs migrazione:

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

Nel codice precedente:

• InitialCreate.Up crea la tabella Movie e configura Id come chiave primaria.
• InitialCreate.Down ripristina le modifiche dello schema apportate dalla Up migrazione.

Inserimento delle dipendenze nel controller

Aprire il Controllers/MoviesController.cs file ed esaminare il costruttore:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

Il costruttore usa l'inserimento dipendenze per inserire il contesto del database (MvcMovieContext) nel controller. Il contesto di database viene usato in ognuno dei metodi CRUD nel controller.

Testare la pagina Create. Immettere e inviare i dati.

Testare le pagine Edit, Details e Delete.

Modelli fortemente tipizzati e direttiva @model

In un passaggio precedente di questa esercitazione è stato esaminato come un controller può passare oggetti o dati a una vista usando il dizionario ViewData. Il dizionario ViewData è un oggetto dinamico che fornisce un modo pratico ad associazione tardiva per passare informazioni a una vista.

MVC consente di passare oggetti modello fortemente tipizzati a una visualizzazione. Questo approccio fortemente tipizzato consente il controllo del codice in fase di compilazione. Il meccanismo di scaffolding ha passato un modello fortemente tipizzato nella classe e nelle MoviesController viste.

Esaminare il metodo generato Details nel Controllers/MoviesController.cs file:

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

In genere il parametro id viene passato come dati di route. Ad esempio, https://localhost:5001/movies/details/1 imposta:

• Il controller al movies controller, il primo segmento di URL.
• Azione su details, il secondo segmento di URL.
• Da id a 1, ultimo segmento di URL.

L'oggetto id può essere passato con una stringa di query, come nell'esempio seguente:

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

Il id parametro è definito come un tipo nullable (int?) nei casi in cui il id valore non viene specificato.

Un'espressione lambda viene passata al FirstOrDefaultAsync metodo per selezionare le entità film che corrispondono ai dati di route o al valore della stringa di query.

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

Se viene trovato un film, viene passata un'istanza del modello Movie alla vista Details:

return View(movie);

Esaminare il contenuto del Views/Movies/Details.cshtml file:

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

L'istruzione @model all'inizio del file di vista specifica il tipo di oggetto previsto dalla vista. Quando è stato creato il controller dei film, è stata inclusa l'istruzione @model seguente:

@model MvcMovie.Models.Movie

Questa direttiva @model consente di accedere al film che il controller ha passato alla vista. L'oggetto Model è fortemente tipizzato. Nella visualizzazione, ad esempio, Details.cshtml il codice passa ogni campo filmato agli DisplayNameFor helper HTML e DisplayFor con l'oggetto fortemente tipizzato Model . Le viste e i metodi Create e Edit passano anche un oggetto modello Movie.

Esaminare la Index.cshtml visualizzazione e il Index metodo nel controller Movies. Si noti che il codice crea un oggetto List quando chiama il metodo View. Il codice passa questo elenco Movies dal metodo di azione Index alla vista:

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

Il codice restituisce i dettagli del problema se la Movie proprietà del contesto di dati è Null.

Quando è stato creato il controller movies, lo scaffolding includeva l'istruzione seguente @model all'inizio del Index.cshtml file:

@model IEnumerable<MvcMovie.Models.Movie>

La @model direttiva consente l'accesso all'elenco di film passati dal controller alla visualizzazione usando un Model oggetto fortemente tipizzato. Ad esempio, nella Index.cshtml visualizzazione il codice scorre i filmati con un'istruzione foreach sull'oggetto fortemente tipizzato Model :

@model IEnumerable<MvcMovie.Models.Movie>

@{
    ViewData["Title"] = "Index";
}

<h1>Index</h1>

<p>
    <a asp-action="Create">Create New</a>
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.Title)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.ReleaseDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Genre)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Price)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
@foreach (var item in Model) {
        <tr>
            <td>
                @Html.DisplayFor(modelItem => item.Title)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.ReleaseDate)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Genre)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Price)
            </td>
            <td>
                <a asp-action="Edit" asp-route-id="@item.Id">Edit</a> |
                <a asp-action="Details" asp-route-id="@item.Id">Details</a> |
                <a asp-action="Delete" asp-route-id="@item.Id">Delete</a>
            </td>
        </tr>
}
    </tbody>
</table>

Poiché l'oggetto Model è fortemente tipizzato come IEnumerable<Movie> oggetto , ogni elemento del ciclo viene tipizzato come Movie. Tra gli altri vantaggi, il compilatore convalida i tipi usati nel codice.

Risorse aggiuntive

• Entity Framework Core per principianti
• Helper per i tag
• Globalizzazione e localizzazione

In questa esercitazione vengono aggiunte classi per la gestione dei film in un database. Queste classi sono la parte "Model" dell'app MVC.

Queste classi di modello vengono usate con Entity Framework Core (EF Core) per lavorare con un database. EF Core è un framework ORM (Object-Relational Mapping) che semplifica il codice di accesso ai dati da scrivere.

Le classi di modello create sono note come classi POCO, da Plain Old CLR Objects. Le classi POCO non hanno alcuna dipendenza da EF Core. Definiscono solo le proprietà dei dati da archiviare nel database.

In questa esercitazione vengono create prima le classi di modelli e EF Core viene creato il database.

Aggiungere una classe del modello di dati

Aggiornare il Models/Movie.cs file con il codice seguente:

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

La classe Movie contiene un campo Id, richiesto dal database per la chiave primaria.

L'attributo DataType su ReleaseDate specifica il tipo di dati (Date). Con questo attributo:

• L'utente non deve immettere le informazioni sull'ora nel campo data.
• Viene visualizzata solo la data, non le informazioni temporali.

L'attributo DataAnnotations viene analizzato in un'esercitazione successiva.

Il punto interrogativo dopo string indica che la proprietà è nullable. Per altre informazioni, vedere Tipi di riferimento Nullable.

Aggiungere i pacchetti NuGet di

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

Eseguire lo scaffolding delle pagine Movie

Usare lo strumento di scaffolding per produrre Createpagine , Read, Updatee Delete (CRUD) per il modello di film.

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

Migrazione iniziale

Usare la EF Corefunzionalità Migrazioni per creare il database. Le migrazioni sono un set di strumenti che creano e aggiornano un database in modo che corrispondano al modello di dati.

Add-Migration InitialCreate
Update-Database

dotnet ef migrations add InitialCreate

dotnet ef database update

Testare l'app

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

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

Esaminare la classe di contesto del database generata e la registrazione

Con EF Core, l'accesso ai dati viene eseguito usando un modello. Un modello è costituito da classi di entità e da un contesto dell'oggetto che rappresenta una sessione con il database che consente di eseguire query e salvare i dati. Il contesto di database viene derivato da Microsoft.EntityFrameworkCore.DbContext e specifica le entità da includere nel modello di dati.

Lo scaffolding crea la classe di contesto del Data/MvcMovieContext.cs database:

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

Il codice precedente crea una proprietà DbSet<Movie> che rappresenta i film nel database.

Inserimento delle dipendenze

ASP.NET Core viene compilato con l'inserimento di dipendenze. I servizi, ad esempio il contesto del database, vengono registrati con l'inserimento delle dipendenze in Program.cs. Questi servizi vengono forniti ai componenti che li richiedono tramite parametri del costruttore.

Controllers/MoviesController.cs Nel file il costruttore usa l'inserimento delle dipendenze per inserire il contesto del MvcMovieContext database nel controller. Il contesto di database viene usato in ognuno dei metodi CRUD nel controller.

Lo scaffolding ha generato il codice evidenziato seguente in 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")));

Il sistema di configurazione ASP.NET Core legge il database "MvcMovieContext" stringa di connessione.

Esaminare il database generato stringa di connessione

Lo scaffolding ha aggiunto un stringa di connessione al appsettings.json file:

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

Per lo sviluppo locale, il sistema di configurazione ASP.NET Core legge la ConnectionString chiave dal appsettings.json file.

Classe InitialCreate

Esaminare il file di Migrations/{timestamp}_InitialCreate.cs migrazione:

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

Nel codice precedente:

• InitialCreate.Up crea la tabella Movie e configura Id come chiave primaria.
• InitialCreate.Down ripristina le modifiche dello schema apportate dalla Up migrazione.

Inserimento delle dipendenze nel controller

Aprire il Controllers/MoviesController.cs file ed esaminare il costruttore:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

Il costruttore usa l'inserimento dipendenze per inserire il contesto del database (MvcMovieContext) nel controller. Il contesto di database viene usato in ognuno dei metodi CRUD nel controller.

Testare la pagina Create. Immettere e inviare i dati.

Testare le pagine Edit, Details e Delete.

Modelli fortemente tipizzati e direttiva @model

In un passaggio precedente di questa esercitazione è stato esaminato come un controller può passare oggetti o dati a una vista usando il dizionario ViewData. Il dizionario ViewData è un oggetto dinamico che fornisce un modo pratico ad associazione tardiva per passare informazioni a una vista.

MVC consente di passare oggetti modello fortemente tipizzati a una visualizzazione. Questo approccio fortemente tipizzato consente il controllo del codice in fase di compilazione. Il meccanismo di scaffolding ha passato un modello fortemente tipizzato nella classe e nelle MoviesController viste.

Esaminare il metodo generato Details nel Controllers/MoviesController.cs file:

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

In genere il parametro id viene passato come dati di route. Ad esempio, https://localhost:5001/movies/details/1 imposta:

• Il controller al movies controller, il primo segmento di URL.
• Azione su details, il secondo segmento di URL.
• Da id a 1, ultimo segmento di URL.

L'oggetto id può essere passato con una stringa di query, come nell'esempio seguente:

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

Il id parametro è definito come un tipo nullable (int?) nei casi in cui il id valore non viene specificato.

Un'espressione lambda viene passata al FirstOrDefaultAsync metodo per selezionare le entità film che corrispondono ai dati di route o al valore della stringa di query.

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

Se viene trovato un film, viene passata un'istanza del modello Movie alla vista Details:

return View(movie);

Esaminare il contenuto del Views/Movies/Details.cshtml file:

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

L'istruzione @model all'inizio del file di vista specifica il tipo di oggetto previsto dalla vista. Quando è stato creato il controller dei film, è stata inclusa l'istruzione @model seguente:

@model MvcMovie.Models.Movie

Questa direttiva @model consente di accedere al film che il controller ha passato alla vista. L'oggetto Model è fortemente tipizzato. Nella visualizzazione, ad esempio, Details.cshtml il codice passa ogni campo filmato agli DisplayNameFor helper HTML e DisplayFor con l'oggetto fortemente tipizzato Model . Le viste e i metodi Create e Edit passano anche un oggetto modello Movie.

Esaminare la Index.cshtml visualizzazione e il Index metodo nel controller Movies. Si noti che il codice crea un oggetto List quando chiama il metodo View. Il codice passa questo elenco Movies dal metodo di azione Index alla vista:

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

Il codice restituisce i dettagli del problema se la Movie proprietà del contesto di dati è Null.

Quando è stato creato il controller movies, lo scaffolding includeva l'istruzione seguente @model all'inizio del Index.cshtml file:

@model IEnumerable<MvcMovie.Models.Movie>

La @model direttiva consente l'accesso all'elenco di film passati dal controller alla visualizzazione usando un Model oggetto fortemente tipizzato. Ad esempio, nella Index.cshtml visualizzazione il codice scorre i filmati con un'istruzione foreach sull'oggetto fortemente tipizzato Model :

@model IEnumerable<MvcMovie.Models.Movie>

@{
    ViewData["Title"] = "Index";
}

<h1>Index</h1>

<p>
    <a asp-action="Create">Create New</a>
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.Title)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.ReleaseDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Genre)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Price)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
@foreach (var item in Model) {
        <tr>
            <td>
                @Html.DisplayFor(modelItem => item.Title)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.ReleaseDate)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Genre)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Price)
            </td>
            <td>
                <a asp-action="Edit" asp-route-id="@item.Id">Edit</a> |
                <a asp-action="Details" asp-route-id="@item.Id">Details</a> |
                <a asp-action="Delete" asp-route-id="@item.Id">Delete</a>
            </td>
        </tr>
}
    </tbody>
</table>

Poiché l'oggetto Model è fortemente tipizzato come IEnumerable<Movie> oggetto , ogni elemento del ciclo viene tipizzato come Movie. Tra gli altri vantaggi, il compilatore convalida i tipi usati nel codice.

Risorse aggiuntive

• Entity Framework Core per principianti
• Helper per i tag
• Globalizzazione e localizzazione

In questa esercitazione vengono aggiunte classi per la gestione dei film in un database. Queste classi sono la parte "Model" dell'app MVC.

Queste classi di modello vengono usate con Entity Framework Core (EF Core) per lavorare con un database. EF Core è un framework ORM (Object-Relational Mapping) che semplifica il codice di accesso ai dati da scrivere.

Le classi di modello create sono note come classi POCO, da Plain Old CLR Objects. Le classi POCO non hanno alcuna dipendenza da EF Core. Definiscono solo le proprietà dei dati da archiviare nel database.

In questa esercitazione vengono create prima le classi di modelli e EF Core viene creato il database.

Aggiungere una classe del modello di dati

Aggiornare il Models/Movie.cs file con il codice seguente:

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

La classe Movie contiene un campo Id, richiesto dal database per la chiave primaria.

L'attributo DataType su ReleaseDate specifica il tipo di dati (Date). Con questo attributo:

• L'utente non deve immettere le informazioni sull'ora nel campo data.
• Viene visualizzata solo la data, non le informazioni temporali.

L'attributo DataAnnotations viene analizzato in un'esercitazione successiva.

Il punto interrogativo dopo string indica che la proprietà è nullable. Per altre informazioni, vedere Tipi di riferimento Nullable.

Aggiungere i pacchetti NuGet di

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

Eseguire lo scaffolding delle pagine Movie

Usare lo strumento di scaffolding per produrre Createpagine , Read, Updatee Delete (CRUD) per il modello di film.

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

Migrazione iniziale

Usare la EF Corefunzionalità Migrazioni per creare il database. Le migrazioni sono un set di strumenti che creano e aggiornano un database in modo che corrispondano al modello di dati.

Add-Migration InitialCreate
Update-Database

dotnet ef migrations add InitialCreate

dotnet ef database update

Testare l'app

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

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

Esaminare la classe di contesto del database generata e la registrazione

Con EF Core, l'accesso ai dati viene eseguito usando un modello. Un modello è costituito da classi di entità e da un contesto dell'oggetto che rappresenta una sessione con il database che consente di eseguire query e salvare i dati. Il contesto di database viene derivato da Microsoft.EntityFrameworkCore.DbContext e specifica le entità da includere nel modello di dati.

Lo scaffolding crea la classe di contesto del Data/MvcMovieContext.cs database:

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

Il codice precedente crea una proprietà DbSet<Movie> che rappresenta i film nel database.

Inserimento delle dipendenze

ASP.NET Core viene compilato con l'inserimento di dipendenze. I servizi, ad esempio il contesto del database, vengono registrati con l'inserimento delle dipendenze in Program.cs. Questi servizi vengono forniti ai componenti che li richiedono tramite parametri del costruttore.

Controllers/MoviesController.cs Nel file il costruttore usa l'inserimento delle dipendenze per inserire il contesto del MvcMovieContext database nel controller. Il contesto di database viene usato in ognuno dei metodi CRUD nel controller.

Lo scaffolding ha generato il codice evidenziato seguente in 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")));

Il sistema di configurazione ASP.NET Core legge il database "MvcMovieContext" stringa di connessione.

Esaminare il database generato stringa di connessione

Lo scaffolding ha aggiunto un stringa di connessione al appsettings.json file:

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

Per lo sviluppo locale, il sistema di configurazione ASP.NET Core legge la ConnectionString chiave dal appsettings.json file.

Classe InitialCreate

Esaminare il file di Migrations/{timestamp}_InitialCreate.cs migrazione:

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

Nel codice precedente:

• InitialCreate.Up crea la tabella Movie e configura Id come chiave primaria.
• InitialCreate.Down ripristina le modifiche dello schema apportate dalla Up migrazione.

Inserimento delle dipendenze nel controller

Aprire il Controllers/MoviesController.cs file ed esaminare il costruttore:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

Il costruttore usa l'inserimento dipendenze per inserire il contesto del database (MvcMovieContext) nel controller. Il contesto di database viene usato in ognuno dei metodi CRUD nel controller.

Testare la pagina Create. Immettere e inviare i dati.

Testare le pagine Edit, Details e Delete.

Modelli fortemente tipizzati e direttiva @model

In un passaggio precedente di questa esercitazione è stato esaminato come un controller può passare oggetti o dati a una vista usando il dizionario ViewData. Il dizionario ViewData è un oggetto dinamico che fornisce un modo pratico ad associazione tardiva per passare informazioni a una vista.

MVC consente di passare oggetti modello fortemente tipizzati a una visualizzazione. Questo approccio fortemente tipizzato consente il controllo del codice in fase di compilazione. Il meccanismo di scaffolding ha passato un modello fortemente tipizzato nella classe e nelle MoviesController viste.

Esaminare il metodo generato Details nel Controllers/MoviesController.cs file:

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

In genere il parametro id viene passato come dati di route. Ad esempio, https://localhost:5001/movies/details/1 imposta:

• Il controller al movies controller, il primo segmento di URL.
• Azione su details, il secondo segmento di URL.
• Da id a 1, ultimo segmento di URL.

L'oggetto id può essere passato con una stringa di query, come nell'esempio seguente:

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

Il id parametro è definito come un tipo nullable (int?) nei casi in cui il id valore non viene specificato.

Un'espressione lambda viene passata al FirstOrDefaultAsync metodo per selezionare le entità film che corrispondono ai dati di route o al valore della stringa di query.

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

Se viene trovato un film, viene passata un'istanza del modello Movie alla vista Details:

return View(movie);

Esaminare il contenuto del Views/Movies/Details.cshtml file:

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

L'istruzione @model all'inizio del file di vista specifica il tipo di oggetto previsto dalla vista. Quando è stato creato il controller dei film, è stata inclusa l'istruzione @model seguente:

@model MvcMovie.Models.Movie

Questa direttiva @model consente di accedere al film che il controller ha passato alla vista. L'oggetto Model è fortemente tipizzato. Nella visualizzazione, ad esempio, Details.cshtml il codice passa ogni campo filmato agli DisplayNameFor helper HTML e DisplayFor con l'oggetto fortemente tipizzato Model . Le viste e i metodi Create e Edit passano anche un oggetto modello Movie.

Esaminare la Index.cshtml visualizzazione e il Index metodo nel controller Movies. Si noti che il codice crea un oggetto List quando chiama il metodo View. Il codice passa questo elenco Movies dal metodo di azione Index alla vista:

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

Il codice restituisce i dettagli del problema se la Movie proprietà del contesto di dati è Null.

Quando è stato creato il controller movies, lo scaffolding includeva l'istruzione seguente @model all'inizio del Index.cshtml file:

@model IEnumerable<MvcMovie.Models.Movie>

La @model direttiva consente l'accesso all'elenco di film passati dal controller alla visualizzazione usando un Model oggetto fortemente tipizzato. Ad esempio, nella Index.cshtml visualizzazione il codice scorre i filmati con un'istruzione foreach sull'oggetto fortemente tipizzato Model :

@model IEnumerable<MvcMovie.Models.Movie>

@{
    ViewData["Title"] = "Index";
}

<h1>Index</h1>

<p>
    <a asp-action="Create">Create New</a>
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.Title)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.ReleaseDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Genre)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Price)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
@foreach (var item in Model) {
        <tr>
            <td>
                @Html.DisplayFor(modelItem => item.Title)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.ReleaseDate)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Genre)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Price)
            </td>
            <td>
                <a asp-action="Edit" asp-route-id="@item.Id">Edit</a> |
                <a asp-action="Details" asp-route-id="@item.Id">Details</a> |
                <a asp-action="Delete" asp-route-id="@item.Id">Delete</a>
            </td>
        </tr>
}
    </tbody>
</table>

Poiché l'oggetto Model è fortemente tipizzato come IEnumerable<Movie> oggetto , ogni elemento del ciclo viene tipizzato come Movie. Tra gli altri vantaggi, il compilatore convalida i tipi usati nel codice.

Risorse aggiuntive

• Entity Framework Core per principianti
• Helper per i tag
• Globalizzazione e localizzazione

In questa esercitazione vengono aggiunte classi per la gestione dei film in un database. Queste classi sono la parte "Model" dell'app MVC.

Queste classi di modello vengono usate con Entity Framework Core (EF Core) per lavorare con un database. EF Core è un framework ORM (Object-Relational Mapping) che semplifica il codice di accesso ai dati da scrivere.

Le classi di modello create sono note come classi POCO, da Plain Old CLR Objects. Le classi POCO non hanno alcuna dipendenza da EF Core. Definiscono solo le proprietà dei dati da archiviare nel database.

In questa esercitazione vengono create prima le classi di modelli e EF Core viene creato il database.

Aggiungere una classe del modello di dati

Aggiornare il Models/Movie.cs file con il codice seguente:

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

La classe Movie contiene un campo Id, richiesto dal database per la chiave primaria.

L'attributo DataType su ReleaseDate specifica il tipo di dati (Date). Con questo attributo:

• L'utente non deve immettere le informazioni sull'ora nel campo data.
• Viene visualizzata solo la data, non le informazioni temporali.

L'attributo DataAnnotations viene analizzato in un'esercitazione successiva.

Il punto interrogativo dopo string indica che la proprietà è nullable. Per altre informazioni, vedere Tipi di riferimento Nullable.

Aggiungere i pacchetti NuGet di

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

Compilare il progetto per controllare se sono presenti errori del compilatore.

Eseguire lo scaffolding delle pagine Movie

Usare lo strumento di scaffolding per produrre Createpagine , Read, Updatee Delete (CRUD) per il modello di film.

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

Lo scaffolding crea quanto segue:

• Un controller di film: Controllers/MoviesController.cs
• Razor visualizzare i file per le pagine Create, Delete, Details, Edit e Index : Views/Movies/*.cshtml
• Classe di contesto del database: Data/MvcMovieContext.cs

La creazione automatica di questi file e aggiornamenti dei file è nota come scaffolding.

Le pagine con scaffolding non possono essere ancora usate perché il database non esiste. L'esecuzione dell'app e la selezione del collegamento Movie App comporta l'impossibilità di aprire un database o nessuna di queste tabelle: messaggio di errore movie.

Creare l'app

Compilazione dell'app. Il compilatore genera diversi avvisi sulla modalità null di gestione dei valori. Per altre informazioni, vedere questo problema di GitHub e i tipi di riferimento Nullable.

Per eliminare gli avvisi dai tipi riferimento nullable, rimuovere la riga seguente dal MvcMovie.csproj file:

<Nullable>enable</Nullable>

Ci auguriamo di risolvere questo problema nella versione successiva.

Migrazione iniziale

Usare la EF Corefunzionalità Migrazioni per creare il database. Le migrazioni sono un set di strumenti che creano e aggiornano un database in modo che corrispondano al modello di dati.

Add-Migration InitialCreate
Update-Database

  dotnet tool install --global dotnet-ef

dotnet ef migrations add InitialCreate
dotnet ef database update

Testare l'app

Eseguire l'app e selezionare il collegamento App film.

Se si ottiene un'eccezione simile alla seguente, è possibile che il passaggio delle migrazioni non sia stato ottenuto:

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

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

Esaminare la classe di contesto del database generata e la registrazione

Con EF Core, l'accesso ai dati viene eseguito usando un modello. Un modello è costituito da classi di entità e da un contesto dell'oggetto che rappresenta una sessione con il database che consente di eseguire query e salvare i dati. Il contesto di database viene derivato da Microsoft.EntityFrameworkCore.DbContext e specifica le entità da includere nel modello di dati.

Lo scaffolding crea la classe di contesto del Data/MvcMovieContext.cs database:

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

Il codice precedente crea una proprietà DbSet<Movie> che rappresenta i film nel database.

Inserimento delle dipendenze

ASP.NET Core viene compilato con l'inserimento di dipendenze. I servizi, ad esempio il contesto del database, vengono registrati con l'inserimento delle dipendenze in Program.cs. Questi servizi vengono forniti ai componenti che li richiedono tramite parametri del costruttore.

Controllers/MoviesController.cs Nel file il costruttore usa l'inserimento delle dipendenze per inserire il contesto del MvcMovieContext database nel controller. Il contesto di database viene usato in ognuno dei metodi CRUD nel controller.

Lo scaffolding ha generato il codice evidenziato seguente in 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")));

Il sistema di configurazione ASP.NET Core legge il database "MvcMovieContext" stringa di connessione.

Esaminare il database generato stringa di connessione

Lo scaffolding ha aggiunto un stringa di connessione al appsettings.json file:

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

Per lo sviluppo locale, il sistema di configurazione ASP.NET Core legge la ConnectionString chiave dal appsettings.json file.

Classe InitialCreate

Esaminare il file di Migrations/{timestamp}_InitialCreate.cs migrazione:

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

Nel codice precedente:

• InitialCreate.Up crea la tabella Movie e configura Id come chiave primaria.
• InitialCreate.Down ripristina le modifiche dello schema apportate dalla Up migrazione.

Inserimento delle dipendenze nel controller

Aprire il Controllers/MoviesController.cs file ed esaminare il costruttore:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

Il costruttore usa l'inserimento dipendenze per inserire il contesto del database (MvcMovieContext) nel controller. Il contesto di database viene usato in ognuno dei metodi CRUD nel controller.

Testare la pagina Create. Immettere e inviare i dati.

Testare le pagine Edit, Details e Delete.

Modelli fortemente tipizzati e direttiva @model

In un passaggio precedente di questa esercitazione è stato esaminato come un controller può passare oggetti o dati a una vista usando il dizionario ViewData. Il dizionario ViewData è un oggetto dinamico che fornisce un modo pratico ad associazione tardiva per passare informazioni a una vista.

MVC consente di passare oggetti modello fortemente tipizzati a una visualizzazione. Questo approccio fortemente tipizzato consente il controllo del codice in fase di compilazione. Il meccanismo di scaffolding ha passato un modello fortemente tipizzato nella classe e nelle MoviesController viste.

Esaminare il metodo generato Details nel Controllers/MoviesController.cs file:

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

In genere il parametro id viene passato come dati di route. Ad esempio, https://localhost:5001/movies/details/1 imposta:

• Il controller al movies controller, il primo segmento di URL.
• Azione su details, il secondo segmento di URL.
• Da id a 1, ultimo segmento di URL.

L'oggetto id può essere passato con una stringa di query, come nell'esempio seguente:

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

Il id parametro è definito come un tipo nullable (int?) nei casi in cui il id valore non viene specificato.

Un'espressione lambda viene passata al FirstOrDefaultAsync metodo per selezionare le entità film che corrispondono ai dati di route o al valore della stringa di query.

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

Se viene trovato un film, viene passata un'istanza del modello Movie alla vista Details:

return View(movie);

Esaminare il contenuto del Views/Movies/Details.cshtml file:

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

L'istruzione @model all'inizio del file di vista specifica il tipo di oggetto previsto dalla vista. Quando è stato creato il controller dei film, è stata inclusa l'istruzione @model seguente:

@model MvcMovie.Models.Movie

Questa direttiva @model consente di accedere al film che il controller ha passato alla vista. L'oggetto Model è fortemente tipizzato. Nella visualizzazione, ad esempio, Details.cshtml il codice passa ogni campo filmato agli DisplayNameFor helper HTML e DisplayFor con l'oggetto fortemente tipizzato Model . Le viste e i metodi Create e Edit passano anche un oggetto modello Movie.

Esaminare la Index.cshtml visualizzazione e il Index metodo nel controller Movies. Si noti che il codice crea un oggetto List quando chiama il metodo View. Il codice passa questo elenco Movies dal metodo di azione Index alla vista:

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

Quando è stato creato il controller movies, lo scaffolding includeva l'istruzione seguente @model all'inizio del Index.cshtml file:

@model IEnumerable<MvcMovie.Models.Movie>

La @model direttiva consente l'accesso all'elenco di film passati dal controller alla visualizzazione usando un Model oggetto fortemente tipizzato. Ad esempio, nella Index.cshtml visualizzazione il codice scorre i filmati con un'istruzione foreach sull'oggetto fortemente tipizzato Model :

@model IEnumerable<MvcMovie.Models.Movie>

@{
    ViewData["Title"] = "Index";
}

<h1>Index</h1>

<p>
    <a asp-action="Create">Create New</a>
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.Title)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.ReleaseDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Genre)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Price)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
@foreach (var item in Model) {
        <tr>
            <td>
                @Html.DisplayFor(modelItem => item.Title)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.ReleaseDate)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Genre)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Price)
            </td>
            <td>
                <a asp-action="Edit" asp-route-id="@item.Id">Edit</a> |
                <a asp-action="Details" asp-route-id="@item.Id">Details</a> |
                <a asp-action="Delete" asp-route-id="@item.Id">Delete</a>
            </td>
        </tr>
}
    </tbody>
</table>

Poiché l'oggetto Model è fortemente tipizzato come IEnumerable<Movie> oggetto , ogni elemento del ciclo viene tipizzato come Movie. Tra gli altri vantaggi, il compilatore convalida i tipi usati nel codice.

Risorse aggiuntive

• Entity Framework Core per principianti
• Helper per i tag
• Globalizzazione e localizzazione

In questa esercitazione vengono aggiunte classi per la gestione dei film in un database. Queste classi sono la parte "Model" dell'app MVC.

Queste classi di modello vengono usate con Entity Framework Core (EF Core) per lavorare con un database. EF Core è un framework ORM (Object-Relational Mapping) che semplifica il codice di accesso ai dati da scrivere.

Le classi di modello create sono note come classi POCO, da Plain Old CLR Objects. Le classi POCO non hanno alcuna dipendenza da EF Core. Definiscono solo le proprietà dei dati da archiviare nel database.

In questa esercitazione vengono create prima le classi di modelli e EF Core viene creato il database.

Aggiungere una classe del modello di dati

Aggiornare il Models/Movie.cs file con il codice seguente:

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

La classe Movie contiene un campo Id, richiesto dal database per la chiave primaria.

L'attributo DataType su ReleaseDate specifica il tipo di dati (Date). Con questo attributo:

• L'utente non deve immettere le informazioni sull'ora nel campo data.
• Viene visualizzata solo la data, non le informazioni temporali.

L'attributo DataAnnotations viene analizzato in un'esercitazione successiva.

Aggiungere i pacchetti NuGet di

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

Compilare il progetto per controllare se sono presenti errori del compilatore.

Eseguire lo scaffolding delle pagine Movie

Usare lo strumento di scaffolding per produrre Createpagine , Read, Updatee Delete (CRUD) per il modello di film.

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

Lo scaffolding crea quanto segue:

• Un controller di film: Controllers/MoviesController.cs
• Razor visualizzare i file per le pagine Create, Delete, Details, Edit e Index : Views/Movies/*.cshtml
• Classe di contesto del database: Data/MvcMovieContext.cs

La creazione automatica di questi file e aggiornamenti dei file è nota come scaffolding.

Le pagine con scaffolding non possono essere ancora usate perché il database non esiste. L'esecuzione dell'app e la selezione del collegamento Movie App comporta l'impossibilità di aprire un database o nessuna di queste tabelle: messaggio di errore movie.

Migrazione iniziale

Usare la EF Corefunzionalità Migrazioni per creare il database. Le migrazioni sono un set di strumenti che creano e aggiornano un database in modo che corrispondano al modello di dati.

Add-Migration InitialCreate
Update-Database

  dotnet tool install --global dotnet-ef

dotnet ef migrations add InitialCreate
dotnet ef database update

Testare l'app

Eseguire l'app e selezionare il collegamento App film.

Se si ottiene un'eccezione simile alla seguente, è possibile che il passaggio delle migrazioni non sia stato ottenuto:

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

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

Esaminare la classe di contesto del database generata e la registrazione

Con EF Core, l'accesso ai dati viene eseguito usando un modello. Un modello è costituito da classi di entità e da un contesto dell'oggetto che rappresenta una sessione con il database che consente di eseguire query e salvare i dati. Il contesto di database viene derivato da Microsoft.EntityFrameworkCore.DbContext e specifica le entità da includere nel modello di dati.

Lo scaffolding crea la classe di contesto del Data/MvcMovieContext.cs database:

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

Il codice precedente crea una proprietà DbSet<Movie> che rappresenta i film nel database.

ASP.NET Core viene compilato con l'inserimento di dipendenze. I servizi, ad esempio il contesto del database, devono essere registrati con l'inserimento delle dipendenze in Startup. I componenti che richiedono questi servizi vengono forniti tramite parametri del costruttore.

Controllers/MoviesController.cs Nel file il costruttore usa l'inserimento delle dipendenze per inserire il contesto del MvcMovieContext database nel controller. Il contesto di database viene usato in ognuno dei metodi CRUD nel controller.

Lo scaffolding ha generato il codice evidenziato seguente in 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")));
}

Il sistema di configurazione ASP.NET Core legge il database "MvcMovieContext" stringa di connessione.

Esaminare il database generato stringa di connessione

Lo scaffolding ha aggiunto un stringa di connessione al appsettings.json file:

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

Per lo sviluppo locale, il sistema di configurazione ASP.NET Core legge la ConnectionString chiave dal appsettings.json file.

Classe InitialCreate

Esaminare il file di Migrations/{timestamp}_InitialCreate.cs migrazione:

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

Nel codice precedente:

• InitialCreate.Up crea la tabella Movie e configura Id come chiave primaria.
• InitialCreate.Down ripristina le modifiche dello schema apportate dalla Up migrazione.

Inserimento delle dipendenze nel controller

Aprire il Controllers/MoviesController.cs file ed esaminare il costruttore:

public class MoviesController : Controller
{
    private readonly MvcMovieContext _context;

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

Il costruttore usa l'inserimento dipendenze per inserire il contesto del database (MvcMovieContext) nel controller. Il contesto di database viene usato in ognuno dei metodi CRUD nel controller.

Testare la pagina Create. Immettere e inviare i dati.

Testare le pagine Edit, Details e Delete.

Modelli fortemente tipizzati e direttiva @model

In un passaggio precedente di questa esercitazione è stato esaminato come un controller può passare oggetti o dati a una vista usando il dizionario ViewData. Il dizionario ViewData è un oggetto dinamico che fornisce un modo pratico ad associazione tardiva per passare informazioni a una vista.

MVC consente di passare oggetti modello fortemente tipizzati a una visualizzazione. Questo approccio fortemente tipizzato consente il controllo del codice in fase di compilazione. Il meccanismo di scaffolding ha passato un modello fortemente tipizzato nella classe e nelle MoviesController viste.

Esaminare il metodo generato Details nel Controllers/MoviesController.cs file:

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

In genere il parametro id viene passato come dati di route. Ad esempio, https://localhost:5001/movies/details/1 imposta:

• Il controller al movies controller, il primo segmento di URL.
• Azione su details, il secondo segmento di URL.
• Da id a 1, ultimo segmento di URL.

L'oggetto id può essere passato con una stringa di query, come nell'esempio seguente:

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

Il id parametro è definito come un tipo nullable (int?) nei casi in cui il id valore non viene specificato.

Un'espressione lambda viene passata al FirstOrDefaultAsync metodo per selezionare le entità film che corrispondono ai dati di route o al valore della stringa di query.

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

Se viene trovato un film, viene passata un'istanza del modello Movie alla vista Details:

return View(movie);

Esaminare il contenuto del Views/Movies/Details.cshtml file:

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

L'istruzione @model all'inizio del file di vista specifica il tipo di oggetto previsto dalla vista. Quando è stato creato il controller dei film, è stata inclusa l'istruzione @model seguente:

@model MvcMovie.Models.Movie

Questa direttiva @model consente di accedere al film che il controller ha passato alla vista. L'oggetto Model è fortemente tipizzato. Nella visualizzazione, ad esempio, Details.cshtml il codice passa ogni campo filmato agli DisplayNameFor helper HTML e DisplayFor con l'oggetto fortemente tipizzato Model . Le viste e i metodi Create e Edit passano anche un oggetto modello Movie.

Esaminare la Index.cshtml visualizzazione e il Index metodo nel controller Movies. Si noti che il codice crea un oggetto List quando chiama il metodo View. Il codice passa questo elenco Movies dal metodo di azione Index alla vista:

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

Quando è stato creato il controller movies, lo scaffolding includeva l'istruzione seguente @model all'inizio del Index.cshtml file:

@model IEnumerable<MvcMovie.Models.Movie>

La @model direttiva consente l'accesso all'elenco di film passati dal controller alla visualizzazione usando un Model oggetto fortemente tipizzato. Ad esempio, nella Index.cshtml visualizzazione il codice scorre i filmati con un'istruzione foreach sull'oggetto fortemente tipizzato Model :

@model IEnumerable<MvcMovie.Models.Movie>

@{
    ViewData["Title"] = "Index";
}

<h1>Index</h1>

<p>
    <a asp-action="Create">Create New</a>
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.Title)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.ReleaseDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Genre)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Price)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
@foreach (var item in Model) {
        <tr>
            <td>
                @Html.DisplayFor(modelItem => item.Title)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.ReleaseDate)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Genre)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Price)
            </td>
            <td>
                <a asp-action="Edit" asp-route-id="@item.Id">Edit</a> |
                <a asp-action="Details" asp-route-id="@item.Id">Details</a> |
                <a asp-action="Delete" asp-route-id="@item.Id">Delete</a>
            </td>
        </tr>
}
    </tbody>
</table>

Poiché l'oggetto Model è fortemente tipizzato come IEnumerable<Movie> oggetto , ogni elemento del ciclo viene tipizzato come Movie. Tra gli altri vantaggi, il compilatore convalida i tipi usati nel codice.

Registrazione SQL di Entity Framework Core

La configurazione di registrazione viene comunemente fornita dalla sezione Logging dei file appsettings.{Environment}.json. Per registrare istruzioni SQL, aggiungere "Microsoft.EntityFrameworkCore.Database.Command": "Information" al appsettings.Development.json file:

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

Con il codice JSON precedente, le istruzioni SQL vengono visualizzate nella riga di comando e nella finestra di output di Visual Studio.

Per altre informazioni, vedere Registrazione in .NET Core e ASP.NET Core e questo problema di GitHub.

Risorse aggiuntive

• Entity Framework Core per principianti
• Helper per i tag
• Globalizzazione e localizzazione

In questa esercitazione vengono aggiunte classi per la gestione dei film in un database. Queste classi sono la parte "Model" dell'app MVC.

Queste classi di modello vengono usate con Entity Framework Core (EF Core) per lavorare con un database. EF Core è un framework ORM (Object-Relational Mapping) che semplifica il codice di accesso ai dati da scrivere.

Le classi di modello create sono note come classi POCO, da Plain Old CLR Objects. Le classi POCO non hanno alcuna dipendenza da EF Core. Definiscono solo le proprietà dei dati da archiviare nel database.

In questa esercitazione vengono create prima le classi di modelli e EF Core viene creato il database.

Aggiungere una classe del modello di dati

Aggiornare il Movie.cs file con il codice seguente:

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

La classe Movie contiene un campo Id, richiesto dal database per la chiave primaria.

L'attributo DataType su ReleaseDate specifica il tipo di dati (Date). Con questo attributo:

• l'utente non deve immettere le informazioni temporali nel campo della data.
• Viene visualizzata solo la data, non le informazioni temporali.

L'attributo DataAnnotations viene analizzato in un'esercitazione successiva.

Aggiungere i pacchetti NuGet di

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>

Creare una classe di contesto di database

Per coordinare EF Core la funzionalità (Create, Read, Update, Delete) per il modello è necessaria una classe di contesto del Movie database. Il contesto del database è derivato da Microsoft.EntityFrameworkCore.DbContext e specifica le entità da includere nel modello di dati.

Creare una cartella Data.

Aggiungere un Data/MvcMovieContext.cs file con il codice seguente:

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

Il codice precedente crea una proprietà DbSet<Movie> per il set di entità. Nella terminologia di Entity Framework, un set di entità corrisponde in genere alla tabella di un database. Un'entità corrisponde a una riga nella tabella.

Registrare il contesto del database

ASP.NET Core viene compilato con l'inserimento di dipendenze. I servizi , ad esempio il contesto di database, devono essere registrati con l'inserimento delle dipendenze durante l'avvio EF Core dell'applicazione. I componenti che richiedono questi servizi (ad esempio Razor Pages) vengono forniti tramite parametri del costruttore. Più avanti nell'esercitazione viene illustrato il codice del costruttore che ottiene un'istanza del contesto di database. In questa sezione viene registrato il contesto di database per il contenitore di inserimento delle dipendenze.

Aggiungere le istruzioni seguenti using all'inizio di Startup.cs:

using MvcMovie.Data;
using Microsoft.EntityFrameworkCore;

Aggiungere il codice evidenziato seguente in 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")));
}

Il nome della stringa di connessione viene passato al contesto chiamando un metodo in un oggetto DbContextOptions. Per lo sviluppo locale, il sistema di configurazione ASP.NET Core legge il stringa di connessione dal appsettings.json file.

Esaminare il stringa di connessione del database

Aggiungere un stringa di connessione al appsettings.json file:

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

Compilare il progetto per controllare se sono presenti errori del compilatore.

Eseguire lo scaffolding delle pagine Movie

Usare lo strumento di scaffolding per generare le pagine per le operazioni CRUD (creazione, lettura, aggiornamento ed eliminazione) per il modello Movie.

Non è possibile usare ancora le pagine sottoposte a scaffolding perché il database non esiste. Se si esegue l'app e si fa clic sul collegamento Movie App , si ottiene un impossibile aprire il database o nessuna di queste tabelle: messaggio di errore movie .

Migrazione iniziale

Usare la EF Corefunzionalità Migrazioni per creare il database. Migrazioni è un set di strumenti che consentono di creare e aggiornare un database in modo che corrisponda al modello di dati.

Add-Migration InitialCreate
Update-Database

  dotnet tool install --global dotnet-ef

dotnet ef migrations add InitialCreate
dotnet ef database update

Classe InitialCreate

Esaminare il file di Migrations/{timestamp}_InitialCreate.cs migrazione:

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

Il metodo Up crea la tabella Movie e configura Id come chiave primaria. Il metodo Down annulla le modifiche dello schema apportate dalla migrazione Up.

Testare l'app

• Eseguire l'app e fare clic sul collegamento Movie App.

  Se si ottiene un'eccezione simile a una delle seguenti:

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

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

Probabilmente non è stato eseguito il passaggio delle migrazioni.

• Testare la pagina Create. Immettere e inviare i dati.

  Nota

  Potrebbe non essere possibile immettere virgole decimali nel campo Price. Per supportare la convalida jQuery per impostazioni locali diverse dall'inglese che usano la virgola (",") come separatore decimale e per formati di data diversi da quello dell'inglese (Stati Uniti), è necessario localizzare l'app. Per istruzioni sulla localizzazione, vedere questo problema su GitHub.

• Testare le pagine Edit, Details e Delete.

Inserimento delle dipendenze nel controller

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

Modelli fortemente tipizzati e parola chiave @model

In un passaggio precedente di questa esercitazione è stato esaminato come un controller può passare oggetti o dati a una vista usando il dizionario ViewData. Il dizionario ViewData è un oggetto dinamico che fornisce un modo pratico ad associazione tardiva per passare informazioni a una vista.

MVC consente anche di passare oggetti modello fortemente tipizzati a una vista. Questo approccio fortemente tipizzato consente il controllo del codice in fase di compilazione. Con il meccanismo di scaffolding è stato usato questo approccio, ovvero il passaggio di un modello fortemente tipizzato, con le viste e la classe MoviesController.

Esaminare il metodo generato Details nel Controllers/MoviesController.cs file:

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

In genere il parametro id viene passato come dati di route. Ad esempio https://localhost:5001/movies/details/1 imposta:

• Il controller sul controller movies (primo segmento di URL).
• L'azione su details (secondo segmento di URL).
• L'ID su 1 (ultimo segmento di URL).

È possibile anche passare id con una stringa di query nel modo seguente:

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

Il parametro id viene definito come tipo nullable (int?) nel caso in cui non venga fornito un valore ID.

Un'espressione lambda viene passata a FirstOrDefaultAsync per selezionare le entità film che corrispondono al valore della stringa di query o dei dati di route.

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

Se viene trovato un film, viene passata un'istanza del modello Movie alla vista Details:

return View(movie);

Esaminare il contenuto del Views/Movies/Details.cshtml file:

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

L'istruzione @model all'inizio del file di vista specifica il tipo di oggetto previsto dalla vista. Quando è stato creato il controller dei film, è stata inclusa l'istruzione @model seguente:

@model MvcMovie.Models.Movie

Questa direttiva @model consente di accedere al film che il controller ha passato alla vista. L'oggetto Model è fortemente tipizzato. Nella visualizzazione, ad esempio, Details.cshtml il codice passa ogni campo filmato agli DisplayNameFor helper HTML e DisplayFor con l'oggetto fortemente tipizzato Model . Le viste e i metodi Create e Edit passano anche un oggetto modello Movie.

Esaminare la Index.cshtml visualizzazione e il Index metodo nel controller Movies. Si noti che il codice crea un oggetto List quando chiama il metodo View. Il codice passa questo elenco Movies dal metodo di azione Index alla vista:

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

Quando è stato creato il controller movies, lo scaffolding includeva l'istruzione seguente @model all'inizio del Index.cshtml file:

@model IEnumerable<MvcMovie.Models.Movie>

La direttiva @model consente di accedere all'elenco di film che il controller ha passato alla vista usando un oggetto Model fortemente tipizzato. Ad esempio, nella Index.cshtml visualizzazione il codice scorre i filmati con un'istruzione foreach sull'oggetto fortemente tipizzato Model :

@model IEnumerable<MvcMovie.Models.Movie>

@{
    ViewData["Title"] = "Index";
}

<h1>Index</h1>

<p>
    <a asp-action="Create">Create New</a>
</p>
<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.Title)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.ReleaseDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Genre)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Price)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
@foreach (var item in Model) {
        <tr>
            <td>
                @Html.DisplayFor(modelItem => item.Title)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.ReleaseDate)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Genre)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Price)
            </td>
            <td>
                <a asp-action="Edit" asp-route-id="@item.Id">Edit</a> |
                <a asp-action="Details" asp-route-id="@item.Id">Details</a> |
                <a asp-action="Delete" asp-route-id="@item.Id">Delete</a>
            </td>
        </tr>
}
    </tbody>
</table>

Poiché l'oggetto Model è fortemente tipizzato (come un oggetto IEnumerable<Movie>), ogni elemento nel ciclo viene tipizzato come Movie. Tra gli altri vantaggi, si ottiene un controllo del codice in fase di compilazione.

Risorse aggiuntive

• Entity Framework Core per principianti
• Helper per i tag
• Globalizzazione e localizzazione