ASP.Net MVC é um padrão que é usado para dividir a lógica de implementação do aplicativo em três componentes, ou seja, modelos, visualizações e controladores.

Modelo: é basicamente uma entidade comercial que é usada para representar os dados do aplicativo. Controller: O Request que é enviado pelo usuário sempre se espalha pelo controller e sua responsabilidade é redirecionar para a view específica usando o método View (). Visualização: é a camada de apresentação do ASP.Net MVC.

A seguir estão os recursos adicionados recentemente: Modelos móveis Adicionado modelo ASP.NET Web API para criar serviços baseados em REST. Suporte à tarefa do controlador assíncrono. Empacotamento dos scripts java. Separar as configurações para roteamento ASP.Net MVC, API Web, Pacote etc.

Abaixo estão os processados ​​seguidos na sequência -

  • Inicialização do aplicativo O que é separação de preocupações no ASP.NET ASP.Net MVCation
  • Routing
  • Instancie e execute o controlador
  • Localize e invoque a ação do controlador
  • Instancie e renderize a visualização.

  • Fornece uma separação clara de interesses entre UI (camada de apresentação), modelo (objetos de transferência / objetos de domínio / entidades) e lógica de negócios (controlador).
  • Fácil de testar UNIT.
  • Reutilização aprimorada de modelo e visualizações. Podemos ter várias visualizações que podem apontar para o mesmo modelo e vice-versa.
  • Estruturação aprimorada do código.

É o processo de dividir o programa em vários recursos distintos que se sobrepõem ao mínimo em funcionalidade. O padrão ASP.Net MVC se preocupa em separar o conteúdo da apresentação e o processamento de dados do conteúdo.

Razor é a primeira grande atualização para renderizar HTML no ASP.Net MVC 3. Razor foi projetado especificamente para a sintaxe do mecanismo de visualização. O foco principal disso seria simplificar e modelagem focada em código para geração de HTML. Abaixo está o exemplo de uso do Razor:

@model ASP.Net MVCMusicStore.Models.Customer
@{ViewBag.Title = "Get Customers";}
< div class="cust"> <h3><em>@Model.CustomerName</<em> </<h3><div>

Este é um termo geral que transmite uma filosofia geral, semelhante ao termo REST (Representational State Transfer). O JavaScript discreto não mistura o código JavaScript na marcação da sua página. Ex: Em vez de usar eventos como onclick e onsubmit, o JavaScript discreto se anexa aos elementos por seu ID ou classe com base nos atributos de dados HTML5.

View Model é uma classe simples com propriedades, que é usada para vinculá-la a uma visão fortemente tipada. O modelo de visualização pode ter as regras de validação definidas para suas propriedades usando anotações de dados.

O roteamento é um mecanismo de correspondência de padrões de solicitações de entrada para os padrões de URL registrados na tabela de rotas. Classe: "UrlRoutingModule" é usado para o mesmo processo.

Ações são os métodos da classe Controller responsáveis ​​por retornar a visão ou os dados json. A ação terá principalmente o tipo de retorno: "ActionResult" e será invocada a partir do método: "InvokeAction ()" chamado pelo controlador.

ASP.NET Web API oferece suporte a esse tipo de roteamento. Isso é apresentado no ASP.Net MVC5. Nesse tipo de roteiro, atributos estão sendo usados ​​para definir as rotas. Esse tipo de roteamento oferece mais controle sobre o Roteamento URI clássico. O roteamento de atributo pode ser definido no nível do controlador ou no nível da ação como:

[Route("{action = TestCategoryList}")] - Controller Level
[Route("customers/{TestCategoryId:int:min(10)}")] - Action Level

Basta adicionar @ Model.CustomerName o método: "MapASP.Net MVCAttributeRoutes ()" para habilitar o roteamento de atributo conforme mostrado abaixo: 

public static void RegisterRoutes(RouteCollection routes)
    {
        routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
        //enabling attribute routing
        routes.MapASP.Net MVCAttributeRoutes();
        //convention-based routing
        routes.MapRoute
        (
            name: "Default",
            url: "{controller}/{action}/{id}",
            defaults: new { controller = "Customer", action = "GetCustomerList", id = UrlParameter.Optional }
        );
    }

O suporte de vinculação de JavaScript Object Notation (JSON) começou a partir do ASP.Net MVC3 por meio do novo JsonValueProviderFactory, que permite que os métodos de ação aceitem e vinculem dados de modelo no formato JSON. Isso é útil em cenários Ajax como modelos de cliente e vinculação de dados que precisam enviar dados de volta ao servidor.

Dependency Resolver novamente foi introduzido no ASP.Net MVC3 e é bastante simplificado o uso de injeção de dependência em seus aplicativos. Isso se tornou mais fácil e útil para desacoplar os componentes do aplicativo e torná-los mais fáceis de testar e mais configuráveis.

"BundleConfig.cs" em ASP.Net MVC4 é usado para registrar os bundles pelo sistema de empacotamento e minificação. Muitos pacotes são adicionados por padrão, incluindo bibliotecas jQuery como - jquery.validate, Modernizr e referências CSS padrão.

Método: "RegisterRoutes ()" é usado para registrar as rotas que serão adicionadas no método "Application_Start ()" do arquivo global.asax, que é disparado quando a aplicação é carregada ou iniciada.

Abaixo estão os namespaces importantes usados ​​no ASP.Net MVC -

  • System.Web.ASP.Net MVC
  • System.Web.ASP.Net MVC.Ajax
  • System.Web.ASP.Net MVC.Html
  • System.Web.ASP.Net MVC.Async

Viewdata contém os pares de chave e valor como dicionário e é derivado da classe: "ViewDataDictionary". No método de ação, estamos definindo o valor para viewdata e, em vista, o valor será obtido por typecasting.

ViewBag é um wrapper em torno de ViewData, que permite criar propriedades dinâmicas. A vantagem do viewbag sobre os viewdata será: No ViewBag, não há necessidade de fazer o typecast dos objetos como no ViewData. ViewBag aproveitará a vantagem da palavra-chave dinâmica introduzida na versão 4.0. Mas antes de usar o ViewBag, devemos ter em mente que o ViewBag é mais lento que o ViewData.

TempData é novamente um par de chave e valor como ViewData. Isso é derivado da classe "TempDataDictionary". TempData é utilizado quando os dados devem ser utilizados em duas requisições consecutivas, podendo ser entre as ações ou entre os controladores. Isso requer uma classificação em vista.

Os HTML Helpers são como controles em formulários tradicionais da web. Mas os ajudantes HTML são mais leves em comparação com os controles da web, pois não contêm viewstate e eventos. HTML Helpers retorna a string HTML que pode ser renderizada diretamente na página HTML. Helpers HTML personalizados também podem ser criados substituindo a classe "HtmlHelper".

Auxiliares de AJAX são usados ​​para criar elementos habilitados para AJAX, como formulários habilitados para Ajax e links que realizam a solicitação de forma assíncrona e são métodos de extensão da classe AJAXHelper que existe no namespace - System.Web.ASP.Net MVC.

Abaixo estão as opções nos auxiliares AJAX:

  • Url: este é o URL do pedido.
  • Confirmar: Isto é usado para especificar a mensagem que deve ser exibida na caixa de confirmação.
  • OnBegin: nome do método Javascript a ser fornecido aqui e será chamado antes da solicitação AJAX.
  • OnComplete: nome do método Javascript a ser fornecido aqui e será chamado no final da solicitação AJAX.
  • OnSuccess - nome do método Javascript a ser fornecido aqui e será chamado quando a solicitação AJAX for bem-sucedida.
  • OnFailure - o nome do método Javascript a ser fornecido aqui e será chamado quando a solicitação AJAX falhar.
  • UpdateTargetId: elemento de destino que é preenchido a partir do HTML de retorno de ação.

As páginas de layout são semelhantes às páginas mestras em formulários da web tradicionais. Isso é usado para definir a aparência comum em várias páginas. Em cada página filha, podemos encontrar: / p>

@{
Layout = "~/Views/Shared/TestLayout1.cshtml";
}
Isso indica que a página filha usa a página TestLayout como página mestra.

A seção é a parte do HTML que deve ser renderizada na página de layout. Na página Layout, usaremos a sintaxe abaixo para renderizar o HTML:

@RenderSection("TestSection")
E nas páginas filhas, estamos definindo essas seções conforme mostrado abaixo: 
@section TestSection{
<h1>Test Content<h1>
}
Se alguma página filha não tiver essa seção definida, um erro será gerado para evitar que possamos renderizar o HTML desta forma: 
@RenderSection("TestSection", required: false)

RenderBody é como ContentPlaceHolder em formulários da web. Isso existirá na página de layout e renderizará as páginas / visualizações filhas. A página de layout terá apenas um método RenderBody (). RenderPage também existe na página Layout e vários RenderPage () podem estar lá na página Layout.

Esta página é usada para garantir que a página de layout comum seja usada para visualizações múltiplas. O código escrito neste arquivo será executado primeiro quando o aplicativo estiver sendo carregado.

Abaixo estão os métodos usados ​​para renderizar as visualizações da ação -

  • Ver (): Para retornar a visão da ação.
  • PartialView (): Para retornar a visão parcial da ação.
  • RedirectToAction (): para redirecionar para uma ação diferente, que pode estar no mesmo controlador ou em um controlador diferente.
  • Redirect (): Semelhante a "Response.Redirect ()" em formulários da web, usado para redirecionar para o URL especificado.
  • RedirectToRoute (): redireciona para a ação a partir do URL especificado, mas o URL na tabela de rotas foi correspondido.

ActionResult é usado para representar o resultado do método de ação. Abaixo estão os subtipos de ActionResult:

  • ViewResult
  • PartialViewResult
  • RedirectToRouteResult
  • RedirectResult
  • JavascriptResult
  • JSONResult
  • FileResult
  • HTTPStatusCodeResult

No ASP.Net MVC todos os métodos públicos foram tratados como Ações. Portanto, se você está criando um método e não deseja usá-lo como um método de ação, o método deve ser decorado com o atributo "NonAction" conforme mostrado abaixo:

[NonAction]
public void TestMethod()
{
// Method logic
}

O atributo "ActionName" pode ser usado para alterar o nome da ação. Abaixo está o snippet de código de amostra para demonstrar mais:

[ActionName("TestActionNew")]
public ActionResult TestAction()
    {
        return View();
    }
Portanto, no trecho de código acima, "TestAction" é o nome da ação original e no atributo "ActionName", o nome - "TestActionNew" é fornecido. Portanto, o chamador desse método de ação usará o nome "TestActionNew" para chamar essa ação.

Ao contrário das expressões de código que são avaliadas e enviadas para a resposta, são os blocos de código que são executados. Isso é útil para declarar variáveis ​​que podem ser solicitadas a serem usadas posteriormente.

@{
 int x = 123;
 string y = "aa";
 }

A propriedade HelperPage.IsAjax obtém um valor que indica se Ajax está sendo usado durante a solicitação da página da web.

Crie um método JavaScript: 

function DrpIndexChanged() { }
Invoque o método: 
< %:Html.DropDownListFor(x => x.SelectedProduct, new SelectList(Model.Customers, "Value", "Text"), "Please Select a Customer", new { id = "ddlCustomers", onchange=" DrpIndexChanged ()" })%>

Anotações de dados são atributos que podem ser encontrados no namespace "System.ComponentModel.DataAnnotations". Esses atributos serão usados ​​para validação do lado do servidor e a validação do lado do cliente também é suportada. Quatro atributos - Obrigatório, Comprimento da String, Expressão Regular e Intervalo são usados ​​para cobrir os cenários de validação comuns.

Este método é usado para renderizar a visualização parcial especificada como uma string HTML. Este método não depende de nenhum método de ação. Podemos usar isso como abaixo: @ Html.Partial ("TestPartialView")

Resultado do método: "RenderPartial" é escrito diretamente na resposta HTML. Este método não retorna nada (void). Este método também não depende de métodos de ação. O método RenderPartial () chama "Write ()" internamente e temos que nos certificar de que o método "RenderPartial" está entre colchetes. Abaixo está o snippet de código de amostra: @ {Html.RenderPartial ("TestPartialView"); }

"RouteConfig.cs" contém a configuração de roteamento para ASP.Net MVC. RouteConfig será inicializado no evento Application_Start registrado em Global.asax.

Scaffolding no ASP.NET ASP.Net MVC é usado para gerar os controladores, o modelo e as visualizações para criar, ler, atualizar e excluir a funcionalidade (CRUD) em um aplicativo. O scaffolding saberá as convenções de nomenclatura usadas para modelos, controladores e visualizações.

Abaixo estão os tipos de andaimes:

  • Empty
  • Create
  • Delete
  • Details
  • Edit
  • List

Sim, podemos compartilhar uma visão entre vários controladores. Podemos colocar a visão na pasta "Compartilhada". Quando criamos um novo projeto ASP.Net MVC, podemos ver que a página Layout será adicionada à pasta compartilhada, porque ela é usada por várias páginas filhas.

  • Nome - Este é o nome da rota.
  • Padrão de URL: os marcadores de posição serão fornecidos para corresponder ao padrão de URL da solicitação.
  • Padrões: Ao carregar a aplicação cujo controlador, ação a ser carregada junto com o parâmetro.

Usando esta rota padrão - {resource} .axd / {* pathInfo}, podemos evitar que as solicitações dos arquivos de recursos da web como - WebResource.axd ou ScriptResource.axd passem para um controlador.

Sim, podemos adicionar restrições à rota das seguintes maneiras:

  • Usando expressões regulares
  • Usando o objeto que implementa a interface - IRouteConstraint.

Abaixo estão os dois tipos de extensões que o razor view pode ter:

  • .cshtml: Na linguagem de programação C #, esta extensão será usada.
  • .vbhtml - Na linguagem de programação VB esta extensão será usada.

PartialView é semelhante a UserControls em formulários da web tradicionais. Para fins de reutilização, visualizações parciais são usadas. Uma vez que foi compartilhado com várias visualizações, elas são mantidas na pasta compartilhada. Visualizações parciais podem ser renderizadas das seguintes maneiras:

  • Html.Partial()
  • Html.RenderPartial()

Abaixo está o snippet de código de amostra para adicionar css às ​​visualizações do Razor: <link rel = "StyleSheet" href = "/ @ Href (~ Content / Site.css") "type =" text / css "/>

Não. Não podemos adicionar os casos de teste na edição Visual Studio Express, ele pode ser adicionado apenas nas versões Professional e Ultimate do Visual Studio.

Glimpse é uma ferramenta de código aberto para depuração de rotas em ASP.Net MVC. É o depurador do lado do cliente. O Glimpse deve ser ativado visitando o link de url local - http: // localhost: portname // glimpse.axd Esta é uma ferramenta popular e útil para depuração que rastreia os detalhes de velocidade, detalhes de url, etc.

Os Filtros de Ação nos permitem executar o código antes ou depois que a ação foi executada. Isso pode ser feito decorando os métodos de ação dos controles com atributos ASP.Net MVC.

Abaixo estão alguns filtros de ação usados:

  • Authentication
  • Authorization
  • HandleError
  • OutputCache

Isso pode ser feito da seguinte forma: Use a classe: "HttpRequestBase" e use o método: "HttpMethod" para determinar o tipo de solicitação de ação.

Sempre que a validação falhar, ela será rastreada no ModelState. Usando a propriedade: IsValid, ela pode ser determinada. No código do servidor, verifique assim:

if(ModelState.IsValid){
     // No Validation Errors
}

No Web.Config existem tags chamadas: "ClientValidationEnabled" e "UnobtrusiveJavaScriptEnabled". Podemos definir a validação do lado do cliente apenas definindo essas duas tags como "verdadeiras", então essa configuração será aplicada no nível do aplicativo.

< add key="ClientValidationEnabled" value="true" />
< add key="UnobtrusiveJavaScriptEnabled" value="true" />

Para Model Binding, usaremos uma classe chamada: "ModelBinders", que dá acesso a todos os binders de modelo em um aplicativo. Podemos criar um modelo de binders personalizado, herdando "IModelBinder".

O tratamento de exceções é simplificado no ASP.Net MVC e pode ser feito apenas sobrescrevendo "OnException" e definir a propriedade result do objeto filtercontext (como mostrado abaixo) para o detalhe da visão, que deve ser retornado em caso de exceção. 

protected overrides void OnException(ExceptionContext filterContext)
    {
    }

Se Tempdata for atribuído na solicitação atual, ele estará disponível para a solicitação atual e a solicitação subsequente e depende se os dados em TempData são lidos ou não. Se os dados em Tempdata forem lidos, eles não estarão disponíveis para as solicitações subsequentes.

Conforme explicado acima, caso os dados em Tempdata tenham sido lidos na solicitação atual, apenas o método "Manter" foi usado para disponibilizá-los para a solicitação subsequente. 

@TempData["TestData"];
TempData.Keep("TestData");

Semelhante ao método Keep, temos mais um método chamado "Peek" que é usado para o mesmo propósito. Este método é usado para ler dados em Tempdata e mantém os dados para solicitação subsequente.

string A4str = TempData.Peek("TT").ToString();

A área é usada para armazenar os detalhes dos módulos do nosso projeto. Isso é realmente útil para grandes aplicativos, onde controladores, visualizações e modelos estão todos nas pastas controlador principal, visualização e modelo e é muito difícil de gerenciar.

Depois de criar uma área, certifique-se de que ela será registrada no evento "Application_Start" no Global.asax. Abaixo está o snippet de código onde o registro da área é feito:

protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
}

Para criar widgets reutilizáveis, ações filho são usadas e isso será embutido nas visualizações pai. No ASP.Net MVC, as visualizações parciais são usadas para ter capacidade de reutilização no aplicativo. A ação infantil retorna principalmente as visualizações parciais.

O atributo "ChildActionOnly" é decorado com métodos de ação para indicar que o método de ação é uma ação filho. Abaixo está o snippet de código usado para denotar a ação secundária:

[ChildActionOnly]
public ActionResult MenuBar()
{
//Logic here
return PartialView();
}

é um padrão de design e é usado para desenvolver código vagamente acoplado. Isso é muito usado em projetos de software. Isso reduzirá a codificação em caso de alterações no design do projeto, portanto, é amplamente utilizado.

Abaixo estão as vantagens do DI:

  • Reduz o acoplamento de classe
  • Aumenta a reutilização de código
  • Melhora a capacidade de manutenção do código
  • Melhora o teste de aplicativos

TDD é uma metodologia que diz, escreva seus testes primeiro, antes de escrever seu código. No TDD, os testes orientam os ciclos de design e desenvolvimento de seu aplicativo. Você não faz o check-in de seu código no controle de origem até que todos os seus testes de unidade sejam aprovados.

Abaixo estão as ferramentas usadas para testes de unidade:

  • NUnit
  • xUnit.NET
  • Ninject 2
  • Moq

REST é um estilo de arquitetura que usa métodos de protocolo HTTP como GET, POST, PUT e DELETE para acessar os dados. ASP.Net MVC funciona neste estilo. No ASP.Net MVC 4 existe um suporte para API Web que usa para construir o serviço usando verbos HTTP.

Podemos usar anotações de dados para validação no ASP.Net MVC. Se quisermos usar a validação durante o tempo de execução usando Jquery, podemos usar plug-ins Jquery para validação. Por exemplo: se a validação deve ser feita na caixa de texto do nome do cliente, podemos fazer o seguinte:

$('#CustomerName').rules("add", {
required: true,
minlength: 2,
messages: {
required: "Please enter name",
minlength: "Minimum length is 2"
}
});

Abaixo está o cenário e a solução para resolver o problema de vários botões de envio. Cenário:

@using (Html.BeginForm("MyTestAction","MyTestController")
{
    <input type="submit" value="MySave" />
    <input type="submit" value="MyEdit" />
}
Solução: 
Public ActionResult MyTestAction(string submit) //submit will have value either "MySave" or "MyEdit"
{
    // Write code here
}

  • Modelos de exibição: são centrados no modelo. O que significa que depende das propriedades do modelo de vista usado. Ele usa uma convenção que só será exibida como divs ou rótulos.
  • Editar modelos: também são centrados no modelo, mas terão controles editáveis ​​como caixas de texto.
  • Vista parcial: são centradas na vista. Eles serão diferentes dos modelos pela maneira como renderizam as propriedades (Id's). Ex: CategoryViewModel tem propriedade de classe de produto, então será processado como Model.Product.ProductName, mas no caso de modelos se nós CategoryViewModel tiver List então @ Html.DisplayFor (m => m.Products) funciona e renderiza o modelo para cada item desta lista.

Não. Não podemos definir um comprimento ilimitado para a propriedade maxJsonLength. O valor padrão é - 102400 e o valor máximo que podemos definir seria: 2147483644.

Sim. Podemos usar o código de navalha em javascript em cshtml usando o elemento <text>.

< script type="text/javascript">
@foreach (var item in Model) {
< text >
//javascript goes here which uses the server values
< text >
}
< script>

Abaixo está o snippet de código para retornar a string do método de ação: 

public ActionResult TestAction() {
return Content("Hello Test !!");
}

Abaixo está o snippet de código para retornar a string do método de ação: 

public ActionResult TestAction() {
return JSON(new { prop1 = "Test1", prop2 = "Test2" });
}