1. Exploring ASP.

NET MVC 4
Overview of Microsoft Web Technologies

WebMatrix 2 - You can use WebMatrix 2 to create static HTML pages and dynamic pages with
ASP.NET, PHP, and Node.js. WebMatrix 2is a free development tool that you can install by
downloading and using the Microsoft Web Platform Installer (Web PI) from the Microsoft website.
WebMatrix2 enables you to develop custom websites based on popular web applications such as
Orchard, Umbraco CMS, and WordPress. Using WebMatrix 2, you can create ASP.NET Web Pages
applications, but not ASP.NET Web Forms or MVC applications

Overview of ASP.NET 4.5

Programming Models

Web Pages: Pages contain server code (C# code, pages have a .cshtml file extension, VB
- .vbhtml). This programming model is simple and easy to learn, and is suited for simple
data-driven sites. ASP.NET 4.5 includes Web Pages version 2.0.

Web Forms: Very similar to building desktop applications. Supports usage of predefined
set of controls that can be dragged and dropped on the form, data source can also be
assigned by drag and drop.
You can also add third-party controls or build custom controls. To respond to user actions,
you can attach event handlers containing code to the server-side controls.

MVC: server-side code is split into 3 parts:

o
o
o

Model
Classes that represent the data or the business logic. Model classes are also
responsible for writing and reading the data to the database.
Controller
Handles user interaction and requests, creates and modifies model classes, and
selects appropriate views.
View

Used to visualize the UI controls and to display them to the users. Controllers
often pass an instance of a model class to a view. The view displays properties of
the model class.

The ASP.NET API

System.Web namespace:

Configuration
Using web.config files, you can configure your web application, regardless of the programming
model. In code, you can access the configuration through the System.Web.Configuration
namespace.

Authentication and Authorization

Many websites require users to log on by entering a user name and password, or by providing
extra information. You can use ASP.NET membership providers to authenticate and authorize
users and restrict access to content (System.Web.Security Namespace)

Caching
ASP.NET caches a rendered page in memory, so that it can return the same page to subsequent
user requests without having to render it again from the start. In a similar manner, .NET
Framework objects can also be cached.
You can access cached pages by using the System.Runtime.Caching namespace and configure
the caches in web.config.

Compiling ASP.NET Code

1. Compilation to MSIL. When you build a website in Visual Studio, the ASP.NET compiler
creates .dll files with all the code compiled into Microsoft Intermediate Language (MSIL). This
code is both independent of the language you used to write the application and the CPU
architecture of the server.
2. Compilation to native code. When a page is requested for the first time, the Common
Language Runtime (CLR) compiles MSIL into native code for the server CPU.
Pages may take extra time to render the first time they are requested after a server restart. To
avoid this delay, you can pre-compile the website.

Client-Side Web Technologies

JavaScript
JQuery
AJAX
AJAX is a technology that enables browsers to communicate with web servers asynchronously
using the XmlHttpRequest object without completely refreshing the page.
You can use AJAX in a page to update a portion of the page with new data, without reloading the
entire page.

Internet Information Server 8.0

Deployment Protocols
Advanced Web Deploy protocol (built into Visual Studio 2012) automatically manages the
deployment of a website with all its dependencies. Alternatively, you can use FTP to deploy
content.

Centralized Web Farm Management

When you run a large website, you can configure a loadbalanced farm of many IIS servers to
scale to large sizes. IIS management tools make it easy to deploy sites to all servers in the farm
and manage sites after deployment.
High Performance Caches
You can configure ASP.NET to make optimal use of the IIS caches to accelerate responses to user
requests. When IIS serves a page or other content, it can cache it in memory so that subsequent
identical requests can be served faster.
Authentication and Security
IIS supports most common standards for authentication, including Smart Card authentication and
Integrated Windows authentication. You can also use SSL to encrypt security-sensitive
communications, such as login pages and pages containing credit card numbers.
ASP.NET Support
IIS is the only web server that fully supports ASP.NET.
Other Server-Side Technologies
You can host websites developed in PHP and Node.js on IIS.

Scaling Up IIS
A single web server has limited scalability because it is limited by its processor speed, memory,
disk speed
Furthermore, single web servers are vulnerable to hardware failures and outages.
You can improve the scalability and resilience of your website by hosting it on a multiple server
farm. In such server farms, many servers share the same server name.
All servers can respond to browser requests. A load balancing system such as Windows Network
Load Balancing or a hardware-based system such as Riverbed Cascade, distributes requests
evenly among the servers in the server farm. If a server fails, other servers are available to
respond to requests, and thereby, the website availability is not interrupted.

Perimeter Networks
Web servers, including IIS, are often located on a perimeter network (firewall to the outside
allowing only certain ports and requests to access the IIS server, second parameter is to the
inside network allowing only web application to access resources e.g. database etc).

IIS Express
Internet Information Server 8.0 Express does not provide all the features of Internet Information
Server 8.0 on Windows Server 2012. E.g. you cannot create load-balanced server farms by using
Internet Information Server 8.0 Express.
It has all the features necessary to host rich ASP.NET 4.5 websites and other websites on a single
server. It is included with Windows 8.

Visual Studio Development Server

Visual Studio 2012 includes an in-built web server, Visual Studio Development Server. When you
open a website in debugging mode, Visual Studio Development Server starts and hosts your site.
Visual Studio
Development Server cannot host sites for production and does not provide all the functionality
available in Internet Information Server 8.0 Express. You cannot configure Secure Sockets Layer
(SSL)

encryption in Visual Studio Development Server.

Windows Azure Hosting

You can use Windows Azure to host the following:
Websites - Windows Azure supports websites developed in ASP.NET, PHP, or Node.js. You can
also deploy websites to Windows Azure directly from Visual Studio 2012 or WebMatrix 2.
Web services - You can call web services from mobile devices, desktop applications, and from
website code running on the client-side or the serverside.
Databases - When you host a website in Windows Azure, you can use SQL Database, which is a
cloud-based database service based on SQL Server, to host your database.
Virtual servers - You can provision entire virtual servers in Windows Azure to run businesscritical back office software or use the virtual servers as test environments. Virtual servers in
Windows Azure can run Windows Server or Linux.
Mobile Services - If you develop apps for mobile devices such as phones and tablets, you can
use Windows Azure to host services that underpin them. Such services can provide user
preference storage, data storage and other functions.
Media Services - When you use Windows Azure to host media such as audio and video, it is
automatically available to many types of devices such as computers, mobile phones, and tablets
and encoded in various formats such as MP4 and Windows Media formats.

Overview of ASP.NET 4.5

Web Pages Applications
Web Pages is the simplest programming model you can choose to build a web application in
ASP.NET
There is a single file associated with each webpage that users can request. For each page, you
write HTML, client-side code, and server-side code in the same .cshtml file (C#, for VB it is
.vbhtml file).
The @ symbol is used to distinguish server-side code from HTML and JavaScript.
When users request the page, the ASP.NET runtime compiles and runs the server-side code to
render HTML and returns that HTML to the web browser for display.
This is the only model that it is supported by WebMatrix 2
<h2>Special Offers</h2>
<p>Get the best possible value on Northwind specialty foods by taking advantage of these offers:</p>
@foreach (var item in offers) {
<div class="offer-card">
<div class="offer-picture">
@if (!String.IsNullOrEmpty(item.PhotoUrl)){
<img src="@Href(item.PhotoUrl) alt="@item.Title" />
}
</div>
</div>
}

The Web Pages programming model has the following advantages:

It is simple to learn
It provides precise control over the rendered HTML

It can be written in WebMatrix 2 or Visual Studio2012

Using a Web Pages site has some disadvantages:

It provides no control over URLs that appear in the address bar
Large websites require a large numbers of pages, each of which must be coded
individually
There is no separation of business logic, input logic, and the user interface
Why should web developers need to take control of the URLs that appear in the address bar when
a visitor browses a Web Pages site?

Web Forms Applications

A Web Forms application is characterized by controls, which you can drag from the Visual Studio
toolbox onto each webpage.
The controls provided include:
Input controls, such as text boxes, option buttons, and check boxes.
Display controls, such as image boxes, image maps, and ad rotators.
Data display controls, such as grid views, form views, and charts.
Validation controls, which check data entered by the user.
Navigation controls, such as menus and tree views.
You can also create your own custom controls to encapsulate custom functionality.

Web Forms Code Files

In a Web Forms application, HTML and control markup is stored in files with an .aspx extension.
Serverside
C# code is usually written in an associated .cs file (code-behind file). default.aspx code behind
class is default.aspx.cs.
Similarly, when you write custom controls, you store HTML and control markup in an .ascx file. A
control
called customcontrol.ascx has a code-behind file called customcontrol.ascx.cs.
You can also write classes with .cs extension.

Binding Controls to Data

In Web Forms applications, you can easily display data by binding controls to data sources. Drag
and drop is supported.

Advantages and Disadvantages of Web Forms

Advantages:
Using server controls and Design View, you can design your page visually.
You can use a broad range of highly functional controls that encapsulate a lot of
functionality.
You can display data without writing many lines of server-side code.
The user interface, in the .aspx file is separated from input and business logic in codebehind files.
Disadvantages:
The ASP.NET Web Forms page life cycle is an abstraction layer over HTTP and can behave
in unexpected ways. You must have a complete understanding of this life cycle in order to
write code in the correct event handlers.
You do not have precise control over markup generated by server-side controls.

Controls can add large amounts of markup and state information to the rendered HTML
page. This increases the time it takes to load pages.

Why should you be concerned about the markup and state information that ASP.NET Web Forms
controls add to a rendered HTML page?

MVC Applications
ASP.NET 4.5 includes MVC version 4.0.
Models
Models are representation of data and they are implemented as custom .NET classes and store
code in .cs files.

Views
Views create the user interface.
Views are markup pages that store both HTML and C# code in .cshtml files. This means that they
are like Web Pages, but they include only user interface code. Other logic is separated into
Models and Controllers.

Controllers
Controllers respond to user actions, load data from a model, and pass it to a view, so that it will
render a webpage. Controllers implement input logic and tie Models to the right Views.
Controllers are .NET classes that inherit from the System.Web.Mvc.Controller class and store
code in .cs files.

Advantages and Disadvantages of MVC

The MVC programming model has the following advantages:

Views enable the developer to take precise control of the HTML that is rendered.
You can use the Routing Engine to take precise control of URLs.
Business logic, input logic, and user interface logic is separated into Models, Controllers,
and Views.
Unit testing techniques and Test Driven Development (TDD) is possible.
Using an MVC site has some disadvantages:
MVC is potentially more complex than Web Pages or Web Forms to understand.
MVC forces you to separate your concerns (models, views, and controllers). Some find this
challenging.
You cannot visually create a user interface by dragging controls onto a page.
You must have a full understanding of HTML, CSS, and JavaScript to develop Views.
When a user makes a request for a particular product in your product catalog, what component
receives the request first: a model, a controller, or a view?

Shared ASP.NET Features

These features are available regardless of the programming model that you use.
Configuration

You can configure ASP.NET sites by creating and editing web.config files. The web.config file in the
root folder of your site configures the entire site, but you can override this configuration at lower
levels by creating web.config files in sub-folders.
If you need to access configuration values at runtime in your server-side .NET code, you can use
the System.Web.Configuration namespace.

Authentication
ASP.NET supports several mechanisms for authentication. If you are using Internet Explorer on a
Windows computer, ASP.NET may be able to use Integrated Windows authentication. In this
mechanism, your Windows user account is used to identify you.
For Internet sites, you cannot be sure that users have Windows, a compatible browser, or an
accessible account, so Forms Authentication is often used. Forms Authentication is supported by
many browsers and it can be configured to check credentials against a database, directory
service, or other user account stores.

Membership and Roles

In ASP.NET, a membership provider is a component that implements user account management
features.
Several membership providers are supported by ASP.NET, such as the SQL Membership Provider,
which uses a SQL database to store user accounts. You can also create a custom membership
provider, inheriting from one of the default providers, if you have unique requirements.
When you have more than a few users, you may want to group them into roles with different
levels of access. For example, you might create a Gold Members role containing user accounts
with access to the best special offers. ASP.NET role providers enable you to create and populate
roles with the minimum of custom code.
You can enable access to pages on your website for individual user accounts or for all members
of a role.
This process is known as authorization.

State Management

Web servers and web browsers communicate through HTTP. This is a stateless protocol - any
values from previous requests are not automatically remembered.
However, when you build a web application, you must frequently preserve values across multiple
page requests.
ASP.NET provides several locations where you can store values or state information across
multiple requests.

Caching
An ASP.NET page is built dynamically by the ASP.NET runtime on the web server. For example, in
a Web Pages application, the runtime must execute the C# code in the page to render HTML to
return it to the browser. That C# code may perform complex and time-consuming operations.
You can use the ASP.NET page cache to store the rendered version of a commonly requested page
in the memory of the web server.

Can you think of other facilities that all ASP.NET applications might need, regardless of the
programming
model they use?

Introduction to ASP.NET MVC 4

Models, Views, and Controllers

Models and Data

A model is a set of .NET class that represents objects handled by your website.
You can also include other procedures, if necessary. These procedures encapsulate the business
logic. For example, you could write a Publish procedure that marks the Product as ready-to-sell.
In an MVC application, the model includes code that reads and writes database records.
ASP.NET MVC works with many different data access frameworks. The most commonly used
framework is the Entity Framework version 5.0.

Controllers and Actions

Controller responds to web browser requests in an MVC application. There is usually one
controller class for each model class. Controllers include actions, which are methods that run in
response to a user request.
Controllers inherit from the System.Web.Mvc.Controller base class. Actions usually return a
System.Web.Mvc.ActionResult object.

Views and Razor

A view is, by default, a .cshtml or .vbhtml file that includes both HTML markup and programming
code.
A view engine interprets view files, runs the server-side code, and renders HTML to the web
browser.
Razor is the default view engine in ASP.NET MVC 4, but ASP.NET MVC 4 also supports the ASPX
view engine.
Additionally, you can install alternate view engines such as Spark and NHaml. The razor view
engine identifies server-side code by looking for the @ symbol as the following example
demonstrates.
Part of a Razor View

<h2>Details</h2>
<fieldset>
<legend>Comment</legend>
<div class="display-label">
@Html.DisplayNameFor(model => model.Subject)
</div>
<div class="display-field">
@Html.DisplayFor(model => model.Subject)
</div>
<div class="display-label">

@Html.DisplayNameFor(model => model.Body)

</div>
<div class="display-field">
@Html.DisplayFor(model => model.Body)
</div>
</fieldset>

Request Life Cycle

1. The user requests the web address: http://www.adventureworks.com/product/display/1
2. The MVC routing engine examines the request and determines that it should forward it to the
Product Controller and the Display action.
3. The Display action in the Product Controller creates a new instance of the Product model class.
4. The Product model class queries the database for information about the product with ID 1.
5. The Display action also creates a new instance of the Product Display View and passes the
Product Model to it.
6. The Razor view engine runs the server-side code in the Product Display View to render HTML. In
this case, the server-side code inserts properties such as Title, Description, Catalog Number, and
Price into the HTML.
7. The completed HTML page is returned to the browser for display.

New Features of ASP.NET MVC 4

ASP.NET MVC 4 includes several new features:
ASP.NET Web API - makes it easy to create a set of web services that can respond to
browser requests using simple HTTP verbs such as GET, POST, and DELETE. Using the
Web API, you can build the back end web services that a client-centric web application
can call. Building web applications using client-centric HTML pages and the Web API is an
alternative to using ASP.NET MVC.
Mobile features It is necessary to ensure that website display well on all screen sizes.
jQuery Mobile script library renders a rich user interface for smartphone browsers and
simpler controls to older models of phones. You can use the new Mobile Project Template
that uses jQuery Mobile to create sites specifically for mobile devices. Alternatively, you
can add mobile-specific views to your MVC project.
Display modes - allow you to select a view easily based on the web browser that made
the request. When you add a display mode for a particular browser, you override the
views, template views, and partial views that are used to render HTML.
Asynchronous controllers - Usually, a Controller action renders synchronously, this
allows you to write more responsive sites since UI thread will not be blocked.
OAuth and OpenID standards support - Using the OAuth and OpenID standards for
identifying users connected to the web application over the Internet, you can call the
services of a thirdparty site to check the credentials of a user. Using these technologies,
you could, for example, enable users to access internal resources by logging on with their
Windows Live account
Bundling and minification - When a browser requests a webpage, the server often
returns the page with a CSS style sheet and one or more JavaScript files. ASP.NET MVC 4.0
can bundle these separate files into a single file to increase the efficiency of the response.
It can also minify these files, by removing white space, shortening variable names, and
performing other actions that save space.
You want to encourage developers to reuse data from your website in mashups with Bing Maps.
Which of the new features of MVC 4 would you use to make this possible?

Module Review and Takeaways

Best Practice: Use Web Pages when you have simple requirements or have developers with
little experience of ASP.NET.

Best Practice: Use Web Forms when you want to create a user interface by dragging controls
from a tool box onto each webpage or when your developers have experience of Web Forms or
Windows Forms.
Best Practice: Use MVC when you want the most precise control of HTML and URLs, when you
want cleanly to separate business logic, user interface code, and input logic, or when you want to
perform Test Driven Development.

2. Designing ASP.NET MVC 4 Web Applications

Planning in the Project Design Phase
Project Development Methodologies
Gathering Requirements
SKIPPED SEE IF NEEDED FOR EXAM

Planning for Distributed Applications

Communication Between Layers

Between the browser and presentation layer web server:

SSL or HTTP

Between the web server and the middle tier server:

Web Services: If you implement business objects and data access classes as web services, the
presentation layer components communicate with the web services by using HTTP. You can
perform authentication by using the Kerberos protocol that is a part of Windows integrated
authentication or by using plain text encrypted with SSL.
Windows Communication Foundation (WCF) Services:
If you implement business objects and data access classes as WCF services, you can choose
between two hosting mechanisms. You can host the WCF services within IIS, in which case HTTP
is the transport mechanism and SSL is the security mechanism. You can also host the WCF
services within a Windows Process Activation Service (WAS), in which case you can use TCP,
Microsoft Message Queuing (MSMQ), or named pipes as the transport mechanism.
Between middle tier server and database:
The middle tier server sends T-SQL queries to the database server, which authenticates against
the database by using the required credentials, which are often included in the connection string.
Note: Web services and WCF services are covered in detail in Course 20487A: Developing
Windows Azure and Web Services.
Question: What are the advantages of writing middle tier components as WCF services and not
web services?

Planning State Management

You should be careful about maintaining large quantities of state data because it either consumes
server memory, if it is stored on the server or slows down the transfer of the webpage to the
browser, if it is included in a web page.

Client-Side State Storage

If you store state information on client side, you will save on server resources. However, all clientside state information must be sent between the web server and the web browser, and this
process can slow down page load time. Use client-side state storage only for small amounts of
data.
Possible usages:
Cookies: Cookies are small text files that you can pass to the browser to store information. A
cookie can be stored:
In the client computer memory, in which case it preserves information only for a single
user session
On the client computer hard disk drive, in which case it preserves information across
multiple sessions.
Most browsers can store cookies only up to 4096 bytes and permit only 20 cookies per website.
Also some users may disable cookies for privacy purposes, so you should not rely on cookies for
critical functions.
Query strings: A query string is the part of the URL after the question mark and is often used to
communicate form values and other data to the server. You can use the query string to preserve
a small amount of data from one page request to another. All browsers support query strings but
some impose a limit of 2083 characters on the URL length
You should not place any sensitive information in query strings because it is visible to the user,
anyone observing their session, or anyone monitoring web traffic.
Note: In ASP.NET Web Forms applications, View State, Control State, and Hidden Fields can be
used to store state information in the rendered HTML that the server sends to the client. These
mechanisms are not available in MVC web applications because they do not use Web Forms
controls.

Server-Side State Storage

The following locations store state information in server memory:
TempData
You can store values by adding them to the TempData collection. This information is preserved
for a single request only and is designed to help maintain data across a web page redirect
(e.g. pass message to an error page)
Application State
This is a state storage location you can use to store vales for the lifetime of the application.
The values stored in application state are shared among all users. You can store values by
adding them to the Application collection. If the web server or the web application is restarted,
the values are destroyed.
The Application_Start() procedure in the Global.asax file is an appropriate place to initialize
application state values.
Session State
The Session collection stores information for the lifetime of a single browser session and values
stored here are specific to a single user session: they cannot be accessed by other users. By
default, if the web server or the web application is restarted the values are destroyed. However,
you can configure ASP.NET to store session state in a database or state server.
Session state is available for both authenticated users and anonymous users.

By default, session state uses cookies to identify users but you can configure ASP.NET to store
session state without using cookies.
Profile propertie
If your site uses an ASP.NET profile provider, you can store user preferences in profiles. Profile
properties are persisted to the membership database so they will be kept even if the web
application or web server restarts.
Database tables
If your site uses an underlying database, like most sites do, you can store state information in its
tables. This is a good place to store large volumes of state data that cannot be placed in server
memory or on the client computer.
Bear in mind that state data is only one form of information that an ASP.NET application places in
server memory. For example, caches must share memory with state data.
Question: You show the visitors of your website a choice of countries. When they pick a state,
you want to redirect them to a page that shows a map of that state. You will not use the name of
the chosen country that the user selected after this. Which location should you use to store the
name of the chosen country?

Planning Globalization and Localization

Managing Browsers for Languages and Regions
Codes are split in two parts:
1. The language
2. The region

Using Resource Files

Index.es-CL.resx , can specify default language

Using Separate Views

When you use separate views to globalize and localize a site, views are more readable, because
most of the text and labels remain in the view file. However, you must create view files, which
requires you or your team members to be proficient in the target language.

Designing Models, Controllers, and Views

Designing Models
Identifying Model Classes and Properties
Domain Model and Logical Data Model Diagrams
You can use Domain Model Diagrams and Logical Data Model (LDM) diagrams to analyze the
information your website manages and suggest a physical data model or database design. Each
object in your Domain Model or LDM diagram should be implemented as an MVC model class.

Relationships and Aggregates

When you identify the model classes that you will implement in your website, you must also
consider the relationships between them. (one to many, one to one, cascading delte)

Entity Framework

The Entity Framework is an Object Relational Mapping (ORM) framework for the .NET Frameworkbased applications. An ORM framework maps database tables and views to classes that a
developer can program against by creating instances or calling methods. The Entity Framework
has been a part of ADO.NET since the .NET Framework 3.5.
When you use the Entity Framework in your MVC web application, it maps tables or views to the
model classes that you have planned. You do not need to write SQL code to query or update
database tables because the Entity Framework does this for you. The Entity Framework is well
integrated with the Language Integrated Query (LINQ) query language.
If you plan to use the Entity Framework for data access, you should decide on how the database
will be created during the planning phase:
Database-First: Use the Entity Framework in the database-first mode when you have a
preexisting database to work with. This may happen because you already have data from
an earlier system or because a DBA has designed the database for you. You can also
choose this mode if you are familiar with creating databases in a database administration
tool, such as Microsoft SQL Server Management Studio. When you use this mode, you
have to specify the database connection string. The Entity Framework connects to the
database and examines the database schema. It creates a set of classes for you to use for
data access.
Model-First: Use the Entity Framework in the model-first mode when you do not have a
preexisting database and prefer to design your model in Visual Studio. You can use the
Entity Designer tool to name, configure, and link your model classes. This creates XML
files which the Entity Framework uses both to create model classes and to create the
database with its tables and relationships.
Code-First: Use the Entity Framework in the code-first mode when you have no preexisting database and prefer to design your models entirely in C# code. Your code must
include DBContext and DBSet objects these correspond to the database and its tables.
When you run the application for the first time, the Entity Framework creates the
database for you. TODO: Does it create it for the other models if we drop the database?
The Entity Framework lets you work in the Agile or Extreme Programming styles. For example, the
framework can update the database when the model changes. Alternatively the framework can
update the model when the database changes. The Entity Framework can perform these updates
in any Entity Framework mode.

Designing Controllers
Identify Controllers and Actions
In an ASP.NET MVC web application, there is usually one controller for each model class.
Conventionally, if the model class is called Photo, the controller is called PhotoController.
If you follow this convention in your design, you can use the MVC default routing behavior to
select the right controller for a request.
For each controller there can be many actions each action is implemented as a method in the
controller and usually returns a view. You often require separate actions for GET and POST HTTP
request verbs. Similar to designing a model, you can identify the actions to write in each
controller by examining the use cases you gathered during analysis.

Designing Views
Views, Template Views, and Partial Views
There is a many-to-one relationship between MVC controllers and views.
For example, a controller may use one view to display a single photo, another view to display
several photos, and a third view to enable users to upload new photos. Each view corresponds to
a web page that the application can display to the user, although it can display different data. For
example, the PhotoDetails view can display different photos, depending on the ID parameter that
is passed to it.
As you plan views, you should also consider parts of the user interface that appear on all pages.
For example, the company logo, main site menu, links to legal information, and log on controls
may need to appear on every page. You can place these user interface components in a template
view to create a consistent look and feel across pages.
Note: Template views in ASP.NET MVC web applications perform the same role as master pages
in
ASP.NET Web Forms applications.
Some user interface components do not appear on all pages but are reused on several pages. For
example, comments may be displayed in a single photo display, on the gallery, or on other
pages. By creating a partial view, you can create a reusable user interface element that can
appear in many locations in this manner, without duplicating code.

Module Review and Takeaways

Best Practice:
When you design an ASP.NET MVC web application, start with the model, and then plan
controllers, actions, and views. The controllers, actions, and views that you create each depend
on the model.

Review Question(s)

Question: You want to support both English and Spanish on your web application. You have both
Spanish-speaking and English-speaking developers and want to ensure that views remain
readable as easily as possible. Should you use multiple view files or multiple resource files to
globalize your site?

3. Developing ASP.NET MVC 4 Models

Creating MVC Models
The model class will probably be revised when you create the controller and views for the model,
and then later during the iterations that happen during the project. If you follow the Agile
development model or Extreme Programming, you begin with a simple understanding of the class
perhaps its name and a few properties.
When developing the model, you can refer to use cases or user stories to ensure that these
model details are correct.
// example of model class

public class Photo

{
public int PhotoID { get; set; }
public string Title { get; set; }
public byte[] PhotoFile { get; set; }
public string Description { get; set; }
public DateTime CreatedDate { get; set; }
public string Owner { get; set; }
public virtual ICollection<Comment> Comments { get; set; }
}

Notice that the model class does not inherit from any other class. Also, notice that you have
created public properties for each property in the model and included the data type, such as
integer or string in the declaration. You can create read-only properties by omitting the set;
keyword.
The Photo class includes a property called Comments. This is declared as a collection of
Comment objects and implements one side of the relationship between photos and comments.
The following lines of code illustrate how you can implement the Comment model class.
public class Comment
{
public int CommentID { get; set; }
public int PhotoID { get; set; }
public string UserName { get; set; }
public string Subject { get; set; }
public string Body { get; set; }
public virtual Photo Photo { get; set; }
}

Notice that the Comment class includes a PhotoID property. This property stores the ID of the
Photo that the user commented on and ties the comment to a single photo. Also, notice that the
Comment class includes a Photo property, which returns the Photo object that the comment
relates to. These properties implement the other side of the relationship between photos and
comments.
// this is how the Model is instantiated from the controller
Photo newPhoto = new Photo();
newPhoto.Title = "This is an Example Photo";
newPhoto.Owner = User.Identity.Name;
newPhoto.CreatedDate = DateTime.Today;
return View("DisplayView", newPhoto);

Using Display and Edit Data Annotations on Properties

The model classes usually specify three attributes for each property:
The name of the property, for example, Title.
The data type of the property, for example, String.

The access levels of the property, for example, the get and set keywords to indicate read
and write access.

Additionally by using attributes, you can supply additional metadata to describe properties to
ASP.NET MVC. The MVC runtime uses this metadata to determine how to render each property in
views for display and editing. These attributes are called display and edit annotations.
E.g. DisplayName annotation property names in C# cannot contain spaces, use DisplayName
to provide name containing spaces.
If you have a DateTime property, you can use display and edit data annotations to inform MVC
what format you want the property displayed in.
[DisplayName("Created Date")]
[DataType(DataType.DateTime)]
[DisplayFormat(DataFormatString = "{0:dd/MM/yy}", ApplyFormatInEditMode = true)]
public DateTime CreatedDate { get; set; }

All the data annotations that are provided with ASP.NET MVC 4 are included in the
System.ComponentModel.DataAnnotations namespace.
Additional Reading: To read more about all the data annotations provided with MVC
4, see http://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations.aspx
Question: In the code on the slide, how can you recognize the display and edit annotations and
distinguish them from other code?

Validating User Input with Data Annotations

You can use data annotations in MVC models to set validation criteria for user input. Input
validation is the process by which MVC checks data provided by a user or a web request to
ensure that it is in the right format.
The following example shows a webpage form that collects some information from the user:
Name. This is required input. The user must enter some data in this field.
Height. This must be an integer between 0 and 400.
Email Address. This is required input. The value entered must be a valid email address.
The Required, Range, StringLength, and RegularExpression annotations implement input
validation in
MVC.
To specify the error message that the user sees when data is not valid, you can use the
ErrorMessage property on the validation data annotations
public class Person
{
public int PersonID { get; set; }
[Required(ErrorMessage="Please enter a name.")]
public string Name { get; set; }
[Range(0, 400)]
public int Height { get; set; }
[Required]
[RegularExpression(".+\\@.+\\..+")]
public string EmailAddress { get; set; }
}

Note: You will see how to ensure that the validation error message is displayed in a view.
Additional Reading: For more examples of validation data annotations see:

http://www.asp.net/mvc/tutorials/older-versions/models-(data)/validation-with-the-dataannotationvalidators-cs
Additional Reading: For more information about the regular expressions that you can use to
check user input, see: http://msdn.microsoft.com/en-us/library/hs600312.aspx
Question: You want to make sure that users enter a password that is longer than 6 characters.
How could you do this by using a validation data annotation?

What Are Model Binders?

A model binder is a component of an ASP.NET MVC application that creates an instance of a
model class, based on the data sent in the request from the web browser.
A model binder ensures that the right data is sent to the parameters in a controller action
method. This enables MVC to create instances of model classes that satisfy the users request.
The default model binder, for example, examines both the definition of the controller action
parameters and the request parameters to determine with request values to pass to which action
parameter.
This model binding process can save developers a lot of time and avoid many unexpected
runtime errors that arise from incorrect parameters. MVC includes a default model binder with
sophisticated logic that passes parameters correctly in almost all cases without complex custom
code.

The Controller Action Invoker and The Default Model Binder

To understand the default model binding process, consider the following request from a web
browser:
http://www.adventureworks.com/product/display/45
This request identifies three aspects:
The model class - a product.
The operation to perform on the model class should be displayed.
The specific instance of the model class - ID 45 is
The request is received by an object called the controller action invoker. The controller action
invoker of the MVC runtime calls a controller action and passes the correct parameters to it.
The ControllerActionInvoker class is the default action invoker. This action invoker uses model
binders to determine how parameters are passed to actions.

How the Default Model Binder Passes Parameters

In a default MVC application, there is only one model binder for the ControllerActionInvoker to
use.
This binder is an instance of the DefaultModelBinder class. The default model binder passes
parameters by using the following logic:
1. The binder examines the definition of the action that it must pass parameters to. In the
example, the binder determines that the action requires an integer parameter called PhotoID.
2. The binder searches for values in the request that can be passed as parameters. In the
example, the binder searches for integers because the action requires an integer. The binder
searches for values in the following locations in order:
a. Form Values: If the user fills out a form and clicks a submit button, you can find parameters in
the Request.Form collection.
b. Route Values: Depending on the routes that you have defined in your web application, the
model binder may be able to identify parameters in the URL. In the example URL, 45 is
identified as a parameter by the default MVC route.

c. Query Strings: If the user request includes named parameters after a question mark, you can
find these parameters in the Request.QueryString collection.
d. Files: If the user request includes uploaded files, these can be used as parameters.
Notice that if there are form values and route values in the request, form values take precedence.
Query string values are only used if there are no form values and no route values available as
parameters.

Model Extensibility
Two ways in which you can extend the MVC handling of MVC models are to create custom data
annotations and to create custom model binders.

Custom Validation Data Annotations

You can use data annotations to indicate to MVC how to validate the data a user enters in a form
or passes in query strings. The four built-in validation attributes in MVC 4, Required, Range,
StringLength, and RegularExpression
In some situations, such as the following examples, you may want to run some custom validation
code:
Running a Data Store Check. You want to check the data entered against data that has
already been stored in the database or in another database store.
Comparing Values. You want to compare two entered values with each other.
Mathematical Checks. You want to calculate a value from the entered data and check that
value is valid.
In such situations you can create a custom validation data annotation. To do this, you create a
class that inherits from the
System.ComponentModel.DataAnnotations.ValidationAttribute class.
[AttributeUsage(AttributeTargets.Field)]
public class LargerThanValidationAttribute : ValidationAttribute
{
public int MinimumValue { get; set; }
//Constructor
public LargerThanValidationAttribute (int minimum)
{
MinimumValue = minimum;
}
//You must override the IsValid method to run your test
public override Boolean IsValid (Object value)
{
var valueToCompare = (int)value;
if (valueToCompare > MinimumValue)
{
return true;
}
else
{
return false;
}
}
}
[LargerThanValidationAttribute(18)]
public VoterAge { get; set; }

Custom Model Binders

The default model binder is sophisticated and flexible, but sometimes you may want to customize
its behavior to pass parameters in an unusual way. You can do this by creating a custom model
binder and registering it with the MVC runtime.
The following lines of code show how to create a simple custom model binder to pass parameters
from the form collection by implementing the IModelBinder interface.
public class CarModelBinder : IModelBinder
{
public object BindModel (ControllerContext controllerContext, ModelBindingContext
bindingContext)
{
//Get the color for the car from the request form
string color = controllerContext.HttpContext.Request.Form["color"];
//Get the brand for the car from the request form
string brand= controllerContext.HttpContext.Request.Form["brand"];
//Create a new instance of the car model
Car newCar = new Car();
newCar.color = color;
newCar.brand = brand;
//return the car
return newCar;
}
}

The code example assumes that you have a model class in your MVC application called Car. It
also assumes that any request for a Car object includes values for color and brand in the form
collection.
Additional Reading: You can see more examples of custom model binders at the following
locations:
http://www.mgolchin.net/posts/20/dive-deep-into-mvc-imodelbinder-part-1
http://dotnetslackers.com/articles/aspnet/Understanding-ASP-NET-MVC-Model-Binding.aspx
Question: You want to ensure that, when a user types a value into the Car Model Number
textbox when adding a new car to the website, the text entered is not already used by another
car in the database.
Would you use a custom validation data annotation or a custom model binder for this?

Data Access in Models and Repositories

In MVC applications, you can place the data access code in the model along with the business
logic. Many software architects prefer to separate these two types of code because they serve
different purposes:
Business Logic. This code defines the objects that the web application manages, their
properties and their relationships with each other.

Data Access Logic. This code defines the operations necessary to persist data to a
database. This includes operations to create new records, read records, update records,
and delete records in database tables. A single object in the business logic layer may take
data from multiple database tables. This abstraction is handled by the data access logic.

MVC does not require you to separate business and data access logic and you can create MVC
model classes that implement both layers. This is often done in small or simple web applications
with small development teams. In these scenarios, Entity Framework classes are used directly in
the model classes.
In more complex situations, you need to place the business logic in MVC model classes and place
the data access logic in dedicated classes called repositories. When you take this approach,
model classes are independent of the database structure and do not include code that depends
on database table names, column names, or view names. This approach makes it easier to
redesign the database or move to a different data store or data access technology, without the
need to recode your entire application. Using this approach, you employ the Entity Framework in
your repository classes, but not in your model classes.

How to Separate Model Classes and Repositories

If you do choose to separate business logic and data access logic, you must take the following
steps for each model class:
1. Define an interface for the repository class. This interface declares the methods that the
repository class uses to read and write data from and to the database.
2. Create and write code for the repository class. This class must implement all the data access
methods declared in the interface.
3. Remove all data access code from the model class.
4. Modify the controller class to use the repository class. Instead create an instance of the
repository class and call its methods to create the model.

A Simple Example Model Class and Repository Class

The Comment Model Class
public class Comment
{
public int CommentID { get; set; }
public int PhotoID { get; set; }

public string CommentText { get; set; }

public virtual Photo Photo { get; set; }
}

The ICommentRepository Interface

public interface ICommentRepository {
ICollection<Comment> GetComments (int PhotoID);
}

The CommentRepository Class

public class CommentRepository : ICommentRepository

{
public ICollection<Comment> GetComments(int PhotoID)
{
//Implement entity framework calls here.
}
}

The CommentsController Class

public class CommentsController : Controller

{
ICommentRepository commentRepository = new CommentRepository;
public ActionResult DisplayCommentsForPhoto (int PhotoID)
{
//Use the repository to get the comments
ICollection<Comments> comments = commentRepository.GetComments(PhotoID);
return View("DisplayComments", comments);
}
}

The CommentsController class uses the repository class instead of calling Entity Framework
methods
Note: By using the ICommentRepository interface, the code makes it easy to replace
CommentRespository with another implementation if you need to. However, the
CommentController code still creates a CommentRespository object. You have to modify the
object to make the replacement.
In an even better architecture you can replace CommentRepository with a different
implementation of ICommentRepository without any changes to the CommentController
class. This is an extremely flexible and adaptable approach and is called a loosely coupled
architecture
Question: You are building a site that collects information from customers for their accounts. You
want to ensure that customers enter a valid email address in the Email property. How would you
do this?
Question: You have been asked to create an intranet site that publishes a customer database,
created by the sales department, to all employees within your company. How would you create
the model with Entity Framework?

Module Review and Takeaways

Best Practice: If you have a pre-existing database for a web application, use Entity Framework
in the database-first workflow to import and create your model and its classes.
Best Practice: If you want to create a new database for a web application and prefer to draw
your model in a Visual Studio designer, use Entity Framework in the model-first workflow to
create your model and its classes.
Best Practice: If you want to create a new database for a web application and prefer to write
code that describes your model, use Entity Framework in the code-first workflow to create your
model and its classes.
Best Practice: If you want to separate business logic from data access logic, create separate
model classes and repository classes.
Question: At the end of the first iteration of your project, you have a website that displays
photos users upload. However, during development the database is empty and users must
upload several photos to the site so they can test functionality. Your manager wants you find
some way to populate the database whenever it is deployed to the test server. How can you do
this?

4. Developing ASP.NET MVC 4 Controllers

Writing Controllers and Actions
Responding to User Requests
When an MVC web application receives a request from a web browser, the following events
happen in sequence:
1. An MvcHandler object creates a controller factory. The controller factory is the object that
instantiates a controller to respond to the request. Usually, this factory is a
DefaultControllerFactory object, but you can create a custom controller factory, if necessary.
The MVCHandler object chooses the controller factory based on the RequestContext object,
which has information about the request that the user made.
2. The controller factory creates a Controller object, and the MvcHandler calls the Execute
method in that controller.
3. The ControllerActionInvoker examines the RequestContext object and determines the
action in the Controller object to call.
4. The ControllerActionInvoker uses a model binder to determine the values to be passed to
the action as parameters.
5. The ControllerActionInvoker runs the action. Often, the action creates a new instance of a
model class, perhaps by querying the database with the parameters that the invoker passed to it.
This model object is passed to a view, to display results to the user. Action methods can do many
other things such as rendering views and partial views, redirecting to other websites, displaying
snippets of content, or displaying other files.
Note: The routing engine determines which controller and action receives a request.
Routing is not covered in this section.