ASP.

NET & MVC

Some Terminologies
1. Solution: It is the outermost container for a C# based application. It can
contain multiple Projects.

2. Project: It is the second outermost container. It can reside independently or in

a Solution. We can have them dedicated for a specific purpose. Example – We
can have 2 different Projects in our Solution for the Web Application and the
Data Layer.

3. Razor View: It is a special file with HTML and C# code in the same file. It has
an extension of .cshtml . If we have a path with the name Index inside the
Controller with the name Home . ASP.NET will then go into the Views > Home >
Index.cshtml to resolve the View.

public class HomeController : Controller {

private IData db;

public HomeController() {
db = new DataDB();
}

public ActionResult Index() {

var model = db.GetAll();
return View(model);
}
}

@model IEnumerable<Solution.DataProject.Models.DataType>
<div>
There are @Model.Count() restaurants in the DB.
</div>

ASP.NET & MVC 1

 <ul>
@foreach (var dataPoint in Model) {
<li>@dataPoint.Property</li>
}
</ul>

From C# to HTML in ASP.NET MVC

.dll files: They’re files in the Microsoft Intermediate Language (MSIL) format.
Visual Studio takes the source code of the project, and compiles the C# and
the Scripts and the Configuration files to MSIL. The .dll is a common
executable file in the Windows environment.

IIS Server: Internet Information Services (IIS), is a Web Server for the Windows
environment. It can be used to host any web content on Windows. Visual
Studio, by default, uses a lightweight version of this, called IIS Express, to host
the code we run using the IDE.

ASP.NET & MVC 2

 💡 Because the IIS Express Server is only responsible for hosting the Web
Server in the Local Machine, the build and run steps are independent of
each other. We can rebuild the application after making changes to the
code in Visual Studio, and it will update the .dll file, which will then
automatically be picked up by the Server. So, we need not re-run the
application to see the changes.

.NET Configurations
Global.asax

<%@ Application CodeBehind="Global.asax.cs"

Inherits="NameOfProject.Web.MvcA
Language="C#" %>

Global.asax.cs

namespace NameOfProject.Web {
public class MvcApplication : System.Web.HttpApplication {
protected void Application_Start() {
// Startup Code for the Application
}
}
}

The above 2 files are auto generated. They’re responsible for the startup of the
app.

BundleConfig.cs
It has the support for bundling the CSS and JS files together, and minifying it.

RouteConfig.cs
It’s used to map the Routes for the application.
We can ignore as well as map specific routes from controllers.

ASP.NET & MVC 3

 routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
// The Resource is the name of the file
// The '*' in front of pathInfo is used to denote all paths afte
// The .axd extension is for Tracing

routes.MapRoute(
name: "Default",
url: "{controller}/{action}/{id}",
defaults: new { controller = "Home", action = "Index", id =
);
/**
* So, a url hit to '/home/contact/' will try to invoke
* the Contact method in HomeController.cs

* P.S.: The defaults are applied in sequential order, so a call

* will apply the default action of 'Index' and invoke the Index
* HomeController.cs
*/

Web.config
It’s an XML file, used for configuration. Most of its logic consists of “Bind
directives”. It binds the Web Server to the appropriate versions of the Assembly
Files. Most of these are irrelevant to the developer.

There is, however, a specific section in the config, called <appSettings> which is
used to define some Settings for the application. The defaults are used for
framework specific configurations. But we can add our own custom settings to it
and use those in our application.

Controllers in .NET
They are the same as Spring Controllers

They don’t need special strings to point to path, they are configured as shown
in Route.config .

ASP.NET & MVC 4

 The method name for each path needs to be either unique, or overloaded.

The HTTP Methods being supported by the Controller method can be

specified using an annotation of the type [HttpGet] .

There also exist a special type of controllers, called API Controllers in the
System. They cannot have special named methods. They will implement
methods by the name of Get(), Post(), Put(), Delete() et cetera.

Models in .NET
They are, for the most part, exactly like Models we are used to.

The annotations for [Required], [MaxLength] , et cetera are all provided by .NET
out of the box.

Entity Framework in .NET

It is an Object Relational Mapper (ORM). It’s an external NuGet package.

It works using the DbContext files. Our database must extend this class.

The DbContext file can then be used to describe our table structures.

It provides us with CRUD operations as a ‘Unit of Work’ operation, i.e., we will

have to call saveChanges() method of the DbContext class for our CRUD
operations to be persisted in the database.

Razor View Engine

Syntax
Anything with @ { ... } format is a block of C# code. But Razor is smart
enough to pick which part of it is HTML, and which is C#.

Anything like @Model.calculate() or @(Model.Calculate()) is a C# expression or

directive that can be injected into the HTML.

Anything like @:text is a literal, which needs to be rendered as HTML.

We can escape the @ sign by writing @@ instead.

ASP.NET & MVC 5

 Properties
_ViewStart.cshtmlis a special file, which the Razor View engine will go looking
for. Anything we write here, will be executed before any and all other .cshtml
files inside the same folder or subfolders that are being loaded by the Razor
View Engine.

Layout Property: The Layout property of a View is used to mention the

template of the View. The Layout Property is used to refer to a special kind of
View, called Layout View. The Layout View renders most of the semantic
HTML code on it (like <!DOCTYPE html>, <head> , et cetera). At one point, the
Layout View will have a @Render.Body() call in it. This will be used to render the
actual View at the location of the method call.

ViewBag Property: It’s a dynamic object property that is present for, and
accessibly from every page. It can be used to store View specific
configurations or values. Example – The page title can be stored in the
ViewBag, and the ViewBag can then be accessed from Layout to dynamically
set the title for a View.

Sections in Views: They can be used to render more elements in the Layout
View. We can have a call to sections inside our Layout View using the
directive. The section can be
@RenderSection("nameOfSection", required: boolean)

defined in any of the subsequent views using the @section nameOfSection { ... }

directive.

Partial Views: This can be used to plug in the small reusable chunks of HTML
into our views. The syntax for calling a partial view inside a full view is
@Html.Partial("_nameOfView", modelElement) .

TempData: Used to send temporary data over via requests. Possible use case
– Can be used to show a Confirmation Message on a Redirect.

namespace Conference.Portal {
public class MyPortalController : Controller {
[HttpPost]
[ValidateAntiForgeryToken] // Used to prevent CSRF at
public ActionResult BookHotel(HotelOrder hotelOrder)
hotelService.bookHotel(hotelOrder);

ASP.NET & MVC 6

 TempData["Message"] = "Thank you for your hotel b
return RedirectToAction("MyPortal", new { hotelBo
}
}
}

The TempDate["Message"] can then be accessed inside the Layout or the View.

Front-End frameworks
: It is used to render Script bundles for client side libraries.
RenderScripts()

They’re configured using the BundleConfig.cs file in App_Start folder. The

bundler picks up the latest files in the bundles folder of the project, and is
smart enough to serve non-minified version in Development, and minified
version in a Production environment. It also bundles the CSS and JS files
together to create single downloads for the clients.

.NET MVC Request Life Cycle

ASP.NET & MVC 7

 Application Start

Application End

ASP.NET & MVC 8

 Pre-Application Start

[assembly: PreApplicationStartMethod(typeof(MvcApplication, "Reg

namespace ProjectName {
public class MvcApplication : HttpApplication {
public static void Register() {
HttpApplication.RegisterModule(typeof(LogModule)); /
}

protected void Application_Start() {

// Do Application Start Logic
}
}
}

Lifecycle of a Request

ASP.NET & MVC 9

 Routing
HttpHandlers
Classes that implement the IHttpHandler interface and generate a response to a
HttpRequest .

Only 1 can execute per request.

Requests handled by a Custom handler, will not be handled by .NET MVC.

ASP.NET & MVC 10

 namespace MvcApplication.Handlers {
public class SampleHandler : IHttpHandler {
public bool isReusable {
get { return false; }
}

public void ProcessRequest(HttpContext context) {

context.Response.Writer("<p>This was generated by th
}
}
}

namespace MvcApplication {
public class RouteConfig {
public static void RegisterRoutes(RouteCollection routes
routes.Add(new Route("home/about", new SampleRouteHa

routes.MapRoute(
name: "Default",
url: "{controller}/{action}/{id}",
defaults: new {
controller = "Home", action = "Index", id =
}

ASP.NET & MVC 11

 );
}
}

private class SampleRouteHandler : IRouteHandler {

public IHttpHandler GetHttpHandler(RequestContext reques
return new SampleHandler();
}
}
}

HttpModules
Classes that implement the IHttpModule interface and are designed to respond to
Lifecycle Events.

We can accomplish the same functionality from our Global.asax file as well.

But breaking it out into a Module makes the Project cleaner, and our code
becomes reusable.

ASP.NET & MVC 12

 Handlers vs Modules

ASP.NET & MVC 13

 Controller Initialisation

ASP.NET & MVC 14

 Controller Factory

ASP.NET & MVC 15

 Dependency Resolver

ASP.NET & MVC 16

 Action Execution

Action Invoker

ASP.NET & MVC 17

 Action Method Selector
Only public , non- static and non-special methods can be considered for an
execution action.

Model Binding

ASP.NET & MVC 18

 Filters

ASP.NET & MVC 19

ASP.NET & MVC 20
ASP.NET & MVC 21
 We can call the Action Filter methods right in the Controller class, because the
Controller class in .NET also implements the IActionFilter .

ASP.NET & MVC 22

ASP.NET & MVC 23
 namespace MvcApplication.Helper {
public enum WorkflowValues {
Begin = 0,
ApplicantInfo = 10,
AddressInfo = 20,
EmploymentInfo = 30,
VehicleInfo = 40,
Products = 50,
Final = 60
}
}

namespace MvcApplication.Filters {
public class WorkflowFilter : FilterAttribute, IActionFilter
private int _highestCompletedStage;
public int MinRequiredStage { get; set; };
public int CurrentStage { get; set; };

public void OnActionExecuted(ActionExecutedContext filte

var _context = DependencyResolver().Current.GetServi

ASP.NET & MVC 24

 var sessionId = filterContext.HttpContext.Session["T

if (null != sessionId) {
Guid tracker;
if (Guid.TryParse(sessionId.ToString(), out trac
if (
filterContext.HttpContext.Request.Reques
&& CurrentStage >= _highestCompletedStag
) {
var applicant = _context.Applications.Fi
x => ApplicantTracker == tracker
);

applicant.WorkflowStage = CurrentStage;
_context.SaveChanges();
}
}
}
}

public void OnActionExecuting(ActionExecutingContext fil

var applicantId = filterContext.HttpContext.Session

if (null != applicantId) {
Guid tracker;
if (Guid.TryParse(applicationId.ToString(), out
var _context = DependencyResolver().Current
_highestCompletedStage = _context.Applicants
x => ApplicantTracker == tracker
).WorkflowStage;

if (MinRequiredStage > _highestCompletedStag

switch (_highestCompletedPage) {
case (int) WorkflowStage.ApplicantIn
filterContext.Result = GenerateR
"ApplicationInfo", "Applican

ASP.NET & MVC 25

 );
break;

case (int) WorkflowStage.AdressInfo

filterContext.Result = GenerateR
"AddressInfo", "Address"
);
break;

case (int) WorkflowStage.EmploymentI

filterContext.Result = GenerateR
"EmploymentInfo", "Employmen
);
break;

case (int) WorkflowStage.VehicleInfo

filterContext.Result = GenerateR
"VehicleInfo", "Vehicle"
);
break;

case (int) WorkflowStage.Products:

filterContext.Result = GenerateR
"ProductInfo", "Products"
);
break;
}
}
}
} else if (CurrentStage != WorkflowStage.ApplicantIn
filterContext.Result = GenerateRedirectUrl("Appl
}
}

private RedirectToRouteResult GenerateRedirectUrl(

string action, string controller

ASP.NET & MVC 26

 ) {
return new RedirectToRouteResult(
new RouteValueDictionary(new { action = action,
);
}
}
}

namespace MvcApplication.Controllers {
[WorflowFilter(
MinRequiredStage = (int) WorkflowValues.bin,
CurrentStage = (int) WorkflowValues.ApplicantInfo
)]
public class ApplicantController : Controller {

}
}

Action Result Execution

ASP.NET & MVC 27

 Custom Action Results

ASP.NET & MVC 28

ASP.NET & MVC 29
 namespace MvcApplication.CustomResults {
public class XmlResult : ActionResult {
private object _data;

public XmlResult(object data) {

_data = data;
}

ASP.NET & MVC 30

 public override void ExecuteResult(ControllerContext con
XmlSerializer serializer = new XmlSerializer(_data.G

var response = context.HttpContext.Response;

response.ContentType = "text/xml";

serializer.Serialize(response.Output, data);
}
}
}

namespace MvcApplication.CustomResults {
public class CsvResult : FileResult {
private IEnumerable _data;

public CsvResult(IEnumerable _data, string fileName) : b

_data = data;
FileDownloadName = fileName; // FileDownloadName is
}

protected override void WriteFile(HttpResponseBase respo

var builder = new StringBuilder();
var stringWriter = new StringWriter(builder);

foreach (var item in _data) {

var properties = item.GetType().GetProperties();
foreach (var prop in properties) {
stringWriter.Write(GetValue(item, prop.Name)
stringWriter.Write(", ");
}
}
}

private static string GetValue(object item, string propN

ASP.NET & MVC 31

 return item
.GetType()
.GetProperty(propName)
.GetValue(item, null)
.ToString() ?? "";
}
}
}

namespace MvcApplication.Controller {
public class FilesController : Controller {
// The Controller Initialization Logic is irrelevant

public ActionResult GetXmlForData() {

var data = _context.GetDataFromSomewhere();
return new XmlResult(data);
}

public ActionResult GetCsvForData() {

var data = _context.GetDataFromSomewhere();
return new CsvResult(data, "Test CSV");
}
}
}

View Results and View Engine

ASP.NET & MVC 32

ASP.NET & MVC 33
ASP.NET & MVC 34
 HTML Helpers

ASP.NET & MVC 35

ASP.NET & MVC 36
ASP.NET & MVC 37