ASP.Net MVC è un modello utilizzato per suddividere la logica di implementazione dell'applicazione in tre componenti, ovvero modelli, visualizzazioni e controller.

Modello: è fondamentalmente un'entità aziendale che viene utilizzata per rappresentare i dati dell'applicazione. Controller: la richiesta inviata dall'utente si diffonde sempre attraverso il controller ed è responsabilità del reindirizzamento alla vista specifica utilizzando il metodo View (). Visualizza: è il livello di presentazione di ASP.Net MVC.

Di seguito sono state aggiunte nuove funzionalità: Modelli mobili Aggiunto modello API Web ASP.NET per la creazione di servizi basati su REST. Supporto delle attività del controller asincrono. Raggruppamento degli script Java. Segregazione delle configurazioni per routing ASP.Net MVC, API Web, bundle ecc.

Di seguito sono riportati gli elaborati seguiti nella sequenza:

• Inizializzazione dell'appChe cos'è la separazione delle preoccupazioni in ASP.NET ASP.Net MVCation
• Routing
• Istanziare ed eseguire il controller
• Individua e richiama l'azione del controller
• Istanziare ed eseguire il rendering della vista.

• Fornisce una netta separazione delle preoccupazioni tra interfaccia utente (livello presentazione), modello (oggetti di trasferimento / oggetti di dominio / entità) e logica di business (controller).
• Facile da UNIT test.
• Riutilizzabilità migliorata del modello e delle viste. Possiamo avere più viste che possono puntare allo stesso modello e viceversa.
• Migliore strutturazione del codice.

È il processo di suddivisione del programma in varie caratteristiche distinte che si sovrappongono il meno possibile in termini di funzionalità. Il modello ASP.Net MVC riguarda la separazione del contenuto dalla presentazione e l'elaborazione dei dati dal contenuto.

Razor è il primo aggiornamento importante per il rendering HTML in ASP.Net MVC 3. Razor è stato progettato specificamente per la sintassi del motore di visualizzazione. L'obiettivo principale di questo sarebbe semplificare la creazione di modelli incentrati sul codice per la generazione di HTML. Di seguito è riportato un esempio di utilizzo di Razor:

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

Questo è un termine generale che trasmette una filosofia generale, simile al termine REST (Representational State Transfer). JavaScript non invadente non mescola il codice JavaScript nel markup della tua pagina. Ad esempio: invece di utilizzare eventi come onclick e onsubmit, JavaScript discreto si collega agli elementi tramite il loro ID o classe in base agli attributi dei dati HTML5.

View Model è una semplice classe con proprietà, che viene utilizzata per associarla a una vista fortemente tipizzata. Il modello di visualizzazione può avere le regole di convalida definite per le sue proprietà utilizzando le annotazioni dei dati.

Il routing è un meccanismo di corrispondenza dei pattern delle richieste in arrivo ai pattern URL registrati nella tabella di route. Classe: "UrlRoutingModule" viene utilizzato per lo stesso processo.

Le azioni sono i metodi nella classe Controller che è responsabile della restituzione della vista o dei dati JSON. L'azione avrà principalmente il tipo di ritorno: "ActionResult" e sarà invocata dal metodo: "InvokeAction ()" chiamato dal controller.

L'API Web ASP.NET supporta questo tipo di routing. Questo è introdotto in ASP.Net MVC5. In questo tipo di instradamento, gli attributi vengono utilizzati per definire le rotte. Questo tipo di instradamento offre un maggiore controllo sull'instradamento URI classico. Il routing degli attributi può essere definito a livello di controller o di azione come:

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

Basta aggiungere @ Model.CustomerName il metodo: "MapASP.Net MVCAttributeRoutes ()" per abilitare il routing degli attributi come mostrato di seguito:

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

Il supporto dell'associazione JavaScript Object Notation (JSON) è stato avviato da ASP.Net MVC3 in poi tramite il nuovo JsonValueProviderFactory, che consente ai metodi di azione di accettare e associare i dati in formato JSON. Ciò è utile negli scenari Ajax come i modelli client e l'associazione dati che devono inviare i dati al server.

Il Resolver delle dipendenze è stato nuovamente introdotto in ASP.Net MVC3 ed è stato notevolmente semplificato l'uso dell'inserimento delle dipendenze nelle applicazioni. Questo risulta essere più facile e utile per disaccoppiare i componenti dell'applicazione e renderli più facili da testare e più configurabili.

"BundleConfig.cs" in ASP.Net MVC4 viene utilizzato per registrare i bundle dal sistema di bundling e minification. Molti bundle vengono aggiunti per impostazione predefinita, comprese le librerie jQuery come - jquery.validate, Modernizr e riferimenti CSS predefiniti.

Metodo: "RegisterRoutes ()" viene utilizzato per registrare le rotte che verranno aggiunte nel metodo "Application_Start ()" del file global.asax, che viene attivato quando l'applicazione viene caricata o avviata.

Di seguito sono riportati gli spazi dei nomi importanti utilizzati in 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 contiene la chiave, le coppie di valori come dizionario e questo è derivato dalla classe: "ViewDataDictionary". Nel metodo di azione stiamo impostando il valore per viewdata e in vista il valore verrà recuperato digitando.

ViewBag è un wrapper attorno a ViewData, che consente di creare proprietà dinamiche. Il vantaggio di viewbag rispetto a viewdata sarà: In ViewBag non è necessario typecast gli oggetti come in ViewData. ViewBag sfrutterà la parola chiave dinamica introdotta nella versione 4.0. Ma prima di utilizzare ViewBag dobbiamo tenere presente che ViewBag è più lento di ViewData.

TempData è di nuovo una coppia chiave e valore come ViewData. Deriva dalla classe "TempDataDictionary". TempData viene utilizzato quando i dati devono essere utilizzati in due richieste consecutive, questo potrebbe essere tra le azioni o tra i controller. Ciò richiede il typecasting in vista.

Gli helper HTML sono come i controlli nei moduli web tradizionali. Ma gli helper HTML sono più leggeri rispetto ai controlli web in quanto non contengono viewstate ed eventi. Gli helper HTML restituiscono la stringa HTML che può essere riprodotta direttamente nella pagina HTML. Gli helper HTML personalizzati possono essere creati anche sovrascrivendo la classe "HtmlHelper".

Gli helper AJAX vengono utilizzati per creare elementi abilitati AJAX come moduli e collegamenti abilitati Ajax che eseguono la richiesta in modo asincrono e questi sono metodi di estensione della classe AJAXHelper che esiste nello spazio dei nomi - System.Web.ASP.Net MVC.

Di seguito sono riportate le opzioni negli helper AJAX:

• Url: questo è l'URL della richiesta.
• Conferma: consente di specificare il messaggio che deve essere visualizzato nella casella di conferma.
• OnBegin: nome del metodo Javascript da fornire qui e questo verrà chiamato prima della richiesta AJAX.
• OnComplete: nome del metodo Javascript da fornire qui e questo verrà chiamato alla fine della richiesta AJAX.
• OnSuccess - Il nome del metodo Javascript da fornire qui e questo verrà chiamato quando la richiesta AJAX ha esito positivo.
• OnFailure - Il nome del metodo Javascript da fornire qui e questo verrà chiamato quando la richiesta AJAX non è riuscita.
• UpdateTargetId: elemento di destinazione che viene popolato dall'azione che restituisce HTML.

Le pagine di layout sono simili alle pagine master nei moduli Web tradizionali. Viene utilizzato per impostare l'aspetto comune su più pagine. In ogni pagina figlio possiamo trovare: / p>

@{
Layout = "~/Views/Shared/TestLayout1.cshtml";
}

Ciò indica che la pagina figlio utilizza la pagina TestLayout come pagina master.

Le sezioni sono la parte dell'HTML che deve essere visualizzata nella pagina di layout. Nella pagina Layout useremo la sintassi seguente per il rendering dell'HTML:

@RenderSection("TestSection")

E nelle pagine figlie stiamo definendo queste sezioni come mostrato di seguito:

@section TestSection{
<h1>Test Content<h1>
}

Se una qualsiasi pagina figlia non ha questa sezione definita, verrà generato un errore in modo da evitare di poter visualizzare l'HTML in questo modo:

@RenderSection("TestSection", required: false)

RenderBody è come ContentPlaceHolder nei moduli web. Questo esisterà nella pagina di layout e renderà le pagine / viste figlie. La pagina di layout avrà un solo metodo RenderBody (). RenderPage esiste anche nella pagina Layout e più RenderPage () possono essere presenti nella pagina Layout.

Questa pagina viene utilizzata per assicurarsi che la pagina di layout comune venga utilizzata per più visualizzazioni. Il codice scritto in questo file verrà eseguito per primo quando l'applicazione viene caricata.

Di seguito sono riportati i metodi utilizzati per eseguire il rendering delle visualizzazioni dall'azione:

• Visualizza (): per tornare alla visualizzazione dall'azione.
• PartialView (): per restituire la vista parziale dall'azione.
• RedirectToAction (): per reindirizzare a un'azione diversa che può essere nello stesso controller o in un controller diverso.
• Redirect (): simile a "Response.Redirect ()" nei moduli web, utilizzato per reindirizzare all'URL specificato.
• RedirectToRoute (): reindirizza all'azione dall'URL specificato ma l'URL nella tabella di route è stato trovato.

ActionResult viene utilizzato per rappresentare il risultato del metodo di azione. Di seguito sono riportati i sottotipi di ActionResult:

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

In ASP.Net MVC tutti i metodi pubblici sono stati trattati come azioni. Quindi, se stai creando un metodo e se non vuoi usarlo come metodo di azione, il metodo deve essere decorato con l'attributo "NonAction" come mostrato di seguito:

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

L'attributo "ActionName" può essere utilizzato per modificare il nome dell'azione. Di seguito è riportato lo snippet di codice di esempio per dimostrare di più:

[ActionName("TestActionNew")]
public ActionResult TestAction()
    {
        return View();
    }

Quindi nello snippet di codice precedente "TestAction" è il nome dell'azione originale e nell'attributo "ActionName", name - "TestActionNew" è dato. Quindi il chiamante di questo metodo di azione utilizzerà il nome "TestActionNew" per chiamare questa azione.

A differenza delle espressioni di codice che vengono valutate e inviate alla risposta, sono i blocchi di codice che vengono eseguiti. Questo è utile per dichiarare variabili che potremmo dover utilizzare in seguito.

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

La proprietà HelperPage.IsAjax ottiene un valore che indica se Ajax viene utilizzato durante la richiesta della pagina Web.

Crea un metodo JavaScript:

function DrpIndexChanged() { }

Invoca il metodo:

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

Le annotazioni dei dati sono attributi che possono essere trovati nello spazio dei nomi "System.ComponentModel.DataAnnotations". Questi attributi verranno utilizzati per la convalida lato server ed è supportata anche la convalida lato client. Quattro attributi: Required, String Length, Regular Expression e Range vengono utilizzati per coprire gli scenari di convalida comuni.

Questo metodo viene utilizzato per eseguire il rendering della vista parziale specificata come stringa HTML. Questo metodo non dipende da alcun metodo di azione. Possiamo usarlo come di seguito: @ Html.Partial ("TestPartialView")

Risultato del metodo: "RenderPartial" viene scritto direttamente nella risposta HTML. Questo metodo non restituisce nulla (void). Anche questo metodo non dipende dai metodi di azione. Il metodo RenderPartial () chiama "Write ()" internamente e dobbiamo assicurarci che il metodo "RenderPartial" sia racchiuso tra parentesi. Di seguito è riportato uno snippet di codice di esempio: @ {Html.RenderPartial ("TestPartialView"); }

"RouteConfig.cs" contiene la configurazione del routing per ASP.Net MVC. RouteConfig verrà inizializzato sull'evento Application_Start registrato in Global.asax.

Scaffolding in ASP.NET ASP.Net MVC viene utilizzato per generare i controller, il modello e le viste per creare, leggere, aggiornare ed eliminare la funzionalità (CRUD) in un'applicazione. L'impalcatura conoscerà le convenzioni di denominazione utilizzate per modelli, controller e viste.

Di seguito le tipologie di ponteggi:

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

Sì, possiamo condividere una vista su più controller. Possiamo mettere la vista nella cartella "Condivisa". Quando creiamo un nuovo progetto ASP.Net MVC, possiamo vedere che la pagina Layout verrà aggiunta nella cartella condivisa, perché è utilizzata da più pagine figlie.

• Nome: questo è il nome del percorso.
• Pattern URL: verranno assegnati segnaposto per corrispondere al pattern URL della richiesta.
• Impostazioni predefinite: quando si carica l'applicazione quale controller, l'azione da caricare insieme al parametro.

Usando questo percorso predefinito - {resource} .axd / {* pathInfo}, possiamo impedire che le richieste per i file delle risorse web come - WebResource.axd o ScriptResource.axd passino a un controller.

Sì, possiamo aggiungere vincoli al percorso nei seguenti modi:

• Utilizzo di espressioni regolari
• Utilizzo di un oggetto che implementa l'interfaccia - IRouteConstraint.

Di seguito sono riportati i due tipi di estensioni che la visualizzazione del rasoio può avere:

• .cshtml: nel linguaggio di programmazione C # verrà utilizzata questa estensione.
• .vbhtml - Nel linguaggio di programmazione VB verrà utilizzata questa estensione.

PartialView è simile a UserControls nei moduli Web tradizionali. Ai fini della riutilizzabilità vengono utilizzate viste parziali. Poiché è stato condiviso con più visualizzazioni, queste vengono conservate nella cartella condivisa. Le viste parziali possono essere visualizzate nei seguenti modi:

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

Di seguito è riportato lo snippet di codice di esempio per aggiungere css alle visualizzazioni razor: <link rel = "StyleSheet" href = "/ @ Href (~ Content / Site.css") "type =" text / css "/>

No. Non è possibile aggiungere i casi di test nell'edizione di Visual Studio Express, che possono essere aggiunti solo nelle versioni Professional e Ultimate di Visual Studio.

Glimpse è uno strumento open source per il debug delle rotte in ASP.Net MVC. È il debugger lato client. Glimpse deve essere attivato visitando il link dell'URL locale - http: // localhost: portname // glimpse.axd Questo è uno strumento popolare e utile per il debug che tiene traccia dei dettagli di velocità, dei dettagli dell'URL ecc.

I filtri di azione ci consentono di eseguire il codice prima o dopo che l'azione è stata eseguita. Questa operazione può essere eseguita decorando i metodi di azione dei controlli con attributi ASP.Net MVC.

Di seguito sono riportati alcuni filtri di azione utilizzati:

• Authentication
• Authorization
• HandleError
• OutputCache

Questo può essere fatto nel modo seguente: Usa la classe: "HttpRequestBase" e usa il metodo: "HttpMethod" per determinare il tipo di richiesta di azione.

Ogni volta che la convalida fallisce, verrà tracciata in ModelState. Utilizzando la proprietà: IsValid può essere determinato. In Codice server, controlla in questo modo:

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

In Web.Config ci sono tag chiamati: "ClientValidationEnabled" e "UnobtrusiveJavaScriptEnabled". Possiamo impostare la convalida lato client semplicemente impostando questi due tag su "true", quindi questa impostazione verrà applicata a livello di applicazione.

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

Per Model Binding useremo la classe chiamata: "ModelBinders", che dà accesso a tutti i leganti di modelli in un'applicazione. Possiamo creare leganti di modelli personalizzati ereditando "IModelBinder".

La gestione delle eccezioni è resa semplice in ASP.Net MVC e può essere eseguita semplicemente sovrascrivendo "OnException" e impostando la proprietà del risultato dell'oggetto filtercontext (come mostrato di seguito) sui dettagli della vista, che deve essere restituito in caso di eccezione.

protected overrides void OnException(ExceptionContext filterContext)
    {
    }

Se Tempdata è assegnato nella richiesta corrente, sarà disponibile per la richiesta corrente e la richiesta successiva e dipende se i dati in TempData vengono letti o meno. Se i dati in Tempdata vengono letti, non saranno disponibili per le richieste successive.

Come spiegato sopra, nel caso in cui i dati in Tempdata siano stati letti nella richiesta corrente, solo il metodo "Keep" è stato utilizzato per renderli disponibili per la richiesta successiva.

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

Simile al metodo Keep, abbiamo un altro metodo chiamato "Peek" che viene utilizzato per lo stesso scopo. Questo metodo è utilizzato per leggere i dati in Tempdata e mantiene i dati per la richiesta successiva.

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

L'area è utilizzata per memorizzare i dettagli dei moduli del nostro progetto. Questo è davvero utile per le grandi applicazioni, dove controller, viste e modelli sono tutti nel controller principale, nelle cartelle di visualizzazione e modello ed è molto difficile da gestire.

Quando abbiamo creato un'area assicurati che venga registrata nell'evento "Application_Start" in Global.asax. Di seguito è riportato lo snippet di codice in cui viene eseguita la registrazione dell'area:

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

Per creare widget riutilizzabili vengono utilizzate azioni figlio che verranno incorporate nelle viste padre. In ASP.Net MVC le viste parziali vengono utilizzate per essere riutilizzabili nell'applicazione. L'azione figlio restituisce principalmente le visualizzazioni parziali.

L'attributo "ChildActionOnly" è decorato sui metodi di azione per indicare che il metodo di azione è un'azione figlio. Di seguito è riportato lo snippet di codice utilizzato per indicare l'azione figlio:

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

è un modello di progettazione e viene utilizzato per lo sviluppo di un codice a coppie vagamente. Questo è molto utilizzato nei progetti software. Ciò ridurrà la codifica in caso di modifiche al design del progetto, quindi viene ampiamente utilizzata.

Di seguito sono riportati i vantaggi di DI:

• Riduce l'accoppiamento di classe
• Aumenta il riutilizzo del codice
• Migliora la manutenibilità del codice
• Migliora il test delle applicazioni

TDD è una metodologia che dice: scrivi i tuoi test prima di scrivere il tuo codice. In TDD, i test guidano la progettazione dell'applicazione ei cicli di sviluppo. Non esegui l'archiviazione del codice nel controllo del codice sorgente finché tutti i tuoi unit test non vengono superati.

Di seguito sono riportati gli strumenti utilizzati per i test unitari:

• NUnit
• xUnit.NET
• Ninject 2
• Moq

REST è uno stile architettonico che utilizza metodi del protocollo HTTP come GET, POST, PUT e DELETE per accedere ai dati. ASP.Net MVC funziona in questo stile. In ASP.Net MVC 4 è presente un supporto per l'API Web che utilizza per creare il servizio utilizzando i verbi HTTP.

Possiamo usare le annotazioni dei dati per la convalida in ASP.Net MVC. Se si desidera utilizzare la convalida durante il runtime utilizzando Jquery, è possibile utilizzare i plug-in Jquery per la convalida. Ad esempio: se la convalida deve essere eseguita sulla casella di testo del nome del cliente, possiamo fare come segue:

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

Di seguito è riportato lo scenario e la soluzione per risolvere il problema con più pulsanti di invio. Scenario :

@using (Html.BeginForm("MyTestAction","MyTestController")
{
    <input type="submit" value="MySave" />
    <input type="submit" value="MyEdit" />
}

Soluzione:

Public ActionResult MyTestAction(string submit) //submit will have value either "MySave" or "MyEdit"
{
    // Write code here
}

• Modelli di visualizzazione: sono incentrati sul modello. Significa che dipende dalle proprietà del modello di visualizzazione utilizzato. Utilizza la convenzione che verrà visualizzata solo come div o etichette.
• Modifica modelli: anche questi sono incentrati sul modello ma avranno controlli modificabili come le caselle di testo.
• Vista parziale: sono incentrate sulla vista. Questi differiranno dai modelli per il modo in cui rendono le proprietà (ID) Ad esempio: CategoryViewModel ha la proprietà della classe Product, quindi verrà renderizzato come Model.Product.ProductName ma in caso di modelli se CategoryViewModel ha List quindi @ Html.DisplayFor (m => m.Products) funziona e rende il modello per ogni elemento di questo elenco.

No. Non è possibile impostare una lunghezza illimitata per la proprietà maxJsonLength. Il valore predefinito è - 102400 e il valore massimo che possiamo impostare sarebbe: 2147483644.

Sì. Possiamo usare il codice razor in javascript in cshtml utilizzando l'elemento <text>.

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

Di seguito è riportato lo snippet di codice per restituire la stringa dal metodo di azione:

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

Di seguito è riportato lo snippet di codice per restituire la stringa dal metodo di azione:

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