Accesso ai dati del modello da un controller tramite un modello di visualizzazione
Nota
Una versione aggiornata di questa esercitazione è disponibile qui che usa ASP.NET MVC 5 e Visual Studio 2013. È più sicuro, molto più semplice da seguire e dimostra più funzionalità.
In questa sezione si creerà una nuova MoviesController
classe e si scriverà codice che recupera i dati dei film e lo visualizzerà nel browser usando un modello di visualizzazione.
Compilare l'applicazione prima di passare al passaggio successivo.
Fare clic con il pulsante destro del mouse sulla cartella Controller e creare un nuovo MoviesController
controller. Le opzioni seguenti non verranno visualizzate finché non si compila l'applicazione. Selezionare le opzioni seguenti:
- Nome controller: MoviesController. Questa è l'impostazione predefinita .
- Modello: controller MVC con azioni e viste di lettura/scrittura, usando Entity Framework.
- Classe modello: Movie (MvcMovie.Models).
- Classe contesto dati: MovieDBContext (MvcMovie.Models).
- Views: Razor (CSHTML). Impostazione predefinita.
Scegliere Aggiungi. Visual Studio Express crea i file e le cartelle seguenti:
- Un file MoviesController.cs nella cartella Controllers del progetto.
- Cartella Movies nella cartella Views del progetto.
- Create.cshtml, Delete.cshtml, Details.cshtml, Edit.cshtml e Index.cshtml nella nuova cartella Views\Movies .
ASP.NET MVC 4 ha creato automaticamente i metodi e le visualizzazioni dell'azione CRUD (creazione, lettura, aggiornamento ed eliminazione) (la creazione automatica di metodi di azione CRUD e visualizzazioni è nota come scaffolding). È ora disponibile un'applicazione Web completamente funzionante che consente di creare, elencare, modificare ed eliminare voci di film.
Eseguire l'applicazione e passare al Movies
controller aggiungendo /Movies all'URL nella barra degli indirizzi del browser. Poiché l'applicazione si basa sul routing predefinito (definito nel file Global.asax ), la richiesta http://localhost:xxxxx/Movies
del browser viene instradata al metodo di azione predefinito Index
del Movies
controller. In altre parole, la richiesta http://localhost:xxxxx/Movies
del browser è in effetti uguale alla richiesta http://localhost:xxxxx/Movies/Index
del browser . Il risultato è un elenco vuoto di film, perché non è ancora stato aggiunto.
Creazione di un filmato
Selezionare il collegamento Crea nuovo . Immettere alcuni dettagli su un filmato e quindi fare clic sul pulsante Crea .
Facendo clic sul pulsante Crea , il modulo viene inserito nel server, in cui le informazioni sui film vengono salvate nel database. Viene quindi eseguito il reindirizzamento all'URL /Movies , in cui è possibile visualizzare il filmato appena creato nell'elenco.
Creare altre due voci di filmato. Provare i collegamenti Modifica, Dettagli e Elimina, che sono tutti funzionali.
Esame del codice generato
Aprire il file Controllers\MoviesController.cs ed esaminare il metodo generato Index
. Di seguito è illustrata una parte del controller di film con il Index
metodo .
public class MoviesController : Controller
{
private MovieDBContext db = new MovieDBContext();
//
// GET: /Movies/
public ActionResult Index()
{
return View(db.Movies.ToList());
}
La riga seguente della MoviesController
classe crea un'istanza di un contesto di database di film, come descritto in precedenza. È possibile usare il contesto del database di film per eseguire query, modificare ed eliminare film.
private MovieDBContext db = new MovieDBContext();
Una richiesta al Movies
controller restituisce tutte le voci nella Movies
tabella del database dei film e quindi passa i risultati alla Index
visualizzazione.
Modelli fortemente tipizzati e parola @model chiave
In precedenza in questa esercitazione si è visto come un controller può passare dati o oggetti a un modello di visualizzazione usando l'oggetto ViewBag
. ViewBag
è un oggetto dinamico che fornisce un modo pratico di associazione tardiva per passare informazioni a una visualizzazione.
ASP.NET MVC consente anche di passare dati o oggetti fortemente tipizzati a un modello di visualizzazione. Questo approccio fortemente tipizzato consente un controllo in fase di compilazione migliore del codice e di IntelliSense più avanzato nell'editor di Visual Studio. Il meccanismo di scaffolding in Visual Studio ha usato questo approccio con la MoviesController
classe e i modelli di visualizzazione al momento della creazione dei metodi e delle visualizzazioni.
Nel file Controllers\MoviesController.cs esaminare il metodo generato Details
. Di seguito è illustrata una parte del controller di film con il Details
metodo .
public ActionResult Details(int id = 0)
{
Movie movie = db.Movies.Find(id);
if (movie == null)
{
return HttpNotFound();
}
return View(movie);
}
Se viene trovato un oggetto Movie
, viene passata un'istanza del Movie
modello alla visualizzazione Dettagli. Esaminare il contenuto del file Views\Movies\Details.cshtml .
Includendo un'istruzione @model
nella parte superiore del file modello di visualizzazione, è possibile specificare il tipo di oggetto previsto dalla vista. Al momento della creazione del controller di film, l'istruzione @model
è stata inclusa automaticamente in Visual Studio all'inizio del file Details.cshtml:
@model MvcMovie.Models.Movie
Questa direttiva @model
consente di accedere al film passato dal controller alla vista usando un oggetto Model
fortemente tipizzato. Ad esempio, nel modello Details.cshtml il codice passa ogni campo filmato agli DisplayNameFor
helper HTML e DisplayFor con l'oggetto fortemente tipizzato Model
. I metodi Create e Edit e i modelli di visualizzazione passano anche un oggetto modello di film.
Esaminare il modello di visualizzazione Index.cshtml e il Index
metodo nel file MoviesController.cs . Si noti che il codice crea un List
oggetto quando chiama il View
metodo helper nel Index
metodo action. Il codice passa quindi questo Movies
elenco dal controller alla visualizzazione:
public ActionResult Index()
{
return View(db.Movies.ToList());
}
Quando è stato creato il controller di film, Visual Studio Express incluso automaticamente l'istruzione seguente @model
all'inizio del file Index.cshtml:
@model IEnumerable<MvcMovie.Models.Movie>
Questa @model
direttiva consente di accedere all'elenco di film passati dal controller alla visualizzazione usando un Model
oggetto fortemente tipizzato. Ad esempio, nel modello Index.cshtml il codice scorre i film eseguendo un'istruzione foreach
sull'oggetto fortemente tipizzato Model
:
@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>
<th>
@Html.DisplayFor(modelItem => item.Rating)
</th>
<td>
@Html.ActionLink("Edit", "Edit", new { id=item.ID }) |
@Html.ActionLink("Details", "Details", { id=item.ID }) |
@Html.ActionLink("Delete", "Delete", { id=item.ID })
</td>
</tr>
}
Poiché l'oggetto Model
è fortemente tipizzato (come IEnumerable<Movie>
oggetto ), ogni item
oggetto nel ciclo viene tipizzato come Movie
. Tra gli altri vantaggi, ciò significa che si ottiene il controllo in fase di compilazione del codice e il supporto completo di IntelliSense nell'editor di codice:
Utilizzo di SQL Server Local DB
Entity Framework Code First ha rilevato che la stringa di connessione del database fornita punta a un Movies
database che non esisteva ancora, quindi Code First ha creato automaticamente il database. È possibile verificare che sia stato creato cercando nella cartella App_Data . Se il file Movies.mdf non viene visualizzato, fare clic sul pulsante Mostra tutti i file nella barra degli strumenti Esplora soluzioni, fare clic sul pulsante Aggiorna e quindi espandere la cartella App_Data.
Fare doppio clic su Movies.mdf per aprire DATABASE EXPLORER, quindi espandere la cartella Tabelle per visualizzare la tabella Movies.
Nota
Se Esplora database non viene visualizzato, scegliere Connetti al database dal menu STRUMENTI e quindi annullare la finestra di dialogo Scegli origine dati. Verrà forzato l'apertura di Esplora database.
Nota
Se si usa VWD o Visual Studio 2010 e viene visualizzato un errore simile a uno dei seguenti:
- Il database 'C:\Webs\MVC4\MVCMOVIE\MVCMOVIE\APP_DATA\MOVIES. Impossibile aprire MDF perché è la versione 706. Questo server supporta la versione 655 e precedenti. Il downgrade non è supportato.
- "InvalidOperation Exception was unhandled by user code" The supplied SqlConnection does not specify an initial catalog.
È necessario installare i SQL Server Data Tools e LocalDB. Verificare la MovieDBContext
stringa di connessione specificata nella pagina precedente.
Fare clic con il pulsante destro del mouse sulla Movies
tabella e scegliere Mostra dati tabella per visualizzare i dati creati.
Fare clic con il pulsante destro del mouse sulla Movies
tabella e scegliere Apri definizione tabella per visualizzare la struttura della tabella creata automaticamente da Entity Framework Code First.
Si noti che lo schema della Movies
tabella esegue il Movie
mapping alla classe creata in precedenza. Entity Framework Code First ha creato automaticamente questo schema in base alla Movie
classe.
Al termine, chiudere la connessione facendo clic con il pulsante destro del mouse su MovieDBContext e scegliendo Chiudi connessione. Se non si chiude la connessione, è possibile che venga visualizzato un errore alla successiva esecuzione del progetto.
È ora disponibile il database e una pagina di presentazione semplice da cui visualizzare il contenuto. Nell'esercitazione successiva verranno esaminati il resto del codice con scaffolding e verrà aggiunto un SearchIndex
metodo e una SearchIndex
visualizzazione che consente di cercare film in questo database.
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per