Panoramica di ASP.NET MVCOverview of ASP.NET Core MVC

Steve SmithBy Steve Smith

ASP.NET Core MVC è un framework avanzato per la creazione di app Web e API tramite lo schema progettuale MVC (Model-View-Controller).ASP.NET Core MVC is a rich framework for building web apps and APIs using the Model-View-Controller design pattern.

Cos'è lo schema MVC?What is the MVC pattern?

Nello schema architetturale MVC (Model-View-Controller) l'applicazione viene suddivisa in tre gruppi principali di componenti: modelli, visualizzazioni e controller.The Model-View-Controller (MVC) architectural pattern separates an application into three main groups of components: Models, Views, and Controllers. Questo schema consente di realizzare la separazione delle competenze.This pattern helps to achieve separation of concerns. Grazie all'uso di questo schema, le richieste dell'utente vengono indirizzate a un controller responsabile di interagire con il modello per eseguire le azioni dell'utente e/o recuperare i risultati delle query.Using this pattern, user requests are routed to a Controller which is responsible for working with the Model to perform user actions and/or retrieve results of queries. Il controller sceglie la visualizzazione da mostrare all'utente e le fornisce i dati del modello necessari.The Controller chooses the View to display to the user, and provides it with any Model data it requires.

Il diagramma seguente illustra i tre componenti principali e quali fanno riferimento agli altri:The following diagram shows the three main components and which ones reference the others:

Schema MVC

Questa definizione delle responsabilità consente di ridimensionare l'applicazione in termini di complessità, perché è più facile scrivere codice, eseguire il debug e testare qualcosa (modello, visualizzazione o controller) che presenta un unico processo.This delineation of responsibilities helps you scale the application in terms of complexity because it's easier to code, debug, and test something (model, view, or controller) that has a single job. È più difficile aggiornare, testare ed eseguire il debug di codice con dipendenze distribuite in due o più di queste tre aree.It's more difficult to update, test, and debug code that has dependencies spread across two or more of these three areas. La logica dell'interfaccia utente, ad esempio, tende a cambiare più frequentemente rispetto alla logica di business.For example, user interface logic tends to change more frequently than business logic. Se il codice di presentazione e la logica di business sono combinati in un singolo oggetto, l'oggetto che contiene la logica di business deve essere modificato ogni volta che l'interfaccia utente viene modificata.If presentation code and business logic are combined in a single object, an object containing business logic must be modified every time the user interface is changed. Ciò spesso introduce errori e rende necessaria la ripetizione dei test della logica di business dopo ogni minima modifica dell'interfaccia utente.This often introduces errors and requires the retesting of business logic after every minimal user interface change.

Nota

La visualizzazione e il controller dipendono dal modello.Both the view and the controller depend on the model. Il modello, tuttavia, non dipende né dalla visualizzazione né dal controller.However, the model depends on neither the view nor the controller. Questo è uno dei principali vantaggi della separazione.This is one of the key benefits of the separation. La separazione consente di compilare e testare il modello in modo indipendente dalla presentazione visiva.This separation allows the model to be built and tested independent of the visual presentation.

Responsabilità del modelloModel Responsibilities

In un'applicazione MVC il modello rappresenta lo stato dell'applicazione e la logica di business o le operazioni che essa deve eseguire.The Model in an MVC application represents the state of the application and any business logic or operations that should be performed by it. La logica di business deve essere incapsulata nel modello insieme alla logica di implementazione per rendere persistente lo stato dell'applicazione.Business logic should be encapsulated in the model, along with any implementation logic for persisting the state of the application. Le visualizzazioni fortemente tipizzate usano in genere tipi ViewModel progettati per contenere i dati da visualizzare in una particolare visualizzazione.Strongly-typed views typically use ViewModel types designed to contain the data to display on that view. Il controller crea e popola queste istanze di ViewModel dal modello.The controller creates and populates these ViewModel instances from the model.

Responsabilità della visualizzazioneView Responsibilities

Le visualizzazioni sono responsabili della presentazione del contenuto tramite l'interfaccia utente.Views are responsible for presenting content through the user interface. Usano il motore di visualizzazione Razor per incorporare il codice .NET nel markup HTML.They use the Razor view engine to embed .NET code in HTML markup. Nelle visualizzazioni la quantità di logica deve essere minima e la logica in esse contenuta deve essere relativa alla presentazione del contenuto.There should be minimal logic within views, and any logic in them should relate to presenting content. Se è necessario eseguire una grande quantità di logica nei file di visualizzazione per visualizzare dati da un modello complesso, valutare l'uso di un componente di visualizzazione, un ViewModel o un modello di visualizzazione per semplificare la visualizzazione.If you find the need to perform a great deal of logic in view files in order to display data from a complex model, consider using a View Component, ViewModel, or view template to simplify the view.

Responsabilità del controllerController Responsibilities

I controller sono i componenti che gestiscono l'interazione dell'utente, interagiscono con il modello e selezionano in definitiva la visualizzazione di cui verrà eseguito il rendering.Controllers are the components that handle user interaction, work with the model, and ultimately select a view to render. In un'applicazione MVC la visualizzazione presenta solo le informazioni, mentre il controller gestisce e risponde all'input e all'interazione dell'utente.In an MVC application, the view only displays information; the controller handles and responds to user input and interaction. Nello schema MVC il controller è il punto di ingresso iniziale ed è responsabile della selezione dei tipi di modello con cui interagire e della visualizzazione di cui eseguire il rendering. Come suggerito dal nome, questo componente controlla il modo in cui l'app risponde a una determinata richiesta.In the MVC pattern, the controller is the initial entry point, and is responsible for selecting which model types to work with and which view to render (hence its name - it controls how the app responds to a given request).

Nota

È consigliabile non sovraccaricare eccessivamente i controller con troppe responsabilità.Controllers shouldn't be overly complicated by too many responsibilities. Per evitare che la logica del controller diventi troppo complessa, escludere la logica di business dal controller e includerla nel modello di dominio.To keep controller logic from becoming overly complex, push business logic out of the controller and into the domain model.

Suggerimento

Se si ritiene che le azioni del controller eseguano frequentemente gli stessi tipi di azioni, spostare queste azioni comuni nei filtri.If you find that your controller actions frequently perform the same kinds of actions, move these common actions into filters.

Cos'è ASP.NET Core MVCWhat is ASP.NET Core MVC

Il framework ASP.NET Core MVC è un framework di presentazione leggero, open source e altamente testabile ottimizzato per l'uso con ASP.NET Core.The ASP.NET Core MVC framework is a lightweight, open source, highly testable presentation framework optimized for use with ASP.NET Core.

ASP.NET Core MVC offre un sistema basato su schemi per la creazione di siti Web dinamici che consente una netta separazione delle competenze.ASP.NET Core MVC provides a patterns-based way to build dynamic websites that enables a clean separation of concerns. Offre il controllo completo sul markup, supporta lo sviluppo basato su test e usa gli standard Web più recenti.It gives you full control over markup, supports TDD-friendly development and uses the latest web standards.

FunzionalitàFeatures

ASP.NET Core MVC include:ASP.NET Core MVC includes the following:

RoutingRouting

ASP.NET Core MVC si basa sul routing di ASP.NET Core, un potente componente per il mapping di URL che consente di compilare applicazioni con URL comprensibili che supportano la ricerca.ASP.NET Core MVC is built on top of ASP.NET Core's routing, a powerful URL-mapping component that lets you build applications that have comprehensible and searchable URLs. Ciò consente di definire criteri di denominazione dell'URL dell'applicazione che funzionano perfettamente per l'ottimizzazione dei motori di ricerca (SEO) e la generazione di collegamenti, indipendentemente da come sono organizzati i file nel server Web.This enables you to define your application's URL naming patterns that work well for search engine optimization (SEO) and for link generation, without regard for how the files on your web server are organized. È possibile definire le route usando una pratica sintassi del modello di route che supporta i vincoli di valore delle route, i valori predefiniti e quelli facoltativi.You can define your routes using a convenient route template syntax that supports route value constraints, defaults and optional values.

Il routing basato sulle convenzioni consente di definire in modo globale i formati di URL accettati dall'applicazione e come ognuno di questi formati viene mappato a un metodo di azione specifico in un determinato controller.Convention-based routing enables you to globally define the URL formats that your application accepts and how each of those formats maps to a specific action method on given controller. Alla ricezione di una richiesta in ingresso, il motore di routing analizza l'URL e lo confronta con uno dei formati di URL definiti, quindi chiama il metodo di azione del controller associato.When an incoming request is received, the routing engine parses the URL and matches it to one of the defined URL formats, and then calls the associated controller's action method.

routes.MapRoute(name: "Default", template: "{controller=Home}/{action=Index}/{id?}");

Il routing di attributi consente di specificare informazioni di routing assegnando ai controller e alle azioni attributi che definiscono le route dell'applicazione.Attribute routing enables you to specify routing information by decorating your controllers and actions with attributes that define your application's routes. Ciò significa che le definizioni delle route vengono posizionate accanto al controller e all'azione a cui sono associate.This means that your route definitions are placed next to the controller and action with which they're associated.

[Route("api/[controller]")]
public class ProductsController : Controller
{
    [HttpGet("{id}")]
    public IActionResult GetProduct(int id)
    {
      ...
    }
}

Associazione di modelliModel binding

L'associazione di modelli di ASP.NET Core MVC converte i dati delle richieste client, ad esempio valori del modulo, dati della route, parametri della stringa di query, intestazioni HTTP, in oggetti che il controller è in grado di gestire.ASP.NET Core MVC model binding converts client request data (form values, route data, query string parameters, HTTP headers) into objects that the controller can handle. Di conseguenza, non è necessario che la logica del controller risolva i dati della richiesta in ingresso poiché li avrà semplicemente come parametri associati ai propri metodi di azione.As a result, your controller logic doesn't have to do the work of figuring out the incoming request data; it simply has the data as parameters to its action methods.

public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null) { ... }

Convalida modelloModel validation

ASP.NET Core MVC supporta la convalida assegnando all'oggetto modello attributi di convalida di annotazione dei dati.ASP.NET Core MVC supports validation by decorating your model object with data annotation validation attributes. Gli attributi di convalida vengono controllati sul lato client prima che i valori siano inviati al server, nonché nel server prima che sia chiamata l'azione del controller.The validation attributes are checked on the client side before values are posted to the server, as well as on the server before the controller action is called.

using System.ComponentModel.DataAnnotations;
public class LoginViewModel
{
    [Required]
    [EmailAddress]
    public string Email { get; set; }

    [Required]
    [DataType(DataType.Password)]
    public string Password { get; set; }

    [Display(Name = "Remember me?")]
    public bool RememberMe { get; set; }
}

Un'azione del controller:A controller action:

public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
{
    if (ModelState.IsValid)
    {
      // work with the model
    }
    // At this point, something failed, redisplay form
    return View(model);
}

Il framework gestisce la convalida dei dati della richiesta nel client e nel server.The framework handles validating request data both on the client and on the server. La logica di convalida specificata nei tipi di modello viene aggiunta alle visualizzazioni sottoposte a rendering come annotazioni discrete e viene applicata al browser con jQuery Validation.Validation logic specified on model types is added to the rendered views as unobtrusive annotations and is enforced in the browser with jQuery Validation.

Inserimento di dipendenzeDependency injection

ASP.NET Core include il supporto predefinito per l'inserimento di dipendenze.ASP.NET Core has built-in support for dependency injection (DI). In ASP.NET Core MVC i controller possono richiedere i servizi necessari attraverso i propri costruttori. Ciò consente loro di seguire il principio delle dipendenze esplicite.In ASP.NET Core MVC, controllers can request needed services through their constructors, allowing them to follow the Explicit Dependencies Principle.

L'app può inoltre usare l'inserimento di dipendenze nei file di visualizzazione tramite la direttiva @inject:Your app can also use dependency injection in view files, using the @inject directive:

@inject SomeService ServiceName

<!DOCTYPE html>
<html lang="en">
<head>
    <title>@ServiceName.GetTitle</title>
</head>
<body>
    <h1>@ServiceName.GetTitle</h1>
</body>
</html>

FiltriFilters

I filtri consentono agli sviluppatori di incapsulare questioni trasversali quali la gestione delle eccezioni o l'autorizzazione.Filters help developers encapsulate cross-cutting concerns, like exception handling or authorization. I filtri consentono l'esecuzione di logica pre-elaborazione e post-elaborazione personalizzata per i metodi di azione e possono essere configurati per l'esecuzione in determinate fasi della pipeline di esecuzione per una richiesta specifica.Filters enable running custom pre- and post-processing logic for action methods, and can be configured to run at certain points within the execution pipeline for a given request. È possibile applicare i filtri ai controller o alle azioni come attributi o eseguirli a livello globale.Filters can be applied to controllers or actions as attributes (or can be run globally). Il framework include diversi filtri, ad esempio, Authorize.Several filters (such as Authorize) are included in the framework. [Authorize] è l'attributo usato per creare filtri di autorizzazione MVC.[Authorize] is the attribute that is used to create MVC authorization filters.

[Authorize]
public class AccountController : Controller

AreeAreas

Le aree consentono di suddividere un'app Web ASP.NET Core MVC di grandi dimensioni in raggruppamenti funzionali più piccoli.Areas provide a way to partition a large ASP.NET Core MVC Web app into smaller functional groupings. Un'area è una struttura MVC all'interno di un'applicazione.An area is an MVC structure inside an application. In un progetto MVC i componenti logici come modello, controller e visualizzazione si trovano in cartelle diverse e MVC crea una relazione tra questi componenti tramite convenzioni di denominazione.In an MVC project, logical components like Model, Controller, and View are kept in different folders, and MVC uses naming conventions to create the relationship between these components. Per un'app di grandi dimensioni può risultare utile suddividere l'app in aree di funzionalità di alto livello distinte.For a large app, it may be advantageous to partition the app into separate high level areas of functionality. Ad esempio, un'app di e-commerce con più business unit, ad esempio checkout, fatturazione e ricerca e così via. Ognuna di queste unità dispone di visualizzazioni, controller e modelli di componenti logici.For instance, an e-commerce app with multiple business units, such as checkout, billing, and search etc. Each of these units have their own logical component views, controllers, and models.

API WebWeb APIs

Oltre a essere una piattaforma ideale per la creazione di siti Web, ASP.NET Core MVC include un ottimo supporto per la creazione di API Web.In addition to being a great platform for building web sites, ASP.NET Core MVC has great support for building Web APIs. È possibile creare servizi destinati a un'ampia gamma di client, tra cui browser e dispositivi mobili.You can build services that reach a broad range of clients including browsers and mobile devices.

Il framework include il supporto per la negoziazione del contenuto HTTP con il supporto predefinito per la formattazione dei dati come JSON o XML.The framework includes support for HTTP content-negotiation with built-in support to format data as JSON or XML. È possibile scrivere formattatori personalizzati per aggiungere il supporto per i propri formati.Write custom formatters to add support for your own formats.

Usare la generazione di collegamenti per abilitare il supporto per l'ipermedia.Use link generation to enable support for hypermedia. È possibile abilitare facilmente il supporto per la Condivisione di risorse tra le origini (CORS) in modo da poter condividere le proprie API Web tra più applicazioni Web.Easily enable support for cross-origin resource sharing (CORS) so that your Web APIs can be shared across multiple Web applications.

TestabilitàTestability

L'uso delle interfacce e dell'inserimento di dipendenze rende il framework adatto al testing unità. Il framework include inoltre funzionalità come TestHost e il provider InMemory per Entity Framework grazie alle quali i test di integrazione risultano semplici e veloci.The framework's use of interfaces and dependency injection make it well-suited to unit testing, and the framework includes features (like a TestHost and InMemory provider for Entity Framework) that make integration tests quick and easy as well. Per altre informazioni, vedere Test della logica dei controller.Learn more about how to test controller logic.

Motore di visualizzazione RazorRazor view engine

Le visualizzazioni ASP.NET Core MVC usano il motore di visualizzazione Razor per il rendering delle visualizzazioni.ASP.NET Core MVC views use the Razor view engine to render views. Razor è un linguaggio TML (Template Markup Language) compatto, espressivo e fluido per la definizione delle visualizzazioni tramite l'uso di codice C# incorporato.Razor is a compact, expressive and fluid template markup language for defining views using embedded C# code. Razor viene usato per generare in modo dinamico il contenuto Web nel server.Razor is used to dynamically generate web content on the server. È possibile combinare correttamente il codice server con il contenuto e il codice sul lato client.You can cleanly mix server code with client side content and code.

<ul>
    @for (int i = 0; i < 5; i++) {
        <li>List item @i</li>
    }
</ul>

Tramite il motore di visualizzazione Razor è possibile definire layout, visualizzazioni parziali e sezioni sostituibili.Using the Razor view engine you can define layouts, partial views and replaceable sections.

Visualizzazioni fortemente tipizzateStrongly typed views

Le visualizzazioni Razor in MVC possono essere fortemente tipizzate in base al modello.Razor views in MVC can be strongly typed based on your model. I controller sono in grado di passare un modello fortemente tipizzato alle visualizzazioni abilitando per queste ultime il controllo del tipo e il supporto IntelliSense.Controllers can pass a strongly typed model to views enabling your views to have type checking and IntelliSense support.

La visualizzazione seguente, ad esempio, esegue il rendering di un modello di tipo IEnumerable<Product>:For example, the following view renders a model of type IEnumerable<Product>:

@model IEnumerable<Product>
<ul>
    @foreach (Product p in Model)
    {
        <li>@p.Name</li>
    }
</ul>

Helper tagTag Helpers

Gli helper tag consentono al codice sul lato server di partecipare alla creazione e al rendering di elementi HTML nei file Razor.Tag Helpers enable server side code to participate in creating and rendering HTML elements in Razor files. È possibile usare gli helper tag per definire tag personalizzati, ad esempio <environment> o per modificare il comportamento di tag esistenti, ad esempio <label>.You can use tag helpers to define custom tags (for example, <environment>) or to modify the behavior of existing tags (for example, <label>). Gli helper tag vengono associati a elementi specifici in base al nome dell'elemento e ai relativi attributi.Tag Helpers bind to specific elements based on the element name and its attributes. Offrono i vantaggi del rendering lato server mantenendo al tempo stesso un'esperienza di modifica HTML.They provide the benefits of server-side rendering while still preserving an HTML editing experience.

Esistono molti helper tag predefiniti per le attività comuni, ad esempio la creazione di moduli e collegamenti, il caricamento di asset e così via, e altri ancora sono disponibili nei repository GitHub pubblici e come pacchetti NuGet.There are many built-in Tag Helpers for common tasks - such as creating forms, links, loading assets and more - and even more available in public GitHub repositories and as NuGet packages. Gli helper tag vengono creati in C# e hanno come destinazione gli elementi HTML in base al nome di elemento, nome di attributo o tag padre.Tag Helpers are authored in C#, and they target HTML elements based on element name, attribute name, or parent tag. L'helper tag LinkTagHelper predefinito, ad esempio, può essere usato per creare un collegamento all'azione Login di AccountsController:For example, the built-in LinkTagHelper can be used to create a link to the Login action of the AccountsController:

<p>
    Thank you for confirming your email.
    Please <a asp-controller="Account" asp-action="Login">Click here to Log in</a>.
</p>

EnvironmentTagHelper può essere usato per includere diversi script nelle visualizzazioni (ad esempio, non elaborate o minimizzate) in base all'ambiente di runtime, ad esempio ambiente sviluppo, di gestione temporanea o di produzione:The EnvironmentTagHelper can be used to include different scripts in your views (for example, raw or minified) based on the runtime environment, such as Development, Staging, or Production:

<environment names="Development">
    <script src="~/lib/jquery/dist/jquery.js"></script>
</environment>
<environment names="Staging,Production">
    <script src="https://ajax.aspnetcdn.com/ajax/jquery/jquery-2.1.4.min.js"
            asp-fallback-src="~/lib/jquery/dist/jquery.min.js"
            asp-fallback-test="window.jQuery">
    </script>
</environment>

Gli helper tag offrono un'esperienza di sviluppo HTML semplice e un ambiente IntelliSense avanzato per la creazione di markup HTML e Razor.Tag Helpers provide an HTML-friendly development experience and a rich IntelliSense environment for creating HTML and Razor markup. La maggior parte degli helper tag predefiniti hanno come destinazione elementi HTML esistenti e forniscono attributi sul lato server per l'elemento.Most of the built-in Tag Helpers target existing HTML elements and provide server-side attributes for the element.

Componenti di visualizzazioneView Components

I componenti di visualizzazione consentono di creare pacchetti di logica di rendering e di riusarla nell'applicazione.View Components allow you to package rendering logic and reuse it throughout the application. Sono simili alle visualizzazioni parziali, ma con la logica associata.They're similar to partial views, but with associated logic.

Versione di compatibilitàCompatibility version

Il metodo SetCompatibilityVersion consente a un'app di acconsentire o rifiutare esplicitamente modifiche potenzialmente importanti del comportamento introdotte in ASP.NET Core MVC 2.1 o versioni successive.The SetCompatibilityVersion method allows an app to opt-in or opt-out of potentially breaking behavior changes introduced in ASP.NET Core MVC 2.1 or later.

Per ulteriori informazioni, vedere Versione di compatibilità per ASP.NET Core MVC.For more information, see Versione di compatibilità per ASP.NET Core MVC.

Risorse aggiuntiveAdditional resources