The configuration system provides an environment to easily deploy the application on the cloud. Our application works just like a configuration provider. It helps to retrieve the value from the various configuration sources like XML file.
MVC 6 includes a new environment-based configuration system. Unlike something else it depends on just the Web.Config file in the previous version.
Glimpse is NuGet packages which help in finding performance, debugging and diagnostic information. Glimpse can help you get information about timelines, model binding, routes, environment, etc.
In MVC 6 Microsoft removed the dependency of System.Web.Dll from MVC6 because it's so expensive that typically it consume 30k of memory per request and response, whereas now MVC 6 only requires 2k of memory per request and the response is a very small memory consumtion.
The advantage of using the cloud-optimized framework is that we can include a copy of the mono CLR with your website. For the sake of one website we do not need to upgrade the .NET version on the entire machine. A different version of the CLR for a different website running side by side.
To know whether Ajax is being used at the time of webpage request, HelperPage.IsAjax property is utilized.
Filters are used to define logic that should be performed either after or before action method execution.
Some MVC filters are:
â— Exception filter
â— Action filter
â— Authorisation filter
â— Result filter
In the last, the execution filter is executed.
Controllers define action methods for URL mapping. Every request received by the MVC application is managed and responded to by action methods.
RenderSection() is a method of the WebPageBase class. Scott wrote at one point, The first parameter to the "RenderSection()" helper method specifies the name of the section we want to render at that location in the layout template. The second parameter is optional, and allows us to define whether the section we are rendering is required or not. If a section is "required", then Razor will throw an error at runtime if that section is not implemented within a view template that is based on the layout file (that can make it easier to track down content errors). It returns the HTML content to render.
The model represents the data, and does nothing else. The model does NOT depend on the controller or the view. The MVC Model contains all application logic (business logic, validation logic, and data access logic), except pure view and controller logic. With MVC, models both hold and manipulate application data.
The Models Folde
The Models Folder contains the classes that represent the application model.
Visual Web Developer automatically creates an AccountModels.cs file that contains the models for application security.
Here are popular PHP MVC frameworks:
CodeIgniter: It is one of the most popular PHP MVC frameworks. It’s lightweight and has a short learning curve. It has a rich set of libraries that help build websites and applications rapidly. Users with limited knowledge of OOP programming can also use it.
Kohana: It’s a Hierarchical Model View Controller HMVC that is a secure and lightweight framework. It has a rich set of components for developing applications rapidly.
CakePHP: It is modeled after Ruby on rails. It’s known for concepts such as software design patterns, convention over configuration, ActiveRecord, etc.
Zend: It is a powerful framework that is;
Secure, reliable, fast, and scalable
Supports Web 2.0 and creation of web services.
It features APIs from vendors like Amazon, Google, Flickr, Yahoo, etc. It’s ideal for developing business applications.
You should use PHP MVC Framework because it simplifies working with complex technologies by:
<> Hiding all the complex implementation details
<> Providing standard methods that we can use to build our applications.
<> Increased developer productivity, this is because the base implementation of activities such as connecting to the database, sanitizing user input, etc., are already partially implemented.
<> Adherence to professional coding standards
Here is a code using ng-model to display multi-line input control in AngularJS:
<!DOCTYPE html>
<html>
<head>
<meta chrset="UTF 8">
<title>Event Registration</title>
<link rel="stylesheet" href="css/bootstrap.css"/>
</head>
<body >
<h3> Guru99 Global Event</h3>
<script src="https://code.angularjs.org/1.6.9/angular.js"></script>
<div ng-app="DemoApp" ng-controller="DemoCtrl">
<form>
Topic Description:<br> <br>
<textarea rows="4" cols="50" ng-model="pDescription"></textarea><br><br>
</form>
</div>
<script>
var app = angular.module('DemoApp',[]);
app.controller('DemoCtrl', function($scope){
$scope.pDescription="This topic looks at how Angular JS works
Models in Angular JS"});
</script>
</body>
</html>
Remote validation is the process where we validate specific data posting data to a server without posting the entire form data to the server. Let's see an actual scenario, in one of my projects I had a requirement to validate an email address, whetehr it already exists in the database. Remote validation was useful for that; without posting all the data we can validate only the email address supplied by the user.
Angular.js follows the MVC architecture, the diagram of the MVC framework is shown below.
<> The Controller represents the layer that has the business logic. User events trigger the functions which are stored inside your controller. The user events are part of the controller.
<> Views are used to represent the presentation layer which is provided to the end-users.
<> Models are used to represent your data. The data in your model can be as simple as just having primitive declarations. For example, if you are maintaining a student application, your data model could just have a student id and a name. Or it can also be complex by having a structured data model. If you are maintaining a car ownership application, you can have structures to define the vehicle itself in terms of its engine capacity, seating capacity, etc.
To make Web API serialize the returning object to JSON format and returns JSON data only. For that, you should add the following code in WebApiConfig.cs class in any MVC Web API Project:
//JsonFormatter
//MediaTypeHeaderValue
Config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));
//JsonFormatter
//MediaTypeHeaderValue
Config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"))
Here is the main difference between MVC and WebAPI:
MVC framework is used for developing applications that have a User Interface. For that, views can be used for building a user interface.
WebAPI is used for developing HTTP services. Other apps can also be called the WebAPI methods to fetch that data.
For an MVC developer, it is better t know the significant namespaces used in the ASP.NET MVC application. Here are they:
System.Web.Mvc:
It comprises interfaces and classes which support the MVC pattern for ASP.NET Web applications. Moreover, it contains classes that depict controller factories, controllers, views, partial views, action results, and model binders.
System.Web.Mvc.Ajax:
It includes classes that support Ajax scripting within an ASP.NET MVC application.
iii. System.Web.Mvc.Html:
It includes classes that facilitate the rendering of HTML controls in an MVC application. It contains those classes that support input controls, forms, partial views, links, and validation.
The ASP.NET Core is a cutting-edge platform and it supports various approaches. The user needs to use certain types of distributed cache, for example, Redis. Moreover, Microsoft offers various packages to assist you with this. When using Redis, Microsoft.Extensions.Caching.Redis offers the middleware and employs IDistributedCache to present a standard approach to function with it.
Formerly, HTTP was used as a protocol for all types of clients. Gradually, the client variety began to increase and extend in various directions. The widespread use of Windows applications, JavaScript, and mobile demanded the huge consumption of HTTP. Therefore, the REST approach was introduced. This is the reason why WebAPI technology is implemented to the REST principles to render the data over HTTP.
Here is how MVC works in Spring:
DispatcherServlet receives a request.
After that, the DispatcherServlet communicates with HandlerMapping. It also revokes the controller associated with that specific request.
The Controller processes this request by calling the service methods, and a ModelAndView object is returned by the DispatcherServlet.
The view name is sent to a ViewResolver to find the actual View to invoke.
After that, DispatcherServlet is passed to View to render the result.
By using the model data, the View renders and sends back result back to the user.
ViewBag is dynamic property that takes advantage of new dynamic features in C# 4.0. It's also used to pass data from a controller to a view. In short, The ViewBag property is simply a wrapper around the ViewData that exposes the ViewData dictionary as a dynamic object. Now create an action method "StudentSummary" in the "DisplayDataController" controller that stores a Student class object in ViewBag.
public ActionResult StudentSummary()
{
var student = new Student()
{
Name = "Sandeep Singh Shekhawat",
Age = 24,
City = "Jaipur"
};
ViewBag.Student = student;
return View();
}
C#
Thereafter create a view StudentSummary ("StudentSummary.cshtml") that shows student object data. ViewBag does not require typecasting for complex data type so you can directly access the data from ViewBag.
@ {
ViewBag.Title = "Student Summary";
var student = ViewBag.Student;
}
< table >
< tr >
< th > Name < /th> < th > Age < /th> < th > City < /th> < /tr> < tr >
< td > @student.Name < /td> < td > @student.Age < /td> < td > @student.City < /td> < /tr>
< /table>
Action methods on controllers return JsonResult (JavaScript Object Notation result) that can be used in an AJAX application. This class is inherited from the "ActionResult" abstract class. Here Json is provided one argument which must be serializable. The JSON result object that serializes the specified object to JSON format.
public JsonResult JsonResultTest()
{
return Json("Hello My Friend!");
}
View contains the layout page. Before rendering any view, the view start page is rendered. Moreover, a view may have markup tags such as HTML, body, title, head, and meta, etc.
Partial View does not contain the layout page. It does not validate for a viewstart.cshtml. It is not allowed to place common code for a partial view inside the view start.cshtml.page. Partial view is especially designed to render inside the view and therefore, it does not include any markup. It is allowed to pass a regular view to the RenderPartial method.
The MVC model defines the web applications through 3 logic layers:
The business layer (Model logic)
The display layer (View logic)
The input control (Controller logic)
The Model logic is the portion of the application that only deals with the logic for the application data. Commonly, the model objects access data and even stores data from a database.
The View logic is the portion of the application that looks after the display of the data. Frequently, the model data create views. Some other complex methods of creating views are available.
The Controller logic is the portion of the application that deals with user interaction.
Microsoft introduced jquery.validate.unobtrusive.js plugin with ASP.NET MVC3 to apply data model validations to the client side using a combination of jQuery Validation and HTML 5 data attributes.
Microsoft introduced jquery.validate.unobtrusive.js plugin with ASP.NET MVC3 to apply data model validations to the client side using a combination of jQuery Validation and HTML 5 data attributes.
When server-side model validation fails, errors are included in the ModelState. Hence, by using ModelState.IsValid property you can verify model state. It returns true if there is no error in ModelState else returns false.
[HttpPost]
public ActionResult DoSomething(UserViewModel model)
{
if (ModelState.IsValid)
{
//TODO:
}
return View();
}
Data validation is a key aspect of developing a web application. In Asp.net MVC, we can easily apply validation to the web application by using Data Annotation attribute classes to the model class. Data Annotation attribute classes are present in System.ComponentModel.DataAnnotations namespace and are available to Asp.net projects like Asp.net web application & website, Asp.net MVC, Web forms and also to Entity framework ORM models. Data Annotations help us to define the rules to the model classes or properties for data validation and displaying suitable messages to end users.
For razor views, the file extensions are
<> .cshtml: If C# is the programming language
<> .vbhtml: If VB is the programming language
In the end “Exception Filters†are executed.
The default route prevents requests for a web resource file such as Webresource.axd or ScriptResource.axd from being passed to the controller.
All public methods of a controller class are treated as the action method if you want to prevent this default method, then you have to assign the public method with NonActionAttribute.
This method is used to render the specified partial view as an HTML string. This method does not depend on any action methods. We can use this like below –
@Html.Partial(“TestPartialViewâ€)
In MVC, there are twelve types of results in where “ActionResult†class is the main class while the 11 are their sub-types:
ViewResult
PartialViewResult
EmptyResult
RedirectResult
RedirectToRouteResult
JsonResult
JavaScriptResult
ContentResult
FileContentResult
FileStreamResult
FilePathResult
In order to send the result back in JSON format in MVC, you can use “JSONRESULT†class.
The Action link can help in navigating from one view to another using the hyperlink, which creates a simple URL and navigates to the “Home†controller and also generates the Gotohome action.
Yes, Glimpse helps in finding out the performance, supports debugging, and also helps in diagnosing information. It helps in gaining information about the routes, timelines, model binding, etc.
As per the research and utilization made by Microsoft, Razo is the best and most preferred method than ASPX because it is light in weight and offers simple syntax.
Unlike code expressions that are evaluated and sent to the response, it is the blocks of code that are executed. This is useful for declaring variables which we may be required to be used later.
@{
int x = 123;
string y = “aaâ€;
}
The RenderBody supports web forms as a ContentPlaceHolder. It renders child pages or child views on the existing page layout. The Render page is the part of the layout page. At one time, there can be many numbers of RenderPage in the RenderBody.
Forms Authentication in MVC is offering access to the users over specific service so that they could verify their credentials using their user name, password, or even by applying credentials.
To detect if the call on the controller is a POST action or a GET action we can use the Request.HttpMethod property as shown in the below code snippet.
public ActionResult SomeAction(){
if (Request.HttpMethod == "POST"){
return View("SomePage");
}
else{
return View("SomeOtherPage");
}
}
HTTP is the most used protocol. Since many years, the browser was the most preferred client by which we consumed data exposed over HTTP. But as years passed by, client variety started spreading out. We had demanded to consume data on HTTP from clients like mobile, JavaScript, Windows applications, etc.
For satisfying the broad range of clients, REST was the proposed approach. WebAPI is the technology by which you can expose data over HTTP following REST principles.
Once “TempData†is read in the current request, it’s not available in the subsequent request. If we want “TempData†to be read and also available in the subsequent request then after reading we need to call “Keep†method as shown in the code below.
@TempData["MyData"];
TempData.Keep("MyData");
The more shortcut way of achieving the same is by using “Peekâ€. This function helps to read as well advices MVC to maintain “TempData†for the subsequent request.
string str = TempData.Peek("Td").ToString();
Yes, in case of a physical file found, which matches the URL pattern, the routing is not required. In case when routing is disabled for a URL pattern, then routing cannot be implemented.
The different types of validators include Range, Required, DataType, and StringLength.
Yes, we can implement validation in the MVC application by making use of validators that are well defined in the System.ComponentModel.DataAnnotations namespace.
Two methods for adding constraints to the route is
1. Using regular expressions
2. Using an object that implements IRouteConstraint interface
Url helpers allow you to render HTML links and raw URLs. The output of these helpers is dependent on the routing configuration of your ASP.NET MVC application.
In MVC, Ajax can be implemented in two ways
1. Ajax libraries
2. Jquery
Sessions can be maintained in MVC in three ways: tempdata, viewdata, and viewbag.