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

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 ulteriori informazioni, vedere tipi di riferimento nullable.

Aggiungere i pacchetti NuGet

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

Generare automaticamente le pagine film

Usare lo strumento di scaffolding per produrre Create, Read, Update e Delete (CRUD) pagine 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 L'oggetto contesto consente di eseguire query e salvare i dati. Il contesto del database deriva 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.

Iniezione delle dipendenze

ASP.NET Core viene compilato con dependency injection (DI). I servizi, come il contesto del database, vengono registrati con DI in Program.cs. Questi servizi vengono forniti ai componenti che li richiedono tramite parametri del costruttore.

Nel Controllers/MoviesController.cs file, il costruttore usa l'Dependency Injection per passare 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 seguente codice evidenziato 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 stringa di connessione del database "MvcMovieContext".

Esaminare il stringa di connessione del database generato

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

{
  "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 chiave ConnectionString dal file appsettings.json.

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.

Iniezione 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'iniezione delle dipendenze per iniettare 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 per gestire associazioni ritardate al fine di trasmettere 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 MoviesController e nelle 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:{PORT}/movies/details/1 imposta:

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

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

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

Il id parametro è definito come tipo nullable (int?) nei casi in cui il valore id 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 Details.cshtml, ad esempio, il codice passa ogni campo del film agli helper HTML DisplayNameFor e DisplayFor con l'oggetto fortemente tipizzato Model. I metodi e le viste 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 di 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 ulteriori informazioni, vedere tipi di riferimento nullable.

Aggiungere i pacchetti NuGet

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

Eseguire lo scaffolding delle pagine dei film

Usare lo strumento di scaffolding per produrre Create, Read, Update, e Delete (CRUD) pagine per il modello 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 L'oggetto contesto consente di eseguire query e salvare i dati. Il contesto del database deriva 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.

Iniezione delle dipendenze

ASP.NET Core viene compilato con dependency injection (DI). I servizi, come il contesto del database, vengono registrati con DI in Program.cs. Questi servizi vengono forniti ai componenti che li richiedono tramite parametri del costruttore.

Nel Controllers/MoviesController.cs file, il costruttore usa l'Dependency Injection per passare 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 seguente codice evidenziato 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 stringa di connessione del database "MvcMovieContext".

Esaminare il stringa di connessione del database generato

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

{
  "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 chiave dal file appsettings.json.

Classe InitialCreate

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

using System;
using Microsoft.EntityFrameworkCore.Migrations;

#nullable disable

namespace MvcMovie.Migrations
{
    /// <inheritdoc />
    public partial class InitialCreate : Migration
    {
        /// <inheritdoc />
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.CreateTable(
                name: "Movie",
                columns: table => new
                {
                    Id = table.Column<int>(type: "int", nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Title = table.Column<string>(type: "nvarchar(max)", nullable: true),
                    ReleaseDate = table.Column<DateTime>(type: "datetime2", nullable: false),
                    Genre = table.Column<string>(type: "nvarchar(max)", nullable: true),
                    Price = table.Column<decimal>(type: "decimal(18,2)", nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Movie", x => x.Id);
                });
        }

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

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.

Iniezione 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 MoviesController classe e nelle 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:{PORT}/movies/details/1 imposta:

• Il controller al controller movies, rappresenta il primo segmento dell'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:{PORT}/movies/details?id=1

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

Un'espressione lambda viene passata al FirstOrDefaultAsync metodo per selezionare le entità film che corrispondono ai dati del percorso 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 Details.cshtml, ad esempio, il codice passa ciascun campo relativo al film agli helper HTML DisplayNameFor e DisplayFor con l'oggetto fortemente tipizzato Model. I metodi Create e Edit e le viste 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 di 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 ulteriori informazioni, vedere tipi di riferimento nullable.

Aggiungere i pacchetti NuGet

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

Eseguire lo scaffolding delle pagine dei film

Usare lo strumento di scaffolding per produrre Create, Read, Update, e Delete (CRUD) pagine per il modello film.

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 --databaseProvider sqlite

dotnet aspnet-codegenerator controller -h

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 L'oggetto contesto consente di eseguire query e salvare i dati. Il contesto del database deriva 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.

Iniezione delle dipendenze

ASP.NET Core viene compilato con dependency injection (DI). I servizi, come il contesto del database, vengono registrati con DI in Program.cs. Questi servizi vengono forniti ai componenti che li richiedono tramite parametri del costruttore.

Nel Controllers/MoviesController.cs file, il costruttore usa l'Dependency Injection per passare 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 seguente codice evidenziato 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 stringa di connessione del database "MvcMovieContext".

Esaminare il stringa di connessione del database generato

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

{
  "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 chiave dal file appsettings.json.

Classe InitialCreate

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

using System;
using Microsoft.EntityFrameworkCore.Migrations;

#nullable disable

namespace MvcMovie.Migrations
{
    public partial class InitialCreate : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.CreateTable(
                name: "Movie",
                columns: table => new
                {
                    Id = table.Column<int>(type: "int", nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Title = table.Column<string>(type: "nvarchar(max)", nullable: true),
                    ReleaseDate = table.Column<DateTime>(type: "datetime2", nullable: false),
                    Genre = table.Column<string>(type: "nvarchar(max)", nullable: true),
                    Price = table.Column<decimal>(type: "decimal(18,2)", nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Movie", x => x.Id);
                });
        }

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

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.

Iniezione 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'iniezione delle dipendenze per iniettare 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 per gestire associazioni ritardate al fine di trasmettere 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 MoviesController e nelle 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.
• Il id passa a 1, l'ultimo segmento dell'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 tipo nullable (int?) nei casi in cui il valore id 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 vista Details.cshtml, il codice passa ogni campo del film agli helper HTML DisplayNameFor e DisplayFor con l'oggetto fortemente tipizzato Model. Le viste e i metodi Create e Edit passano anche un oggetto modello Movie.

Esaminare la vista Index.cshtml e il metodo Index 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 direttiva @model consente l'accesso all'elenco di film che il controller ha passato alla vista utilizzando un oggetto Model fortemente tipizzato. Ad esempio, nella visualizzazione Index.cshtml, il codice scorre attraverso i film 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
• Tag Helper
• 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 ulteriori informazioni, vedere tipi di riferimento nullable.

Aggiungere i pacchetti NuGet

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 le pagine Create, Read, Update e 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 L'oggetto contesto consente di eseguire query e salvare i dati. Il contesto del database deriva 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.

Iniezione delle dipendenze

ASP.NET Core viene compilato con dependency injection (DI). I servizi, come il contesto del database, vengono registrati con DI in Program.cs. Questi servizi vengono forniti ai componenti che li richiedono tramite parametri del costruttore.

Nel Controllers/MoviesController.cs file, il costruttore usa l'Dependency Injection per passare 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 seguente codice evidenziato 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 stringa di connessione del database "MvcMovieContext".

Esaminare il stringa di connessione del database generato

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

{
  "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 chiave ConnectionString dal file appsettings.json.

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 utilizza la Dependency Injection per iniettare 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 MoviesController classe e nelle 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 controller movies, rappresenta il primo segmento dell'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 parametro id è definito come un tipo nullable (int?) nei casi in cui id non viene specificato.

Un'espressione lambda viene passata al FirstOrDefaultAsync metodo per selezionare le entità film che corrispondono ai dati del percorso 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 Details.cshtml, ad esempio, il codice passa ciascun campo relativo al film agli helper HTML DisplayNameFor e DisplayFor con l'oggetto fortemente tipizzato Model. I metodi Create e Edit e le viste 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 di 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 ulteriori informazioni, vedere tipi di riferimento nullable.

Aggiungere i pacchetti NuGet

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.

Generare automaticamente le pagine film

Usare lo strumento di scaffolding per produrre Create, Read, Update e Delete (CRUD) pagine 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 provoca un messaggio di errore Impossibile aprire il database oppure nessuna tabella chiamata: 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 Nullable reference types.

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

<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

Esegui l'app e seleziona il collegamento App Film.

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

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 L'oggetto contesto consente di eseguire query e salvare i dati. Il contesto del database deriva 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.

Iniezione delle dipendenze

ASP.NET Core viene compilato con dependency injection (DI). I servizi, come il contesto del database, vengono registrati con DI in Program.cs. Questi servizi vengono forniti ai componenti che li richiedono tramite parametri del costruttore.

Nel Controllers/MoviesController.cs file, il costruttore usa l'Dependency Injection per passare 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 seguente codice evidenziato 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 stringa di connessione del database "MvcMovieContext".

Esaminare il stringa di connessione del database generato

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

{
  "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 chiave ConnectionString dal file appsettings.json.

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.

Iniezione 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'iniezione delle dipendenze per iniettare 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 per gestire associazioni ritardate al fine di trasmettere 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 MoviesController e nelle 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.
• Il id passa a 1, l'ultimo segmento dell'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 tipo nullable (int?) nei casi in cui il valore id 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 vista Details.cshtml, il codice passa ogni campo del film agli helper HTML DisplayNameFor e DisplayFor con l'oggetto fortemente tipizzato Model. Le viste e i metodi Create e Edit passano anche un oggetto modello Movie.

Esaminare la vista Index.cshtml e il metodo Index 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 l'accesso all'elenco di film che il controller ha passato alla vista utilizzando un oggetto Model fortemente tipizzato. Ad esempio, nella visualizzazione Index.cshtml, il codice scorre attraverso i film 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
• Tag Helper
• 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

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.

Generare le pagine film

Usare lo strumento di scaffolding per produrre Create, Read, Update, e Delete (CRUD) per il modello del 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 genera il seguente:

• 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 scaffoldate non possono essere ancora usate perché il database non esiste. L'esecuzione dell'applicazione e la selezione del collegamento Movie App generano il messaggio di errore Impossibile aprire il database o nessuna tabella: 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

Esegui l'app e seleziona il collegamento App Film.

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

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 L'oggetto contesto consente di eseguire query e salvare i dati. Il contesto del database deriva 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 dependency injection (DI). 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.

Nel Controllers/MoviesController.cs file, il costruttore usa l'Dependency Injection per passare 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 seguente codice evidenziato 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 stringa di connessione del database "MvcMovieContext".

Esaminare il stringa di connessione del database generato

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

{
  "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 chiave ConnectionString dal file appsettings.json.

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 utilizza la Dependency Injection per iniettare 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 MoviesController classe e nelle 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 controller movies, rappresenta il primo segmento dell'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 parametro id è definito come un tipo nullable (int?) nei casi in cui id non viene specificato.

Un'espressione lambda viene passata al FirstOrDefaultAsync metodo per selezionare le entità film che corrispondono ai dati del percorso 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 Details.cshtml, ad esempio, il codice passa ciascun campo relativo al film agli helper HTML DisplayNameFor e DisplayFor con l'oggetto fortemente tipizzato Model. I metodi Create e Edit e le viste 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 file appsettings.Development.json:

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

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

Per altre informazioni, vedere le risorse seguenti:

• Registrazione in .NET e ASP.NET Core
• Il modello di ASP.NET disabilita la registrazione EF Core SQL per impostazione predefinita (dotnet/aspnetcore #32977)

Risorse aggiuntive

• Entity Framework Core per principianti
• Helper di 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

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 la funzionalità EF Core (Create, Read, Update, Delete) per il modello, è necessaria una classe di contesto del Movie database. Il contesto del database deriva 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 dependency injection (DI). I servizi (come il contesto di database EF Core) devono essere registrati con DI durante l'avvio 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 nel contenitore DI.

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 del stringa di connessione viene passato al contesto chiamando un metodo su un oggetto DbContextOptions. Per lo sviluppo locale, il sistema di configurazione di ASP.NET Core legge la stringa di connessione dal file.

Esaminare il stringa di connessione del database

Aggiungere un stringa di connessione al file appsettings.json:

{
  "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 la generazione delle pagine dei film

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

Non puoi ancora utilizzare le pagine generate automaticamente perché il database non esiste. Se si esegue l'app e si fa clic sul collegamento Movie App, si otterrà un messaggio di errore impossibile aprire il database o nessuna tabella denominata 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 hai saltato il passaggio delle migrazioni.

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

  Note

  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 globalizzazione, vedere questo problema di GitHub.

• Testare le pagine Edit, Details e Delete.

Iniezione 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 per gestire associazioni ritardate al fine di trasmettere 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. Nel meccanismo di scaffolding è stato utilizzato questo approccio, ovvero il passaggio di un modello fortemente tipizzato, con la classe MoviesController e le 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 verso il controller movies (il primo segmento dell'URL).
• L'azione su details (secondo segmento di URL).
• L'ID a 1 (l'ultimo segmento dell'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 vista Details.cshtml, il codice passa ogni campo del film agli helper HTML DisplayNameFor e DisplayFor con l'oggetto fortemente tipizzato Model. Le viste e i metodi Create e Edit passano anche un oggetto modello Movie.

Esaminare la vista Index.cshtml e il metodo Index 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 visualizzazione Index.cshtml, il codice scorre attraverso i film 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
• Tag Helper
• Globalizzazione e localizzazione