Visualizzazioni in ASP.NET Core MVCViews in ASP.NET Core MVC

Di Steve Smith e Luke LathamBy Steve Smith and Luke Latham

Questo documento illustra le visualizzazioni usate nelle applicazioni ASP.NET Core MVC.This document explains views used in ASP.NET Core MVC applications. Per informazioni relative a Razor Pages, vedere Introduzione a Razor Pages.For information on Razor Pages, see Introduction to Razor Pages.

Nello schema MVC la visualizzazione gestisce la presentazione dei dati dell'app e l'interazione dell'utente.In the Model-View-Controller (MVC) pattern, the view handles the app's data presentation and user interaction. Una visualizzazione è un modello HTML con markup Razor incorporato.A view is an HTML template with embedded Razor markup. Il markup Razor è il codice che interagisce con il markup HTML per produrre una pagina Web che viene inviata al client.Razor markup is code that interacts with HTML markup to produce a webpage that's sent to the client.

In ASP.NET Core MVC le visualizzazioni sono file con estensione cshtml che usano il linguaggio di programmazione C# nel markup Razor.In ASP.NET Core MVC, views are .cshtml files that use the C# programming language in Razor markup. I file di visualizzazione sono in genere raggruppati in cartelle denominate per ognuno dei controller dell'app.Usually, view files are grouped into folders named for each of the app's controllers. Le cartelle vengono archiviate in una cartella Views alla radice dell'app:The folders are stored in a Views folder at the root of the app:

Cartella delle visualizzazioni aperta in Esplora soluzioni di Visual Studio con la cartella Home aperta per mostrare i file About.cshtml, Contact.cshtml e Index.cshtml

Il controller Home è rappresentato da una cartella Home all'interno della cartella Views.The Home controller is represented by a Home folder inside the Views folder. La cartella Home contiene le visualizzazioni per le pagine Web About, Contact e Index (home page).The Home folder contains the views for the About, Contact, and Index (homepage) webpages. Quando un utente richiede una di queste tre pagine Web, le azioni del controller nel controller Home determinano quale delle tre visualizzazioni verrà usata per compilare e restituire una pagina Web all'utente.When a user requests one of these three webpages, controller actions in the Home controller determine which of the three views is used to build and return a webpage to the user.

Usare i layout per offrire sezioni di pagine Web coerenti e ridurre la ripetizione del codice.Use layouts to provide consistent webpage sections and reduce code repetition. I layout spesso includono l'intestazione, elementi di navigazione e menu, nonché il piè di pagina.Layouts often contain the header, navigation and menu elements, and the footer. L'intestazione e il piè di pagina in genere contengono il markup boilerplate per molti elementi di metadati e i collegamenti alle risorse di script e stile.The header and footer usually contain boilerplate markup for many metadata elements and links to script and style assets. I layout consentono di evitare questo markup boilerplate nelle visualizzazioni.Layouts help you avoid this boilerplate markup in your views.

Le visualizzazioni parziali riducono la duplicazione del codice grazie alla gestione delle parti riutilizzabili delle visualizzazioni.Partial views reduce code duplication by managing reusable parts of views. Una visualizzazione parziale è ad esempio utile per la biografia di un autore nel sito Web di un blog che viene mostrata in diverse visualizzazioni.For example, a partial view is useful for an author biography on a blog website that appears in several views. Nel caso della biografia di un autore, il contenuto di visualizzazione è ordinario e non richiede l'esecuzione di codice per produrre il contenuto per la pagina Web.An author biography is ordinary view content and doesn't require code to execute in order to produce the content for the webpage. Il contenuto della biografia di un autore è disponibile per la visualizzazione tramite la sola associazione di modelli, quindi l'uso di una visualizzazione parziale per questo tipo di contenuto è ideale.Author biography content is available to the view by model binding alone, so using a partial view for this type of content is ideal.

I componenti di visualizzazione sono simili alle visualizzazioni parziali nel senso che consentono di ridurre il codice ripetitivo, ma sono adatti per visualizzare contenuto che richiede l'esecuzione di codice nel server al fine di eseguire il rendering della pagina Web.View components are similar to partial views in that they allow you to reduce repetitive code, but they're appropriate for view content that requires code to run on the server in order to render the webpage. I componenti di visualizzazione sono utili quando il contenuto sottoposto a rendering richiede l'interazione con il database, ad esempio nel caso del carrello acquisti di un sito Web.View components are useful when the rendered content requires database interaction, such as for a website shopping cart. I componenti di visualizzazione non si limitano all'associazione di modelli per produrre l'output della pagina Web.View components aren't limited to model binding in order to produce webpage output.

Vantaggi dell'uso delle visualizzazioniBenefits of using views

Le visualizzazioni consentono di stabilire una separazione dei concetti all'interno di un'app MVC separando il markup dell'interfaccia utente da altre parti dell'app.Views help to establish separation of concerns within an MVC app by separating the user interface markup from other parts of the app. La progettazione SoC rende l'app modulare offrendo diversi vantaggi:Following SoC design makes your app modular, which provides several benefits:

  • L'app risulta più facile da gestire perché è organizzata meglio.The app is easier to maintain because it's better organized. Le visualizzazioni sono in genere raggruppate per funzionalità dell'app.Views are generally grouped by app feature. Individuare le visualizzazioni correlate quando si lavora su una funzionalità risulterà quindi più semplice.This makes it easier to find related views when working on a feature.
  • Le parti dell'app sono a regime di controllo libero.The parts of the app are loosely coupled. È possibile compilare e aggiornare le visualizzazioni dell'app separatamente dai componenti di logica di business e accesso ai dati.You can build and update the app's views separately from the business logic and data access components. È possibile modificare le visualizzazioni dell'app senza dover necessariamente aggiornare altre parti dell'app.You can modify the views of the app without necessarily having to update other parts of the app.
  • Poiché le visualizzazioni sono unità distinte, testare le parti dell'interfaccia utente dell'app risulta più semplice.It's easier to test the user interface parts of the app because the views are separate units.
  • Grazie alla migliore organizzazione, le probabilità che le sezioni dell'interfaccia utente vengano ripetute accidentalmente sono minori.Due to better organization, it's less likely that you'll accidentally repeat sections of the user interface.

Creazione di una visualizzazioneCreating a view

Le visualizzazioni specifiche di un controller vengono create nella cartella Views/[ControllerName].Views that are specific to a controller are created in the Views/[ControllerName] folder. Le visualizzazioni condivise tra i controller vengono inserite nella cartella Views/Shared.Views that are shared among controllers are placed in the Views/Shared folder. Per creare una visualizzazione aggiungere un nuovo file e assegnargli lo stesso nome dell'azione del controller a essa associata con l'estensione cshtml.To create a view, add a new file and give it the same name as its associated controller action with the .cshtml file extension. Per creare una visualizzazione che corrisponda all'azione About nel controller Home, creare un file About.cshtml nella cartella Views/Home:To create a view that corresponds with the About action in the Home controller, create an About.cshtml file in the Views/Home folder:

@{
    ViewData["Title"] = "About";
}
<h2>@ViewData["Title"].</h2>
<h3>@ViewData["Message"]</h3>

<p>Use this area to provide additional information.</p>

Il markup Razor inizia con il simbolo @.Razor markup starts with the @ symbol. Eseguire le istruzioni C# inserendo il codice C# entro i blocchi di codice Razor racchiusi tra le parentesi graffe ({ ... }).Run C# statements by placing C# code within Razor code blocks set off by curly braces ({ ... }). Vedere ad esempio l'assegnazione di "About" a ViewData["Title"] illustrato sopra.For example, see the assignment of "About" to ViewData["Title"] shown above. È possibile visualizzare i valori in HTML facendo semplicemente riferimento al valore con il simbolo @.You can display values within HTML by simply referencing the value with the @ symbol. Vedere il contenuto degli elementi <h2> e <h3> riportati sopra.See the contents of the <h2> and <h3> elements above.

Il contenuto della visualizzazione illustrato sopra è solo una parte dell'intera pagina Web di cui viene eseguito il rendering per l'utente.The view content shown above is only part of the entire webpage that's rendered to the user. Il resto del layout della pagina e altri aspetti comuni della visualizzazione sono specificati in altri file.The rest of the page's layout and other common aspects of the view are specified in other view files. Per altre informazioni, vedere l'argomento Layout.To learn more, see the Layout topic.

Modalità di scelta delle visualizzazioni da parte dei controllerHow controllers specify views

Le visualizzazioni vengono in genere restituite da azioni come ViewResult, ovvero un tipo di ActionResult.Views are typically returned from actions as a ViewResult, which is a type of ActionResult. Il metodo dell'azione può creare e restituire direttamente un elemento ViewResult, ma questa procedura non è molto comune.Your action method can create and return a ViewResult directly, but that isn't commonly done. Poiché la maggior parte dei controller ereditano da Controller, si usa semplicemente il metodo helper View per restituire l'elemento ViewResult:Since most controllers inherit from Controller, you simply use the View helper method to return the ViewResult:

HomeController.csHomeController.cs

public IActionResult About()
{
    ViewData["Message"] = "Your application description page.";

    return View();
}

Quando viene restituita questa azione, il rendering della visualizzazione About.cshtml nell'ultima sezione corrisponderà alla pagina Web seguente:When this action returns, the About.cshtml view shown in the last section is rendered as the following webpage:

Rendering della pagina About nel browser Microsoft Edge

Il metodo helper View ha diversi overload.The View helper method has several overloads. È possibile specificare:You can optionally specify:

  • Una visualizzazione esplicita da restituire:An explicit view to return:

    return View("Orders");
    
  • Un modello da passare alla visualizzazione:A model to pass to the view:

    return View(Orders);
    
  • Una visualizzazione e un modello:Both a view and a model:

    return View("Orders", Orders);
    

Individuazione delle visualizzazioniView discovery

Quando un'azione restituisce una visualizzazione viene eseguito un processo denominato individuazione delle visualizzazioni.When an action returns a view, a process called view discovery takes place. Questo processo determina il file di visualizzazione che verrà usato in base al nome della visualizzazione.This process determines which view file is used based on the view name.

In base al comportamento predefinito, il metodo View (return View();) restituisce una visualizzazione con lo stesso nome del metodo dell'azione dal quale viene chiamato.The default behavior of the View method (return View();) is to return a view with the same name as the action method from which it's called. Nel caso di About, ad esempio, il nome del metodo ActionResult del controller viene usato per cercare un file di visualizzazione denominato About.cshtml.For example, the About ActionResult method name of the controller is used to search for a view file named About.cshtml. Il runtime cerca prima la visualizzazione nella cartella Views/[ControllerName].First, the runtime looks in the Views/[ControllerName] folder for the view. Se la cartella non contiene una visualizzazione corrispondente, la ricerca passerà alla cartella Shared.If it doesn't find a matching view there, it searches the Shared folder for the view.

La restituzione implicita di ViewResult con return View(); o il passaggio esplicito del nome della visualizzazione al metodo View con return View("<ViewName>"); non sono rilevanti.It doesn't matter if you implicitly return the ViewResult with return View(); or explicitly pass the view name to the View method with return View("<ViewName>");. In entrambi i casi, l'individuazione delle visualizzazioni cercherà un file di visualizzazione corrispondente in quest'ordine:In both cases, view discovery searches for a matching view file in this order:

  1. Views/[ControllerName]/[ViewName].cshtmlViews/[ControllerName]/[ViewName].cshtml
  2. Views/Shared/[ViewName].cshtmlViews/Shared/[ViewName].cshtml

È possibile fornire il percorso di un file di visualizzazione anziché il nome di una visualizzazione.A view file path can be provided instead of a view name. Se si usa un percorso assoluto che inizia alla radice dell'app (che inizia facoltativamente con "/" o "~/") è necessario specificare l'estensione cshtml:If using an absolute path starting at the app root (optionally starting with "/" or "~/"), the .cshtml extension must be specified:

return View("Views/Home/About.cshtml");

È anche possibile usare un percorso relativo per specificare le visualizzazioni presenti in directory diverse senza l'estensione cshtml.You can also use a relative path to specify views in different directories without the .cshtml extension. All'interno di HomeController è possibile restituire la visualizzazione Index delle visualizzazioni Manage con il percorso relativo:Inside the HomeController, you can return the Index view of your Manage views with a relative path:

return View("../Manage/Index");

In modo analogo, è possibile indicare la directory corrente specifica dei controller con il prefisso "./":Similarly, you can indicate the current controller-specific directory with the "./" prefix:

return View("./About");

Le visualizzazioni parziali e i componenti di visualizzazione usano meccanismi di individuazione simili, ma non identici.Partial views and view components use similar (but not identical) discovery mechanisms.

È possibile personalizzare la convenzione predefinita per la modalità di ricerca delle visualizzazioni all'interno dell'app usando un'interfaccia IViewLocationExpander personalizzata.You can customize the default convention for how views are located within the app by using a custom IViewLocationExpander.

L'individuazione delle visualizzazioni si basa sull'individuazione dei file di visualizzazione in base al nome del file.View discovery relies on finding view files by file name. Se il file system sottostante prevede la distinzione tra maiuscole e minuscole, per i nomi delle visualizzazioni verrà probabilmente applicata questa distinzione.If the underlying file system is case sensitive, view names are probably case sensitive. Per la compatibilità tra sistemi operativi, rispettare la distinzione maiuscole/minuscole tra i nomi di controller e azioni e i nomi di cartelle e file di visualizzazione associati.For compatibility across operating systems, match case between controller and action names and associated view folders and file names. In caso di errore relativo a un file di visualizzazione non trovato durante l'uso di un file system con distinzione tra maiuscole e minuscole, verificare che tra il nome del file di visualizzazione richiesto e il nome effettivo del file di visualizzazione l'uso delle maiuscole e minuscole corrisponda.If you encounter an error that a view file can't be found while working with a case-sensitive file system, confirm that the casing matches between the requested view file and the actual view file name.

Per manutenibilità e chiarezza, seguire le procedure consigliate relative all'organizzazione della struttura di file per le visualizzazioni in modo da riflettere le relazioni tra controller, azioni e visualizzazioni.Follow the best practice of organizing the file structure for your views to reflect the relationships among controllers, actions, and views for maintainability and clarity.

Passaggio dei dati alle visualizzazioniPassing data to views

Passare i dati alle visualizzazioni usando diversi approcci:Pass data to views using several approaches:

  • Dati fortemente tipizzati: viewmodelStrongly typed data: viewmodel
  • Dati con tipizzazione deboleWeakly typed data
    • ViewData (ViewDataAttribute)ViewData (ViewDataAttribute)
    • ViewBag

Dati fortemente tipizzati: (viewmodel)Strongly typed data (viewmodel)

L'approccio più efficace consiste nello specificare un tipo di modello nella visualizzazione.The most robust approach is to specify a model type in the view. Questo modello è comunemente noto come viewmodel.This model is commonly referred to as a viewmodel. Un'istanza del tipo viewmodel viene passato alla visualizzazione dall'azione.You pass an instance of the viewmodel type to the view from the action.

L'uso di un viewmodel per passare i dati a una visualizzazione consente a quest'ultima di trarre vantaggio dal controllo con tipizzazione forte.Using a viewmodel to pass data to a view allows the view to take advantage of strong type checking. L'espressione tipizzazione forte o fortemente tipizzato indica che ogni variabile e costante ha un tipo definito in modo esplicito, ad esempio string, int o DateTime.Strong typing (or strongly typed) means that every variable and constant has an explicitly defined type (for example, string, int, or DateTime). La validità dei tipi usati in una visualizzazione viene verificata in fase di compilazione.The validity of types used in a view is checked at compile time.

In Visual Studio e Visual Studio Code i membri delle classi fortemente tipizzati vengono elencati usando una funzionalità denominata IntelliSense.Visual Studio and Visual Studio Code list strongly typed class members using a feature called IntelliSense. Per visualizzare le proprietà di un elemento viewmodel, digitare il nome della variabile per l'elemento viewmodel seguito da un punto (.).When you want to see the properties of a viewmodel, type the variable name for the viewmodel followed by a period (.). Ciò consente di scrivere il codice più velocemente con un minor numero di errori.This helps you write code faster with fewer errors.

Specificare un modello usando la direttiva @model.Specify a model using the @model directive. Usare il modello con @Model:Use the model with @Model:

@model WebApplication1.ViewModels.Address

<h2>Contact</h2>
<address>
    @Model.Street<br>
    @Model.City, @Model.State @Model.PostalCode<br>
    <abbr title="Phone">P:</abbr> 425.555.0100
</address>

Per fornire il modello alla visualizzazione, il controller lo passa come parametro:To provide the model to the view, the controller passes it as a parameter:

public IActionResult Contact()
{
    ViewData["Message"] = "Your contact page.";

    var viewModel = new Address()
    {
        Name = "Microsoft",
        Street = "One Microsoft Way",
        City = "Redmond",
        State = "WA",
        PostalCode = "98052-6399"
    };

    return View(viewModel);
}

Non ci sono limitazioni ai tipi di modello che è possibile fornire a una visualizzazione.There are no restrictions on the model types that you can provide to a view. È consigliabile usare viewmodel Plain Old CLR Object (POCO) per i quali non siano stati definiti comportamenti (metodi) o ne siano stati definiti solo alcuni.We recommend using Plain Old CLR Object (POCO) viewmodels with little or no behavior (methods) defined. Le classi viewmodel sono in genere archiviate nella cartella Models o in una cartella ViewModels separata alla radice dell'app.Usually, viewmodel classes are either stored in the Models folder or a separate ViewModels folder at the root of the app. Il viewmodel Address usato nell'esempio precedente è un viewmodel POCO archiviato in un file denominato Address.cs:The Address viewmodel used in the example above is a POCO viewmodel stored in a file named Address.cs:

namespace WebApplication1.ViewModels
{
    public class Address
    {
        public string Name { get; set; }
        public string Street { get; set; }
        public string City { get; set; }
        public string State { get; set; }
        public string PostalCode { get; set; }
    }
}

Nulla impedisce di usare le stesse classi per i tipi viewmodel e i tipi del modello aziendale.Nothing prevents you from using the same classes for both your viewmodel types and your business model types. L'uso di modelli separati consente tuttavia la variazione delle visualizzazioni indipendentemente dalle parti relative alla logica di business e all'accesso ai dati dell'app.However, using separate models allows your views to vary independently from the business logic and data access parts of your app. La separazione di modelli e viewmodel offre anche vantaggi in termini di sicurezza quando i modelli usano l'associazione di modelli e la convalida per i dati inviati all'app dall'utente.Separation of models and viewmodels also offers security benefits when models use model binding and validation for data sent to the app by the user.

Dati con tipizzazione debole (ViewData, attributo ViewData e ViewBag)Weakly typed data (ViewData, ViewData attribute, and ViewBag)

ViewBag non è disponibile in Razor Pages.ViewBag isn't available in Razor Pages.

Oltre alle visualizzazioni fortemente tipizzate, le visualizzazioni hanno accesso a una raccolta di dati con tipizzazione debole o debolmente tipizzati.In addition to strongly typed views, views have access to a weakly typed (also called loosely typed) collection of data. A differenza della tipizzazione forte, la tipizzazione debole, o l'espressione debolmente tipizzato, indica che il tipo di dati in uso non viene dichiarato in modo esplicito.Unlike strong types, weak types (or loose types) means that you don't explicitly declare the type of data you're using. È possibile usare la raccolta di dati con tipizzazione debole per passare piccole quantità di dati da e verso i controller e le visualizzazioni.You can use the collection of weakly typed data for passing small amounts of data in and out of controllers and views.

Passaggio dei dati tra...Passing data between a ... EsempioExample
Un controller e una visualizzazioneController and a view Popolamento di dati in un elenco a discesa.Populating a dropdown list with data.
Una visualizzazione e una visualizzazione LayoutView and a layout view Impostazione del contenuto dell'elemento <title> nella visualizzazione Layout da un file di visualizzazione.Setting the <title> element content in the layout view from a view file.
Una visualizzazione parziale e una visualizzazionePartial view and a view Widget che visualizza i dati in base alla pagina Web richiesta dall'utente.A widget that displays data based on the webpage that the user requested.

È possibile fare riferimento a questa raccolta tramite le proprietà ViewData o ViewBag nei controller e nelle visualizzazioni.This collection can be referenced through either the ViewData or ViewBag properties on controllers and views. La proprietà ViewData è un dizionario di oggetti con tipizzazione debole.The ViewData property is a dictionary of weakly typed objects. La proprietà ViewBag è un wrapper di ViewData che offre proprietà dinamiche per la raccolta ViewData sottostante.The ViewBag property is a wrapper around ViewData that provides dynamic properties for the underlying ViewData collection. Nota: Per le ricerche di chiavi non viene fatta distinzione tra maiuscole e minuscole sia per ViewData che per ViewBag.Note: Key lookups are case-insensitive for both ViewData and ViewBag.

ViewData e ViewBag vengono risolte in modo dinamico in fase di esecuzione.ViewData and ViewBag are dynamically resolved at runtime. Poiché non offrono il controllo del tipo in fase di compilazione, entrambe sono in genere più soggette a errori rispetto all'uso di un elemento viewmodel.Since they don't offer compile-time type checking, both are generally more error-prone than using a viewmodel. Per questo motivo, alcuni sviluppatori preferiscono non usare mai ViewData e ViewBag o usarle il meno possibile.For that reason, some developers prefer to minimally or never use ViewData and ViewBag.

ViewDataViewData

ViewData è un oggetto ViewDataDictionary a cui si accede tramite le chiavi string.ViewData is a ViewDataDictionary object accessed through string keys. I dati di tipo stringa possono essere archiviati e usati direttamente, senza la necessità di un cast, ma è necessario eseguire il cast di altri valori dell'oggetto ViewData in tipi specifici quando vengono estratti.String data can be stored and used directly without the need for a cast, but you must cast other ViewData object values to specific types when you extract them. È possibile usare ViewData per passare i dati dai controller alle visualizzazioni e al loro interno, inclusi visualizzazioni parziali e layout.You can use ViewData to pass data from controllers to views and within views, including partial views and layouts.

Nell'esempio seguente vengono impostati i valori per una formula di saluto e un indirizzo usando ViewData in un'azione:The following is an example that sets values for a greeting and an address using ViewData in an action:

public IActionResult SomeAction()
{
    ViewData["Greeting"] = "Hello";
    ViewData["Address"]  = new Address()
    {
        Name = "Steve",
        Street = "123 Main St",
        City = "Hudson",
        State = "OH",
        PostalCode = "44236"
    };

    return View();
}

Lavorare con i dati in una visualizzazione:Work with the data in a view:

@{
    // Since Address isn't a string, it requires a cast.
    var address = ViewData["Address"] as Address;
}

@ViewData["Greeting"] World!

<address>
    @address.Name<br>
    @address.Street<br>
    @address.City, @address.State @address.PostalCode
</address>

Attributo ViewDataViewData attribute

Un altro approccio che usa ViewDataDictionary è ViewDataAttribute.Another approach that uses the ViewDataDictionary is ViewDataAttribute. I valori delle proprietà nei controller o nei modelli Razor Page decorate con [ViewData] vengono archiviati e caricati dal dizionario.Properties on controllers or Razor Page models decorated with [ViewData] have their values stored and loaded from the dictionary.

Nell'esempio seguente il controller Home contiene una proprietà Title decorata con [ViewData].In the following example, the Home controller contains a Title property decorated with [ViewData]. Il metodo About imposta il titolo per la visualizzazione About (Informazioni):The About method sets the title for the About view:

public class HomeController : Controller
{
    [ViewData]
    public string Title { get; set; }

    public IActionResult About()
    {
        Title = "About Us";
        ViewData["Message"] = "Your application description page.";

        return View();
    }
}

Nella visualizzazione About (Informazioni) accedere alla proprietà Title come proprietà del modello:In the About view, access the Title property as a model property:

<h1>@Model.Title</h1>

Nel layout il titolo viene letto dal dizionario ViewData:In the layout, the title is read from the ViewData dictionary:

<!DOCTYPE html>
<html lang="en">
<head>
    <title>@ViewData["Title"] - WebApplication</title>
    ...

ViewBagViewBag

ViewBag non è disponibile in Razor Pages.ViewBag isn't available in Razor Pages.

ViewBag è un oggetto DynamicViewData che consente l'accesso dinamico agli oggetti archiviati in ViewData.ViewBag is a DynamicViewData object that provides dynamic access to the objects stored in ViewData. ViewBag può risultare più comodo da usare poiché non richiede l'esecuzione del cast.ViewBag can be more convenient to work with, since it doesn't require casting. Nell'esempio seguente viene illustrato come usare ViewBag con lo stesso risultato che si ottiene con l'uso di ViewData descritto in precedenza:The following example shows how to use ViewBag with the same result as using ViewData above:

public IActionResult SomeAction()
{
    ViewBag.Greeting = "Hello";
    ViewBag.Address  = new Address()
    {
        Name = "Steve",
        Street = "123 Main St",
        City = "Hudson",
        State = "OH",
        PostalCode = "44236"
    };

    return View();
}
@ViewBag.Greeting World!

<address>
    @ViewBag.Address.Name<br>
    @ViewBag.Address.Street<br>
    @ViewBag.Address.City, @ViewBag.Address.State @ViewBag.Address.PostalCode
</address>

Uso simultaneo di ViewData e ViewBagUsing ViewData and ViewBag simultaneously

ViewBag non è disponibile in Razor Pages.ViewBag isn't available in Razor Pages.

Dal momento che ViewData e ViewBag fanno riferimento alla stessa raccolta ViewData sottostante, è possibile usare ViewData e ViewBag e combinarle durante la lettura e la scrittura dei valori.Since ViewData and ViewBag refer to the same underlying ViewData collection, you can use both ViewData and ViewBag and mix and match between them when reading and writing values.

Impostare il titolo usando ViewBag e la descrizione usando ViewData all'inizio di una visualizzazione About.cshtml:Set the title using ViewBag and the description using ViewData at the top of an About.cshtml view:

@{
    Layout = "/Views/Shared/_Layout.cshtml";
    ViewBag.Title = "About Contoso";
    ViewData["Description"] = "Let us tell you about Contoso's philosophy and mission.";
}

Leggere le proprietà ma invertire l'uso di ViewData e ViewBag.Read the properties but reverse the use of ViewData and ViewBag. Nel file _Layout.cshtml ottenere il titolo usando ViewData e ottenere la descrizione usando ViewBag:In the _Layout.cshtml file, obtain the title using ViewData and obtain the description using ViewBag:

<!DOCTYPE html>
<html lang="en">
<head>
    <title>@ViewData["Title"]</title>
    <meta name="description" content="@ViewBag.Description">
    ...

Tenere presente che per ViewData non è necessario eseguire il cast delle stringhe.Remember that strings don't require a cast for ViewData. È possibile usare @ViewData["Title"] senza eseguire il cast.You can use @ViewData["Title"] without casting.

L'uso simultaneo di ViewData e ViewBag funziona, così come funziona la combinazione di entrambe durante la lettura e la scrittura delle proprietà.Using both ViewData and ViewBag at the same time works, as does mixing and matching reading and writing the properties. Viene eseguito il rendering del markup seguente:The following markup is rendered:

<!DOCTYPE html>
<html lang="en">
<head>
    <title>About Contoso</title>
    <meta name="description" content="Let us tell you about Contoso's philosophy and mission.">
    ...

Riepilogo delle differenze tra ViewData e ViewBagSummary of the differences between ViewData and ViewBag

ViewBag non è disponibile in Razor Pages.ViewBag isn't available in the Razor Pages.

  • ViewData
    • Deriva da ViewDataDictionary e include quindi proprietà di dizionario che possono risultare utili, ad esempio ContainsKey, Add, Remove e Clear.Derives from ViewDataDictionary, so it has dictionary properties that can be useful, such as ContainsKey, Add, Remove, and Clear.
    • Le chiavi nel dizionario sono stringhe, pertanto lo spazio vuoto è consentito.Keys in the dictionary are strings, so whitespace is allowed. Esempio: ViewData["Some Key With Whitespace"]Example: ViewData["Some Key With Whitespace"]
    • Per usare ViewData è necessario eseguire il cast di tutti i tipi diversi da string nella visualizzazione.Any type other than a string must be cast in the view to use ViewData.
  • ViewBag
    • Deriva da DynamicViewData e consente quindi la creazione di proprietà dinamiche usando la notazione del punto (@ViewBag.SomeKey = <value or object>). L'esecuzione del cast non è necessaria.Derives from DynamicViewData, so it allows the creation of dynamic properties using dot notation (@ViewBag.SomeKey = <value or object>), and no casting is required. La sintassi di ViewBag velocizza l'aggiunta in controller e visualizzazioni.The syntax of ViewBag makes it quicker to add to controllers and views.
    • Verificare la presenza di valori Null è più facile.Simpler to check for null values. Esempio: @ViewBag.Person?.NameExample: @ViewBag.Person?.Name

Quando usare ViewData o ViewBagWhen to use ViewData or ViewBag

ViewData e ViewBag sono entrambi approcci ugualmente validi per passare piccole quantità di dati tra controller e visualizzazioni.Both ViewData and ViewBag are equally valid approaches for passing small amounts of data among controllers and views. La scelta di quello da usare è basata sulla preferenza.The choice of which one to use is based on preference. È possibile combinare oggetti ViewData e ViewBag. La lettura e la gestione del codice risulteranno tuttavia più semplici con un unico approccio usato in modo coerente.You can mix and match ViewData and ViewBag objects, however, the code is easier to read and maintain with one approach used consistently. Entrambi gli approcci vengono risolti in modo dinamico in fase di esecuzione e possono quindi determinare errori di runtime.Both approaches are dynamically resolved at runtime and thus prone to causing runtime errors. Alcuni team di sviluppo li evitano.Some development teams avoid them.

Visualizzazioni dinamicheDynamic views

Le visualizzazioni che non dichiarano un tipo di modello usando @model ma a cui è stata passata l'istanza di un modello, ad esempio return View(Address);, possono fare riferimento alle proprietà dell'istanza in modo dinamico:Views that don't declare a model type using @model but that have a model instance passed to them (for example, return View(Address);) can reference the instance's properties dynamically:

<address>
    @Model.Street<br>
    @Model.City, @Model.State @Model.PostalCode<br>
    <abbr title="Phone">P:</abbr> 425.555.0100
</address>

Questa funzionalità offre flessibilità ma non offre la protezione della compilazione o IntelliSense.This feature offers flexibility but doesn't offer compilation protection or IntelliSense. Se la proprietà non esiste, in fase di esecuzione la generazione della pagina Web non riesce.If the property doesn't exist, webpage generation fails at runtime.

Altre funzionalità delle visualizzazioniMore view features

Gli helper tag semplificano l'aggiunta del comportamento sul lato server ai tag HTML esistenti.Tag Helpers make it easy to add server-side behavior to existing HTML tags. Grazie all'uso degli helper tag, è possibile evitare di scrivere codice personalizzato o helper all'interno delle visualizzazioni.Using Tag Helpers avoids the need to write custom code or helpers within your views. Gli helper tag vengono applicati come attributi agli elementi HTML e vengono ignorati dagli editor che non sono in grado di elaborarli.Tag helpers are applied as attributes to HTML elements and are ignored by editors that can't process them. Ciò consente di modificare ed eseguire il rendering del markup delle visualizzazioni in un'ampia gamma di strumenti.This allows you to edit and render view markup in a variety of tools.

La generazione di markup HTML personalizzato può essere ottenuta con molti helper HTML predefiniti.Generating custom HTML markup can be achieved with many built-in HTML Helpers. Una logica dell'interfaccia utente più complessa può essere gestita dai componenti di visualizzazione.More complex user interface logic can be handled by View Components. I componenti di visualizzazione offrono lo stesso tipo di progettazione SoC offerta dai controller e dalle visualizzazioni.View components provide the same SoC that controllers and views offer. Possono eliminare la necessità di azioni e visualizzazioni che gestiscono i dati usati da elementi comuni dell'interfaccia utente.They can eliminate the need for actions and views that deal with data used by common user interface elements.

Come molti altri aspetti di ASP.NET Core, le visualizzazioni supportano l'inserimento di dipendenze, consentendo che i servizi siano inseriti nelle visualizzazioni.Like many other aspects of ASP.NET Core, views support dependency injection, allowing services to be injected into views.