Visão geral do ASP.NET Core MVCOverview of ASP.NET Core MVC

Por Steve SmithBy Steve Smith

O ASP.NET Core MVC é uma estrutura avançada para a criação de aplicativos Web e APIs usando o padrão de design Model-View-Controller.ASP.NET Core MVC is a rich framework for building web apps and APIs using the Model-View-Controller design pattern.

O que é o padrão MVC?What is the MVC pattern?

O padrão de arquitetura MVC (Model-View-Controller) separa um aplicativo em três grupos de componentes principais: Modelos, Exibições e Componentes.The Model-View-Controller (MVC) architectural pattern separates an application into three main groups of components: Models, Views, and Controllers. Esse padrão ajuda a obter a separação de interesses.This pattern helps to achieve separation of concerns. Usando esse padrão, as solicitações de usuário são encaminhadas para um Controlador, que é responsável por trabalhar com o Modelo para executar as ações do usuário e/ou recuperar os resultados de consultas.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. O Controlador escolhe a Exibição a ser exibida para o usuário e fornece-a com os dados do Modelo solicitados.The Controller chooses the View to display to the user, and provides it with any Model data it requires.

O seguinte diagrama mostra os três componentes principais e quais deles referenciam os outros:The following diagram shows the three main components and which ones reference the others:

Padrão MVC

Essa descrição das responsabilidades ajuda você a dimensionar o aplicativo em termos de complexidade, porque é mais fácil de codificar, depurar e testar algo (modelo, exibição ou controlador) que tem um único trabalho (e que segue o Princípio da Responsabilidade Única).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 (and follows the Single Responsibility Principle). É mais difícil atualizar, testar e depurar um código que tem dependências distribuídas em duas ou mais dessas três áreas.It's more difficult to update, test, and debug code that has dependencies spread across two or more of these three areas. Por exemplo, a lógica da interface do usuário tende a ser alterada com mais frequência do que a lógica de negócios.For example, user interface logic tends to change more frequently than business logic. Se o código de apresentação e a lógica de negócios forem combinados em um único objeto, um objeto que contém a lógica de negócios precisa ser modificado sempre que a interface do usuário é alterada.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. Isso costuma introduzir erros e exige um novo teste da lógica de negócios após cada alteração mínima da interface do usuário.This often introduces errors and requires the retesting of business logic after every minimal user interface change.

Observação

A exibição e o controlador dependem do modelo.Both the view and the controller depend on the model. No entanto, o modelo não depende da exibição nem do controlador.However, the model depends on neither the view nor the controller. Esse é um dos principais benefícios da separação.This is one of the key benefits of the separation. Essa separação permite que o modelo seja criado e testado de forma independente da apresentação visual.This separation allows the model to be built and tested independent of the visual presentation.

Responsabilidades do ModeloModel Responsibilities

O Modelo em um aplicativo MVC representa o estado do aplicativo e qualquer lógica de negócios ou operação que deve ser executada por ele.The Model in an MVC application represents the state of the application and any business logic or operations that should be performed by it. A lógica de negócios deve ser encapsulada no modelo, juntamente com qualquer lógica de implementação, para persistir o estado do aplicativo.Business logic should be encapsulated in the model, along with any implementation logic for persisting the state of the application. As exibições fortemente tipadas normalmente usam tipos ViewModel criados para conter os dados a serem exibidos nessa exibição.Strongly-typed views typically use ViewModel types designed to contain the data to display on that view. O controlador cria e popula essas instâncias de ViewModel com base no modelo.The controller creates and populates these ViewModel instances from the model.

Observação

Há várias maneiras de organizar o modelo em um aplicativo que usa o padrão de arquitetura MVC.There are many ways to organize the model in an app that uses the MVC architectural pattern. Saiba mais sobre alguns tipos diferentes de tipos de modelo.Learn more about some different kinds of model types.

Responsabilidades da ExibiçãoView Responsibilities

As exibições são responsáveis por apresentar o conteúdo por meio da interface do usuário.Views are responsible for presenting content through the user interface. Elas usam o mecanismo de exibição do Razor para inserir o código .NET em uma marcação HTML.They use the Razor view engine to embed .NET code in HTML markup. Deve haver uma lógica mínima nas exibições e qualquer lógica contida nelas deve se relacionar à apresentação do conteúdo.There should be minimal logic within views, and any logic in them should relate to presenting content. Se você precisar executar uma grande quantidade de lógica em arquivos de exibição para exibir dados de um modelo complexo, considere o uso de um Componente de Exibição, ViewModel ou um modelo de exibição para simplificar a exibição.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.

Responsabilidades do ControladorController Responsibilities

Os controladores são os componentes que cuidam da interação do usuário, trabalham com o modelo e, em última análise, selecionam uma exibição a ser renderizada.Controllers are the components that handle user interaction, work with the model, and ultimately select a view to render. Em um aplicativo MVC, a exibição mostra apenas informações; o controlador manipula e responde à entrada e à interação do usuário.In an MVC application, the view only displays information; the controller handles and responds to user input and interaction. No padrão MVC, o controlador é o ponto de entrada inicial e é responsável por selecionar quais tipos de modelo serão usados para o trabalho e qual exibição será renderizada (daí seu nome – ele controla como o aplicativo responde a determinada solicitação).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).

Observação

Os controladores não devem ser excessivamente complicados por muitas responsabilidades.Controllers shouldn't be overly complicated by too many responsibilities. Para evitar que a lógica do controlador se torne excessivamente complexa, use o Princípio da Responsabilidade Única para empurrar a lógica de negócios para fora do controlador e inseri-la no modelo de domínio.To keep controller logic from becoming overly complex, use the Single Responsibility Principle to push business logic out of the controller and into the domain model.

Dica

Se você achar que as ações do controlador executam com frequência os mesmos tipos de ações, siga o Princípio Don't Repeat Yourself movendo essas ações comuns para filtros.If you find that your controller actions frequently perform the same kinds of actions, you can follow the Don't Repeat Yourself principle by moving these common actions into filters.

O que é ASP.NET Core MVCWhat is ASP.NET Core MVC

A estrutura do ASP.NET Core MVC é uma estrutura de apresentação leve, de software livre e altamente testável, otimizada para uso com o 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 fornece uma maneira com base em padrões para criar sites dinâmicos que habilitam uma separação limpa de preocupações.ASP.NET Core MVC provides a patterns-based way to build dynamic websites that enables a clean separation of concerns. Ele lhe dá controle total sobre a marcação, dá suporte ao desenvolvimento amigável a TDD e usa os padrões da web mais recentes.It gives you full control over markup, supports TDD-friendly development and uses the latest web standards.

RecursosFeatures

ASP.NET Core MVC inclui o seguinte:ASP.NET Core MVC includes the following:

RoteamentoRouting

O ASP.NET Core MVC baseia-se no roteamento do ASP.NET Core, um componente de mapeamento de URL avançado que permite criar aplicativos que têm URLs compreensíveis e pesquisáveis.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. Isso permite que você defina padrões de nomenclatura de URL do aplicativo que funcionam bem para SEO (otimização do mecanismo de pesquisa) e para a geração de links, sem levar em consideração como os arquivos no servidor Web estão organizados.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. Defina as rotas usando uma sintaxe de modelo de rota conveniente que dá suporte a restrições de valor de rota, padrões e valores opcionais.You can define your routes using a convenient route template syntax that supports route value constraints, defaults and optional values.

O roteamento baseado em convenção permite definir globalmente os formatos de URL aceitos pelo aplicativo e como cada um desses formatos é mapeado para um método de ação específico em determinado controlador.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. Quando uma solicitação de entrada é recebida, o mecanismo de roteamento analisa a URL e corresponde-a a um dos formatos de URL definidos. Em seguida, ele chama o método de ação do controlador associado.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?}");

O roteamento de atributo permite que você especifique as informações de roteamento decorando os controladores e as ações com atributos que definem as rotas do aplicativo.Attribute routing enables you to specify routing information by decorating your controllers and actions with attributes that define your application's routes. Isso significa que as definições de rota são colocadas ao lado do controlador e da ação aos quais estão associadas.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)
  {
    ...
  }
}

Associação de modelosModel binding

ASP.NET Core MVC associação de modelo converte dados de solicitação de cliente (valores de formulário, os dados de rota, parâmetros de cadeia de caracteres de consulta, os cabeçalhos HTTP) em objetos que o controlador pode manipular.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. Como resultado, a lógica de controlador não precisa fazer o trabalho de descobrir os dados de solicitação de entrada; ele simplesmente tem os dados como parâmetros para os métodos de ação.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) { ... }

Validação de modeloModel validation

O ASP.NET Core MVC dá suporte à validação pela decoração do objeto de modelo com atributos de validação de anotação de dados.ASP.NET Core MVC supports validation by decorating your model object with data annotation validation attributes. Os atributos de validação são verificados no lado do cliente antes que os valores sejam postados no servidor, bem como no servidor antes que a ação do controlador seja chamada.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; }
}

Uma ação do controlador: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);
}

A estrutura manipula a validação dos dados de solicitação no cliente e no servidor.The framework handles validating request data both on the client and on the server. A lógica de validação especificada em tipos de modelo é adicionada às exibições renderizados como anotações não invasivas e é imposta no navegador com o 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.

Injeção de dependênciaDependency injection

O ASP.NET Core tem suporte interno para DI (injeção de dependência).ASP.NET Core has built-in support for dependency injection (DI). No ASP.NET Core MVC, os controladores podem solicitar serviços necessários por meio de seus construtores, possibilitando o acompanhamento do princípio de dependências explícitas.In ASP.NET Core MVC, controllers can request needed services through their constructors, allowing them to follow the Explicit Dependencies Principle.

O aplicativo também pode usar a injeção de dependência em arquivos no exibição, usando a diretiva @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>

FiltrosFilters

Os filtros ajudam os desenvolvedores a encapsular interesses paralelos, como tratamento de exceção ou autorização.Filters help developers encapsulate cross-cutting concerns, like exception handling or authorization. Os filtros permitem a execução de uma lógica pré e pós-processamento personalizada para métodos de ação e podem ser configurados para execução em determinados pontos no pipeline de execução de uma solicitação específica.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. Os filtros podem ser aplicados a controladores ou ações como atributos (ou podem ser executados globalmente).Filters can be applied to controllers or actions as attributes (or can be run globally). Vários filtros (como Authorize) são incluídos na estrutura.Several filters (such as Authorize) are included in the framework. [Authorize] é o atributo usado para criar filtros de autorização do MVC.[Authorize] is the attribute that is used to create MVC authorization filters.

[Authorize]
   public class AccountController : Controller
   {

ÁreasAreas

As áreas fornecem uma maneira de particionar um aplicativo Web ASP.NET Core MVC grande em agrupamentos funcionais menores.Areas provide a way to partition a large ASP.NET Core MVC Web app into smaller functional groupings. Uma área é uma estrutura MVC dentro de um aplicativo.An area is an MVC structure inside an application. Em um projeto MVC, componentes lógicos como Modelo, Controlador e Exibição são mantidos em pastas diferentes e o MVC usa convenções de nomenclatura para criar a relação entre esses componentes.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. Para um aplicativo grande, pode ser vantajoso particionar o aplicativo em áreas de nível alto separadas de funcionalidade.For a large app, it may be advantageous to partition the app into separate high level areas of functionality. Por exemplo, um aplicativo de comércio eletrônico com várias unidades de negócios, como check-out, cobrança e pesquisa, etc. Cada uma dessas unidades têm suas próprias exibições de componente lógico, controladores e modelos.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.

APIs da WebWeb APIs

Além de ser uma ótima plataforma para a criação de sites, o ASP.NET Core MVC tem um excelente suporte para a criação de APIs Web.In addition to being a great platform for building web sites, ASP.NET Core MVC has great support for building Web APIs. Crie serviços que alcançam uma ampla gama de clientes, incluindo navegadores e dispositivos móveis.You can build services that reach a broad range of clients including browsers and mobile devices.

A estrutura inclui suporte para a negociação de conteúdo HTTP com suporte interno para formatar dados como JSON ou XML.The framework includes support for HTTP content-negotiation with built-in support to format data as JSON or XML. Escreva formatadores personalizados para adicionar suporte para seus próprios formatos.Write custom formatters to add support for your own formats.

Use a geração de links para habilitar o suporte para hipermídia.Use link generation to enable support for hypermedia. Habilite o suporte para o CORS (Compartilhamento de Recursos Entre Origens) com facilidade, de modo que as APIs Web possam ser compartilhadas entre vários aplicativos Web.Easily enable support for cross-origin resource sharing (CORS) so that your Web APIs can be shared across multiple Web applications.

Capacidade de testeTestability

O uso pela estrutura da injeção de dependência e de interfaces a torna adequada para teste de unidade. Além disso, a estrutura inclui recursos (como um provedor TestHost e InMemory para o Entity Framework) que também agiliza e facilita a execução de testes de integração.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. Saiba mais sobre como testar a lógica do controlador.Learn more about how to test controller logic.

Mecanismo de exibição do RazorRazor view engine

As exibições do ASP.NET Core MVC usam o mecanismo de exibição do Razor para renderizar exibições.ASP.NET Core MVC views use the Razor view engine to render views. Razor é uma linguagem de marcação de modelo compacta, expressiva e fluida para definir exibições usando um código C# inserido.Razor is a compact, expressive and fluid template markup language for defining views using embedded C# code. O Razor é usado para gerar o conteúdo da Web no servidor de forma dinâmica.Razor is used to dynamically generate web content on the server. Você pode combinar o código do servidor com o código e o conteúdo do lado cliente de maneira limpa.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>

Usando o mecanismo de exibição do Razor, você pode definir layouts, exibições parciais e seções substituíveis.Using the Razor view engine you can define layouts, partial views and replaceable sections.

Exibições fortemente tipadasStrongly typed views

As exibições do Razor no MVC podem ser fortemente tipadas com base no modelo.Razor views in MVC can be strongly typed based on your model. Os controladores podem passar um modelo fortemente tipado para as exibições, permitindo que elas tenham a verificação de tipo e o suporte do IntelliSense.Controllers can pass a strongly typed model to views enabling your views to have type checking and IntelliSense support.

Por exemplo, a seguinte exibição renderiza um modelo do 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>

Auxiliares de MarcaTag Helpers

Os Auxiliares de Marca permitem que o código do servidor participe da criação e renderização de elementos HTML em arquivos do Razor.Tag Helpers enable server side code to participate in creating and rendering HTML elements in Razor files. Use auxiliares de marca para definir marcas personalizadas (por exemplo, <environment>) ou para modificar o comportamento de marcas existentes (por exemplo, <label>).You can use tag helpers to define custom tags (for example, <environment>) or to modify the behavior of existing tags (for example, <label>). Os Auxiliares de Marca associam a elementos específicos com base no nome do elemento e seus atributos.Tag Helpers bind to specific elements based on the element name and its attributes. Eles oferecem os benefícios da renderização do lado do servidor, enquanto preservam uma experiência de edição de HTML.They provide the benefits of server-side rendering while still preserving an HTML editing experience.

Há muitos Auxiliares de Marca internos para tarefas comuns – como criação de formulários, links, carregamento de ativos e muito mais – e ainda outros disponíveis em repositórios GitHub públicos e como 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. Os Auxiliares de Marca são criados no C# e são direcionados a elementos HTML de acordo com o nome do elemento, o nome do atributo ou a marca pai.Tag Helpers are authored in C#, and they target HTML elements based on element name, attribute name, or parent tag. Por exemplo, o LinkTagHelper interno pode ser usado para criar um link para a ação Login do 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>

O EnvironmentTagHelper pode ser usado para incluir scripts diferentes nas exibições (por exemplo, bruto ou minimizado) de acordo com o ambiente de tempo de execução, como Desenvolvimento, Preparo ou Produção: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>

Os Auxiliares de Marca fornecem uma experiência de desenvolvimento amigável a HTML e um ambiente avançado do IntelliSense para a criação de HTML e marcação do Razor.Tag Helpers provide an HTML-friendly development experience and a rich IntelliSense environment for creating HTML and Razor markup. A maioria dos Auxiliares de Marca internos é direcionada a elementos HTML existentes e fornece atributos do lado do servidor para o elemento.Most of the built-in Tag Helpers target existing HTML elements and provide server-side attributes for the element.

Componentes da exibiçãoView Components

Os Componentes de Exibição permitem que você empacote a lógica de renderização e reutilize-a em todo o aplicativo.View Components allow you to package rendering logic and reuse it throughout the application. São semelhantes às exibições parciais, mas com a lógica associada.They're similar to partial views, but with associated logic.

Versão de compatibilidadeCompatibility version

O método SetCompatibilityVersion permite que um aplicativo aceite ou recuse as possíveis alterações da falha de comportamento introduzidas no ASP.NET Core MVC 2.1 ou posteriores.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.

Para obter mais informações, consulte Versão de compatibilidade do ASP.NET Core MVC.For more information, see Versão de compatibilidade do ASP.NET Core MVC.