Partilhar via

Visão geral do ASP.NET Core MVC

Por Steve Smith

ASP.NET Core MVC é uma framework rica para construir aplicações web e APIs utilizando o padrão de design Model-View-Controller.

Padrão MVC

O padrão arquitetónico Model-View-Controller (MVC) separa uma aplicação em três grupos principais de componentes: Modelos, Vistas e Controladores. Este padrão ajuda a alcançar a separação das preocupações. Usando este padrão, os pedidos do utilizador são encaminhados para um Controlador, responsável por trabalhar com o Modelo para realizar ações do utilizador e/ou recuperar resultados das consultas. O Controlador escolhe a Vista a mostrar ao utilizador e fornece-lhe quaisquer dados de modelo que necessite.

O diagrama seguinte mostra os três componentes principais e quais referenciam os outros:

Padrão MVC

Esta delimitação de responsabilidades ajuda-te a escalar a aplicação em termos de complexidade porque é mais fácil programar, depurar e testar algo (modelo, vista ou controlador) que tem uma única tarefa. É mais difícil atualizar, testar e depurar código que tenha dependências distribuídas por duas ou mais destas três áreas. Por exemplo, a lógica da interface de utilizador tende a mudar com mais frequência do que a lógica de negócio. Se o código de apresentação e a lógica de negócio forem combinados num único objeto, um objeto que contenha lógica de negócio deve ser modificado sempre que a interface do utilizador é alterada. Isto frequentemente introduz erros e requer o novo teste da lógica de negócio após cada alteração mínima na interface do utilizador.

Observação

Tanto a vista como o controlador dependem do modelo. No entanto, o modelo não depende nem da vista nem do controlador. Este é um dos principais benefícios da separação. Esta separação permite que o modelo seja construído e testado independentemente da apresentação visual.

Responsabilidades de Modelo

O Modelo numa aplicação MVC representa o estado da aplicação e quaisquer lógicas de negócio ou operações que deverão ser realizadas por ela. A lógica de negócio deve estar encapsulada no modelo, juntamente com qualquer lógica de implementação para persistir o estado da aplicação. As vistas fortemente tipadas utilizam tipicamente tipos ViewModel concebidos para conter os dados a serem exibidos nessa vista. O controlador cria e preenche estas instâncias do ViewModel a partir do modelo.

Ver Responsabilidades

As visualizações são responsáveis por apresentar o conteúdo através da interface de utilizador. Eles usam o Razor motor de visualização para incorporar código .NET na marcação HTML. As visões devem conter o mínimo possível de lógica, e qualquer lógica presente deve estar relacionada com a apresentação do conteúdo. Se você sentir a necessidade de realizar muita lógica em ficheiros de visualização para mostrar dados de um modelo complexo, considere usar um Componente de Visualização, Modelo de Visualização ou template de visualização para simplificar a visualização.

Responsabilidades de Controlador

Os controladores são os componentes que gerem a interação do utilizador, trabalham com o modelo e, em última análise, selecionam uma vista para renderizar. Numa aplicação MVC, a visualização apenas apresenta informação; O controlador gere e responde à entrada e interação do utilizador. No padrão MVC, o controlador é o ponto de entrada inicial e é responsável por selecionar que tipos de modelos usar e que vista renderizar (daí o nome - controla como a aplicação responde a um determinado pedido).

Observação

Os controladores não devem ser demasiado complicados devido a um excesso de responsabilidades. Para evitar que a lógica do controlador se torne demasiado complexa, empurre a lógica de negócio para fora do controlador e para o modelo de domínio.

Sugestão

Se perceberes que as ações do teu comando frequentemente realizam os mesmos tipos de ações, move essas ações comuns para filtros.

ASP.NET Core MVC

O framework ASP.NET Core MVC é um framework de apresentação leve, open source e altamente testável, otimizado para uso com ASP.NET Core.

ASP.NET Core MVC oferece uma forma baseada em padrões de construir websites dinâmicos que permite uma separação limpa das preocupações. Dá-lhe controlo total sobre a marcação, suporta desenvolvimento compatível com TDD e utiliza os mais recentes padrões web.

Roteamento

ASP.NET Core MVC é construído sobre o encaminhamento do ASP.NET Core, um poderoso componente de mapeamento de URLs que permite construir aplicações com URLs compreensíveis e pesquisáveis. Isto permite-lhe definir os padrões de nomeação de URLs da sua aplicação que funcionam bem para otimização para motores de busca (SEO) e para geração de links, sem considerar como os ficheiros no seu servidor web estão organizados. Pode definir as suas rotas usando uma sintaxe de modelo de rota conveniente que suporta restrições de valor de rota, valores por defeito e valores opcionais.

O encaminhamento baseado em convenções permite-lhe definir globalmente os formatos de URL que a sua aplicação aceita e como cada um desses formatos corresponde a um método de ação específico num determinado controlador. Quando um pedido recebido é recebido, o motor de encaminhamento analisa a URL e associa-a a um dos formatos de URL definidos, e depois chama o método de ação do controlador associado.

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

O encaminhamento por atributos permite-lhe especificar informações de roteamento decorando os seus controladores e ações com atributos que definem as rotas da sua aplicação. Isto significa que as definições de rota são colocadas ao lado do controlador e da ação com que estão associadas.

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

Vinculação de modelo

ASP.NET Core MVC model binding converte dados dos pedidos do cliente (valores de formulários, dados de rota, parâmetros de string de consulta, cabeçalhos HTTP) em objetos que o controlador pode gerir. Como resultado, a lógica do controlador não tem de fazer o trabalho de decifrar os dados de pedido recebidos; simplesmente tem os dados como parâmetros para os seus métodos de ação.

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

Validação do modelo

ASP.NET Core MVC suporta validação decorando o seu objeto modelo com atributos de validação de anotações de dados. Os atributos de validação são verificados do lado do cliente antes dos valores serem publicados no servidor, bem como no servidor antes da ação do controlador ser chamada.

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 comando:

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);
}

O framework gere a validação dos dados de pedidos tanto no cliente como no servidor. A lógica de validação especificada nos tipos de modelo é adicionada às vistas renderizadas como anotações discretas e é aplicada no navegador com o jQuery Validation.

Injeção de dependência

ASP.NET Core tem suporte integrado para injeção de dependência (DI). No ASP.NET Core MVC, os controladores podem solicitar os serviços necessários através dos seus construtores, permitindo-lhes seguir o Princípio das Dependências Explícitas.

A sua aplicação também pode usar injeção de dependências em ficheiros de vistas, usando a diretiva @inject:

@inject SomeService ServiceName

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

Filtros

Os filtros ajudam os programadores a encapsular questões transversais, como o tratamento de exceções ou a autorização. Os filtros permitem executar lógica personalizada de pré e pós-processamento para métodos de ação, podendo ser configurados para correr em determinados pontos dentro do pipeline de execução para um determinado pedido. Filtros podem ser aplicados a controladores ou ações como atributos (ou podem ser executados globalmente). Vários filtros (como Authorize) estão incluídos no framework. [Authorize] é o atributo utilizado para criar filtros de autorização MVC.

[Authorize]
public class AccountController : Controller

Areas

As áreas fornecem uma forma de dividir uma grande ASP.NET aplicação Web Core MVC em agrupamentos funcionais mais pequenos. Uma área é uma estrutura MVC dentro de uma aplicação. Num projeto MVC, componentes lógicos como Model, Controller e View são mantidos em pastas diferentes, e o MVC usa convenções de nomenclatura para criar a relação entre estes componentes. Para um aplicativo grande, pode ser vantajoso particioná-lo em áreas separadas de alto nível de funcionalidade. Por exemplo, uma aplicação de comércio eletrónico com várias unidades de negócio, como caixa, faturação e pesquisa, etc. Cada uma destas unidades tem as suas próprias vistas de componentes lógicos, controladores e modelos.

Web APIs

Para além de ser uma excelente plataforma para construir sites, ASP.NET Core MVC tem um excelente suporte para construir APIs Web. Pode construir serviços que alcançam uma vasta gama de clientes, incluindo navegadores e dispositivos móveis.

A estrutura inclui suporte para negociação de conteúdos HTTP com suporte incorporado para formatar dados como JSON ou XML. Escreve formatadores personalizados para adicionar suporte aos teus próprios formatos.

Use geração de links para permitir suporte a hipermídia. Ative facilmente o suporte para Partilha de Recursos entre Origens (CORS) para que as suas APIs Web possam ser partilhadas entre várias aplicações Web.

Capacidade de teste

O uso de interfaces e injeção de dependências no framework torna-o bem adequado para testes unitários, e inclui funcionalidades (como um TestHost e um fornecedor InMemory para o Entity Framework) que tornam os testes de integração rápidos e fáceis também. Saiba mais sobre como testar a lógica do controlador.

Razor Motor de visualização

As vistas do ASP.NET Core MVC usam o Razor motor de exibição para renderizar as visualizações. Razor é uma linguagem compacta, expressiva e fluida de marcação de modelos para definir vistas usando código C# embutido. Razor é usado para gerar dinamicamente conteúdo web no servidor. Podes misturar de forma limpa o código do servidor com o conteúdo e o código do lado do cliente.

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

Usando o Razor motor de visualização podes definir layouts, vistas parciais e secções substituíveis.

Opiniões fortemente tipadas

Razor as vistas no MVC podem ser fortemente tipificadas com base no seu modelo. Os controladores podem passar um modelo fortemente tipado para as vistas, permitindo que as suas vistas tenham verificação de tipos e suporte para IntelliSense.

Por exemplo, a seguinte vista renderiza um modelo do tipo IEnumerable<Product>:

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

Auxiliares de Etiquetas

Os Ajudantes de Etiquetas permitem que o código do lado do servidor participe na criação e renderização de elementos HTML em Razor ficheiros. Pode usar ajudantes de etiquetas para definir etiquetas personalizadas (por exemplo, <environment>) ou para modificar o comportamento de etiquetas existentes (por exemplo, <label>). Os Ajudantes de Etiquetas vinculam-se a elementos específicos com base no nome do elemento e nos seus atributos. Oferecem os benefícios da renderização do lado do servidor, preservando ao mesmo tempo a experiência de edição HTML.

Existem muitos Ajudantes de Etiquetas incorporados para tarefas comuns – como criar formulários, links, carregar recursos e muito mais – e ainda mais disponíveis em repositórios públicos do GitHub e como pacotes NuGet. Os Ajudantes de Etiquetas são escritos em C# e direcionam elementos HTML com base no nome do elemento, nome do atributo ou etiqueta pai. Por exemplo, o LinkTagHelper incorporado pode ser usado para criar uma ligação à Login ação do 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 diferentes scripts nas suas visualizações (por exemplo, em formato raw ou minificado) consoante o ambiente de execução, como Desenvolvimento, Intermédio ou Produção.

<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.js"
            asp-fallback-src="~/lib/jquery/dist/jquery.js"
            asp-fallback-test="window.jQuery">
    </script>
</environment>

Os Tag Helpers oferecem uma experiência de desenvolvimento orientada aos padrões HTML e um ambiente rico com IntelliSense para criar HTML e marcação Razor. A maioria dos Ajudantes de Etiquetas incorporados direciona-se a elementos HTML existentes e fornece atributos do lado do servidor para o elemento.

Ver Componentes

Os Componentes de Visualização permitem-lhe empacotar a lógica de renderização e reutilizá-la em toda a aplicação. São semelhantes a vistas parciais, mas com lógica associada.

Versão de compatibilidade

O SetCompatibilityVersion método permite que um aplicativo opte ou desative alterações de comportamento potencialmente perturbadoras introduzidas no ASP.NET Core MVC 2.1 ou posterior.

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

Recursos adicionais

  • Last updated on