ASP.Net MVC est un modèle utilisé pour diviser la logique d'implémentation de l'application en trois composants, à savoir les modèles, les vues et les contrôleurs.

Modèle: il s'agit essentiellement d'une entité commerciale utilisée pour représenter les données d'application. Contrôleur: La requête envoyée par l'utilisateur se disperse toujours via le contrôleur et sa responsabilité est de rediriger vers la vue spécifique à l'aide de la méthode View (). Vue: c'est la couche de présentation d'ASP.Net MVC.

Voici les fonctionnalités nouvellement ajoutées: Modèles mobiles Ajout d'un modèle d'API Web ASP.NET pour la création de services basés sur REST. Prise en charge des tâches du contrôleur asynchrone. Regroupement des scripts java. Séparation des configurations pour le routage ASP.Net MVC, l'API Web, le bundle, etc.

Voici le traitement suivi dans la séquence -

• Qu'est-ce que la séparation des préoccupations dans ASP.NET ASP.Net MVCation
• Routing
• Instancier et exécuter le contrôleur
• Localiser et appeler l'action du contrôleur
• Instancier et rendre la vue.

• Fournit une séparation nette des préoccupations entre l'interface utilisateur (couche de présentation), le modèle (objets de transfert / objets de domaine / entités) et la logique métier (contrôleur).
• Test d'unité facile.
• Réutilisation améliorée du modèle et des vues. Nous pouvons avoir plusieurs vues qui peuvent pointer vers le même modèle et vice versa.
• Amélioration de la structuration du code.

C'est le processus de décomposition du programme en diverses fonctionnalités distinctes qui chevauchent le moins possible les fonctionnalités. Le modèle ASP.Net MVC concerne la séparation du contenu de la présentation et du traitement des données du contenu.

Razor est la première mise à jour majeure à rendre le HTML dans ASP.Net MVC 3. Razor a été conçu spécifiquement pour la syntaxe du moteur d'affichage. L'objectif principal de ceci serait de simplifier et de créer des modèles centrés sur le code pour la génération HTML. Vous trouverez ci-dessous un exemple d'utilisation de Razor:

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

C'est un terme général qui exprime une philosophie générale, similaire au terme REST (Representational State Transfer). Un JavaScript discret ne mélange pas le code JavaScript dans le balisage de votre page. Par exemple: au lieu d'utiliser des événements comme onclick et onsubmit, le JavaScript discret s'attache aux éléments par leur ID ou leur classe basée sur les attributs de données HTML5.

View Model est une classe simple avec des propriétés, qui est utilisée pour la lier à une vue fortement typée. Le modèle de vue peut avoir les règles de validation définies pour ses propriétés à l'aide d'annotations de données.

Le routage est un mécanisme de correspondance de modèle des demandes entrantes vers les modèles d'URL qui sont enregistrés dans la table de routage. Classe: "UrlRoutingModule" est utilisé pour le même processus.

Les actions sont les méthodes de la classe Controller qui sont chargées de renvoyer la vue ou les données json. L'action aura principalement le type de retour: "ActionResult" et elle sera appelée à partir de la méthode: "InvokeAction ()" appelée par le contrôleur.

L'API Web ASP.NET prend en charge ce type de routage. Ceci est introduit dans ASP.Net MVC5. Dans ce type de routage, des attributs sont utilisés pour définir les routes. Ce type de routage donne plus de contrôle sur le routage URI classique. Le routage d'attributs peut être défini au niveau du contrôleur ou au niveau de l'action comme:

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

Ajoutez simplement @ Model.CustomerName la méthode: "MapASP.Net MVCAttributeRoutes ()" pour activer le routage des attributs comme indiqué ci-dessous:

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

La prise en charge de la liaison JavaScript Object Notation (JSON) a démarré à partir d'ASP.Net MVC3 via le nouveau JsonValueProviderFactory, qui permet aux méthodes d'action d'accepter et de lier des données au format JSON. Cela est utile dans les scénarios Ajax tels que les modèles client et la liaison de données qui doivent renvoyer des données sur le serveur.

Le résolveur de dépendances a de nouveau été introduit dans ASP.Net MVC3 et il est considérablement simplifié l'utilisation de l'injection de dépendances dans vos applications. Cela s'avère plus facile et utile pour découpler les composants de l'application et les rendre plus faciles à tester et plus configurables.

"BundleConfig.cs" dans ASP.Net MVC4 est utilisé pour enregistrer les bundles par le système de regroupement et de minification. De nombreux bundles sont ajoutés par défaut, y compris les bibliothèques jQuery comme - jquery.validate, Modernizr et les références CSS par défaut.

Méthode: "RegisterRoutes ()" est utilisé pour enregistrer les routes qui seront ajoutées dans la méthode "Application_Start ()" du fichier global.asax, qui est déclenchée lorsque l'application est chargée ou démarrée.

Vous trouverez ci-dessous les espaces de noms importants utilisés dans 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 contient les paires clé / valeur sous forme de dictionnaire et cela est dérivé de la classe: "ViewDataDictionary". Dans la méthode d'action, nous définissons la valeur de viewdata et dans la vue, la valeur sera récupérée par conversion de type.

ViewBag est un wrapper autour de ViewData, qui permet de créer des propriétés dynamiques. L'avantage de viewbag par rapport à viewdata sera: dans ViewBag pas besoin de typer les objets comme dans ViewData. ViewBag tirera parti du mot clé dynamique introduit dans la version 4.0. Mais avant d'utiliser ViewBag, nous devons garder à l'esprit que ViewBag est plus lent que ViewData.

TempData est à nouveau une paire clé / valeur en tant que ViewData. Ceci est dérivé de la classe "TempDataDictionary". TempData est utilisé lorsque les données doivent être utilisées dans deux requêtes consécutives, cela peut être entre les actions ou entre les contrôleurs. Cela nécessite une conversion de type en vue.

Les HTML Helpers sont comme les contrôles des formulaires Web traditionnels. Mais les helpers HTML sont plus légers que les contrôles Web car ils ne contiennent ni l'état d'affichage ni les événements. HTML Helpers renvoie la chaîne HTML qui peut être directement rendue sur la page HTML. Des HTML Helpers personnalisés peuvent également être créés en remplaçant la classe "HtmlHelper".

Les Helpers AJAX sont utilisés pour créer des éléments activés AJAX comme des formulaires et des liens activés Ajax qui exécutent la requête de manière asynchrone et ce sont des méthodes d'extension de la classe AJAXHelper qui existe dans l'espace de noms - System.Web.ASP.Net MVC.

Voici les options des helpers AJAX:

• Url: il s'agit de l'URL de la demande.
• Confirmer: Ceci est utilisé pour spécifier le message qui doit être affiché dans la boîte de confirmation.
• OnBegin: nom de méthode Javascript à donner ici et qui sera appelé avant la requête AJAX.
• OnComplete: nom de la méthode Javascript à donner ici et il sera appelé à la fin de la requête AJAX.
• OnSuccess - Nom de la méthode Javascript à donner ici et qui sera appelé lorsque la requête AJAX réussit.
• OnFailure - Nom de la méthode Javascript à donner ici et il sera appelé lorsque la requête AJAX échoue.
• UpdateTargetId: élément cible qui est rempli à partir de l'action renvoyant du HTML.

Les pages de mise en page sont similaires aux pages maîtres des formulaires Web traditionnels. Ceci est utilisé pour définir l'apparence commune sur plusieurs pages. Dans chaque page enfant, nous pouvons trouver: / p>

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

Cela indique que la page enfant utilise la page TestLayout comme page maître.

La section est la partie du HTML qui doit être rendue dans la page de mise en page. Dans la page de mise en page, nous utiliserons la syntaxe ci-dessous pour le rendu du HTML:

@RenderSection("TestSection")

Et dans les pages enfants, nous définissons ces sections comme indiqué ci-dessous:

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

Si une page enfant n'a pas cette section définie, une erreur sera générée afin d'éviter que nous puissions rendre le HTML comme ceci:

@RenderSection("TestSection", required: false)

RenderBody est comme ContentPlaceHolder dans les formulaires Web. Cela existera dans la page de mise en page et rendra les pages / vues enfants. La page de mise en page n'aura qu'une seule méthode RenderBody (). RenderPage existe également dans la page Layout et plusieurs RenderPage () peuvent être là dans la page Layout.

Cette page est utilisée pour s'assurer que la page de mise en page commune sera utilisée pour plusieurs vues. Le code écrit dans ce fichier sera exécuté en premier lors du chargement de l'application.

Vous trouverez ci-dessous les méthodes utilisées pour rendre les vues à partir de l'action -

• Vue (): pour retourner la vue de l'action.
• PartialView (): pour renvoyer la vue partielle de l'action.
• RedirectToAction (): Pour rediriger vers une action différente qui peut être dans le même contrôleur ou dans un contrôleur différent.
• Redirect (): similaire à "Response.Redirect ()" dans les formulaires Web, utilisé pour rediriger vers l'URL spécifiée.
• RedirectToRoute (): Redirection vers l'action à partir de l'URL spécifiée, mais l'URL de la table de routage a été mise en correspondance.

ActionResult est utilisé pour représenter le résultat de la méthode d'action. Voici les sous-types d'ActionResult:

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

Dans ASP.Net MVC, toutes les méthodes publiques ont été traitées comme des actions. Donc, si vous créez une méthode et si vous ne souhaitez pas l'utiliser comme méthode d'action, la méthode doit être décorée avec l'attribut "NonAction" comme indiqué ci-dessous:

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

L'attribut "ActionName" peut être utilisé pour changer le nom de l'action. Voici l'exemple d'extrait de code pour en démontrer plus:

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

Ainsi, dans l'extrait de code ci-dessus, "TestAction" est le nom de l'action d'origine et dans l'attribut "ActionName", le nom - "TestActionNew" est donné. Ainsi, l'appelant de cette méthode d'action utilisera le nom "TestActionNew" pour appeler cette action.

Contrairement aux expressions de code qui sont évaluées et envoyées à la réponse, ce sont les blocs de code qui sont exécutés. Ceci est utile pour déclarer des variables que nous pourrions être amenés à utiliser ultérieurement.

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

La propriété HelperPage.IsAjax obtient une valeur qui indique si Ajax est utilisé lors de la demande de la page Web.

Créez une méthode JavaScript:

function DrpIndexChanged() { }

Appelez la méthode:

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

Les annotations de données sont des attributs qui peuvent être trouvés dans l'espace de noms "System.ComponentModel.DataAnnotations". Ces attributs seront utilisés pour la validation côté serveur et la validation côté client est également prise en charge. Quatre attributs - Obligatoire, Longueur de chaîne, Expression régulière et Plage sont utilisés pour couvrir les scénarios de validation courants.

Cette méthode est utilisée pour rendre la vue partielle spécifiée sous forme de chaîne HTML. Cette méthode ne dépend d'aucune méthode d'action. Nous pouvons utiliser ceci comme ci-dessous: @ Html.Partial ("TestPartialView")

Résultat de la méthode: "RenderPartial" est directement écrit dans la réponse HTML. Cette méthode ne renvoie rien (void). Cette méthode ne dépend pas non plus des méthodes d'action. La méthode RenderPartial () appelle "Write ()" en interne et nous devons nous assurer que la méthode "RenderPartial" est entre crochets. Voici l'exemple d'extrait de code: @ {Html.RenderPartial ("TestPartialView"); }

«RouteConfig.cs» contient la configuration de routage pour ASP.Net MVC. RouteConfig sera initialisé sur l'événement Application_Start enregistré dans Global.asax.

Scaffolding dans ASP.NET ASP.Net MVC est utilisé pour générer les contrôleurs, le modèle et les vues pour la fonctionnalité de création, lecture, mise à jour et suppression (CRUD) dans une application. L'échafaudage connaîtra les conventions de dénomination utilisées pour les modèles, les contrôleurs et les vues.

Voici les types d'échafaudages:

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

Oui, nous pouvons partager une vue sur plusieurs contrôleurs. Nous pouvons mettre la vue dans le dossier "Partagé". Lorsque nous créons un nouveau projet ASP.Net MVC, nous pouvons voir que la page Disposition sera ajoutée dans le dossier partagé, car elle est utilisée par plusieurs pages enfants.

• Nom - Il s'agit du nom de l'itinéraire.
• Modèle d'URL: des espaces réservés seront fournis pour correspondre au modèle d'URL de la demande.
• Valeurs par défaut: lors du chargement de l'application quel contrôleur, action à charger avec le paramètre.

En utilisant cette route par défaut - {resource} .axd / {* pathInfo}, nous pouvons empêcher les requêtes des fichiers de ressources Web comme - WebResource.axd ou ScriptResource.axd de passer à un contrôleur.

Oui, nous pouvons ajouter des contraintes au routage des manières suivantes:

• Utilisation d'expressions régulières
• Utilisation d'un objet qui implémente l'interface - IRouteConstraint.

Voici les deux types d'extensions que la vue rasoir peut avoir:

• .cshtml: En langage de programmation C #, cette extension sera utilisée.
• .vbhtml - Dans le langage de programmation VB, cette extension sera utilisée.

PartialView est similaire aux UserControls dans les formulaires Web traditionnels. À des fins de réutilisation, des vues partielles sont utilisées. Comme il a été partagé avec plusieurs vues, ceux-ci sont conservés dans un dossier partagé. Les vues partielles peuvent être rendues des manières suivantes:

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

Vous trouverez ci-dessous un exemple d'extrait de code permettant d'ajouter du CSS aux vues rasoir: <link rel = "StyleSheet" href = "/ @ Href (~ Content / Site.css") "type =" text / css "/>

Non. Nous ne pouvons pas ajouter les cas de test dans l'édition Visual Studio Express, il ne peut être ajouté que dans les versions Professional et Ultimate de Visual Studio.

Glimpse est un outil open source pour le débogage des routes dans ASP.Net MVC. C'est le débogueur côté client. Glimpse doit être activé en visitant le lien URL local - http: // localhost: portname // glimpse.axd C'est un outil populaire et utile pour le débogage qui suit les détails de vitesse, les détails d'url, etc.

Les filtres d'action nous permettent d'exécuter le code avant ou après l'exécution de l'action. Cela peut être fait en décorant les méthodes d'action des contrôles avec des attributs ASP.Net MVC.

Voici quelques filtres d'action utilisés:

• Authentication
• Authorization
• HandleError
• OutputCache

Cela peut être fait de la manière suivante: Utilisez la classe: "HttpRequestBase" et utilisez la méthode: "HttpMethod" pour déterminer le type de demande d'action.

Chaque fois que la validation échoue, elle sera suivie dans ModelState. En utilisant la propriété: IsValid, il peut être déterminé. Dans le code du serveur, vérifiez comme ceci:

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

Dans Web.Config, il existe des balises appelées: "ClientValidationEnabled" et "UnobtrusiveJavaScriptEnabled". Nous pouvons définir la validation côté client simplement en définissant ces deux balises sur "true", puis ce paramètre sera appliqué au niveau de l'application.

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

Pour la liaison de modèle, nous utiliserons la classe appelée: "ModelBinders", qui donne accès à tous les classeurs de modèle d'une application. Nous pouvons créer un classeur de modèle personnalisé en héritant de "IModelBinder".

La gestion des exceptions est simplifiée dans ASP.Net MVC et peut être effectuée en remplaçant simplement «OnException» et en définissant la propriété result de l'objet filtercontext (comme illustré ci-dessous) sur le détail de la vue, qui doit être renvoyé en cas d'exception.

protected overrides void OnException(ExceptionContext filterContext)
    {
    }

Si Tempdata est affecté dans la requête actuelle, il sera disponible pour la requête actuelle et la requête suivante et cela dépend si les données de TempData sont lues ou non. Si les données dans Tempdata sont lues, elles ne seront pas disponibles pour les demandes suivantes.

Comme expliqué ci-dessus, dans le cas où les données dans Tempdata ont été lues dans la requête actuelle uniquement, la méthode "Keep" a été utilisée pour les rendre disponibles pour la requête suivante.

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

Similaire à la méthode Keep, nous avons une autre méthode appelée "Peek" qui est utilisée dans le même but. Cette méthode permet de lire les données dans Tempdata et de conserver les données pour une demande ultérieure.

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

La zone est utilisée pour stocker les détails des modules de notre projet. Ceci est vraiment utile pour les grandes applications, où les contrôleurs, les vues et les modèles sont tous dans les dossiers des contrôleurs principaux, des vues et des modèles et c'est très difficile à gérer.

Lorsque nous avons créé une zone, assurez-vous qu'elle sera enregistrée dans l'événement "Application_Start" dans Global.asax. Vous trouverez ci-dessous l'extrait de code où l'enregistrement de la zone est effectué:

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

Pour créer des widgets réutilisables, des actions enfants sont utilisées et elles seront incorporées dans les vues parent. Dans ASP.Net MVC, les vues partielles sont utilisées pour être réutilisables dans l'application. L'action enfant renvoie principalement les vues partielles.

L'attribut "ChildActionOnly" est décoré sur les méthodes d'action pour indiquer que la méthode d'action est une action enfant. Vous trouverez ci-dessous l'extrait de code utilisé pour désigner l'action enfant:

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

c'est un modèle de conception et est utilisé pour développer du code de couple lâche. Ceci est très utilisé dans les projets logiciels. Cela réduira le codage en cas de modification de la conception du projet, ce qui est donc largement utilisé.

Voici les avantages de DI:

• Réduit le couplage de classe
• Augmente la réutilisation du code
• Améliore la maintenabilité du code
• Améliore les tests d'application

TDD est une méthodologie qui dit, écrivez vos tests avant d'écrire votre code. Dans TDD, les tests pilotent les cycles de conception et de développement de vos applications. Vous n'effectuez pas l'archivage de votre code dans le contrôle de code source tant que tous vos tests unitaires n'ont pas réussi.

Voici les outils utilisés pour les tests unitaires:

• NUnit
• xUnit.NET
• Ninject 2
• Moq

REST est un style architectural qui utilise des méthodes de protocole HTTP telles que GET, POST, PUT et DELETE pour accéder aux données. ASP.Net MVC fonctionne dans ce style. Dans ASP.Net MVC 4, il existe une prise en charge de l'API Web qui utilise pour créer le service à l'aide de verbes HTTP.

Nous pouvons utiliser les annotations de données pour la validation dans ASP.Net MVC. Si nous voulons utiliser la validation pendant l'exécution en utilisant Jquery, nous pouvons utiliser les plugins Jquery pour la validation. Par exemple: si la validation doit être effectuée sur la zone de texte du nom du client, nous pouvons procéder comme suit:

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

Vous trouverez ci-dessous le scénario et la solution pour résoudre le problème de plusieurs boutons d'envoi. Scénario:

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

Solution :

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

• Modèles d'affichage: ils sont centrés sur le modèle. Cela signifie que cela dépend des propriétés du modèle de vue utilisé. Il utilise une convention qui ne s'affichera que comme des div ou des étiquettes.
• Modifier les modèles: ils sont également centrés sur le modèle, mais auront des contrôles modifiables comme les zones de texte.
• Vue partielle: elles sont centrées sur la vue. Ceux-ci diffèrent des modèles par la façon dont ils rendent les propriétés (Id) Par exemple: CategoryViewModel a la propriété de classe Product, alors il sera rendu comme Model.Product.ProductName mais dans le cas de modèles si nous CategoryViewModel a List puis @ Html.DisplayFor (m => m.Products) fonctionne et il rend le modèle pour chaque élément de cette liste.

Non. Nous ne pouvons pas définir une longueur illimitée pour la propriété maxJsonLength. La valeur par défaut est - 102400 et la valeur maximale que nous pouvons définir serait: 2147483644.

Oui. Nous pouvons utiliser le code rasoir en javascript dans cshtml en utilisant l'élément <text>.

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

Vous trouverez ci-dessous l'extrait de code pour renvoyer la chaîne à partir de la méthode d'action:

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

Vous trouverez ci-dessous l'extrait de code pour renvoyer la chaîne à partir de la méthode d'action:

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