Pro ASP.NET MVC 5

Contents at a Glance

Contents

About the Author

About the Technical Reviewer

Chapter 1: Putting ASP.NET MVC in Context

Understanding the History of ASP.NET

What Is Wrong with ASP.NET Web Forms?

Web Development Today

Web Standards and REST

Agile and Test-Driven Development

Ruby on Rails

Node.js

Key Benefits of ASP.NET MVC

MVC Architecture

Extensibility

Tight Control over HTML and HTTP

Testability

Powerful Routing System

Built on the Best Parts of the ASP.NET Platform

Modern API

ASP.NET MVC Is Open Source

What Do I Need to Know?

What Is the Structure of This Book?

Part 1: Introducing ASP.NET MVC 5

Part 2: ASP.NET MVC in Detail

What’s New in this Edition?

Where Can I Get the Example Code?

What Software Do I Need for This Book?

Credits

Summary

Chapter 2: Your First MVC Application

Preparing Visual Studio

Creating a New ASP.NET MVC Project

Adding the First Controller

Understanding Routes

Rendering Web Pages

Creating and Rendering a View

Adding Dynamic Output

Creating a Simple Data-Entry Application

Setting the Scene

Designing a Data Model

Adding a Model Class

Linking Action Methods

Creating the Action Method

Adding a Strongly Typed View

Building the Form

Setting the Start URL

Handling Forms

Using Model Binding

Rendering Other Views

Adding Validation

Highlighting Invalid Fields

Styling the Content

Using NuGet to Install Bootstrap

Styling the Index View

Styling the RsvpForm View

Styling the Thanks View

Completing the Example

Summary

Chapter 3: The MVC Pattern

The History of MVC

Understanding the MVC Pattern

Understanding the Domain Model

The ASP.NET Implementation of MVC

Comparing MVC to Other Patterns

Understanding the Smart UI Pattern

Understanding the Model-View Architecture

Understanding Classic Three-Tier Architectures

Understanding Variations on MVC

Understanding the Model-View-Presenter Pattern

Understanding the Model-View-View Model Pattern

Building Loosely Coupled Components

Using Dependency Injection

Breaking and Declaring Dependencies

Injecting Dependencies

Using a Dependency Injection Container

Getting Started with Automated Testing

Understanding Unit Testing

Using TDD and the Red-Green-Refactor Workflow

Understanding Integration Testing

Summary

Chapter 4: Essential Language Features

Preparing the Example Project

Adding the System.Net.Http Assembly

Using Automatically Implemented Properties

Using Object and Collection Initializers

Using Extension Methods

Applying Extension Methods to an Interface

Creating Filtering Extension Methods

Using Lambda Expressions

Using Automatic Type Inference

Using Anonymous Types

Performing Language Integrated Queries

Understanding Deferred LINQ Queries

Using Async Methods

Applying the async and await Keywords

Summary

Chapter 5: Working with Razor

Preparing the Example Project

Defining the Model

Defining the Controller

Creating the View

Working with the Model Object

Working with Layouts

Creating the Layout

Applying a Layout

Using a View Start File

Demonstrating Shared Layouts

Using Razor Expressions

Inserting Data Values

Setting Attribute Values

Using Conditional Statements

Enumerating Arrays and Collections

Dealing with Namespaces

Summary

Chapter 6: Essential Tools for MVC

Preparing the Example Project

Creating the Model Classes

Adding the Controller

Adding the View

Using Ninject

Understanding the Problem

Applying an Interface

Adding Ninject to the Visual Studio Project

Getting Started with Ninject

Setting up MVC Dependency Injection

Creating the Dependency Resolver

Register the Dependency Resolver

Refactoring the Home Controller

Creating Chains of Dependency

Specifying Property and Constructor Parameter Values

Using Conditional Binding

Setting the Object Scope

Unit Testing with Visual Studio

Creating the Unit Test Project

Creating the Unit Tests

Running the Unit Tests (and Failing)

Implementing the Feature

Testing and Fixing the Code

Using Moq

Understanding the Problem

Adding Moq to the Visual Studio Project

Adding a Mock Object to a Unit Test

Creating a Mock Object

Selecting a Method

Defining the Result

Using the Mock Object

Creating a More Complex Mock Object

Mocking For Specific Values (and Throwing an Exception)

Mocking For a Range of Values

Summary

Chapter 7: SportsStore: A Real Application

Getting Started

Creating the Visual Studio Solution and Projects

Installing the Tool Packages

Adding References Between Projects

Setting Up the DI Container

Running the Application

Starting the Domain Model

Creating an Abstract Repository

Making a Mock Repository

Displaying a List of Products

Adding a Controller

Adding the Layout, View Start File and View

Rendering the View Data

Setting the Default Route

Running the Application

Preparing a Database

Creating the Database

Defining the Database Schema

Adding Data to the Database

Creating the Entity Framework Context

Creating the Product Repository

Adding Pagination

Displaying Page Links

Adding the View Model

Adding the HTML Helper Method

Adding the View Model Data

Displaying the Page Links

Improving the URLs

Styling the Content

Installing the Bootstrap Package

Applying Bootstrap Styles to the Layout

Creating a Partial View

Summary

Chapter 8: SportsStore: Navigation

Adding Navigation Controls

Filtering the Product List

Refining the URL Scheme

Building a Category Navigation Menu

Creating the Navigation Controller

Generating Category Lists

Creating the View

Highlighting the Current Category

Correcting the Page Count

Building the Shopping Cart

Defining the Cart Entity

Adding the Add to Cart Buttons

Implementing the Cart Controller

Displaying the Contents of the Cart

Summary

Chapter 9: SportsStore: Completing the Cart

Using Model Binding

Creating a Custom Model Binder

Completing the Cart

Removing Items from the Cart

Adding the Cart Summary

Submitting Orders

Extending the Domain Model

Adding the Checkout Process

Implementing the Order Processor

Defining the Interface

Implementing the Interface

Registering the Implementation

Completing the Cart Controller

Displaying Validation Errors

Displaying a Summary Page

Summary

Chapter 10: SportsStore: Mobile

Putting Mobile Web Development in Context

Doing Nothing (Or As Little As Possible)

Using Responsive Design

Creating a Responsive Header

Creating a Responsive Product List

Helping the Controller Select a View

Removing View Duplication

Creating Mobile Specific Content

Creating a Mobile Layout

Creating the Mobile Views

Summary

Chapter 11: SportsStore: Administration

Adding Catalog Management

Creating a CRUD Controller

Creating a New Layout

Implementing the List View

Editing Products

Creating the Edit Action Method

Creating the Edit View

Updating the Product Repository

Handling Edit POST Requests

Displaying a Confirmation Message

Adding Model Validation

Enabling Client-Side Validation

Creating New Products

Deleting Products

Summary

Chapter 12: SportsStore: Security & Finishing Touches

Securing the Administration Controller

Creating a Basic Security Policy

Applying Authorization with Filters

Creating the Authentication Provider

Creating the Account Controller

Creating the View

Image Uploads

Extending the Database

Enhancing the Domain Model

Creating the Upload User Interface Elements

Saving Images to the Database

Implementing the GetImage Action Method

Displaying Product Images

Summary

Chapter 13: Deployment

Preparing Windows Azure

Creating the Web Site and Database

Preparing the Database for Remote Administration

Creating the Schema

Getting the Schema Command

Adding the Table Data

Deploying the Application

Summary

Chapter 14: Overview of MVC Projects

Working with Visual Studio MVC Projects

Creating the Project

Understanding MVC Conventions

Following Conventions for Controller Classes

Following Conventions for Views

Following Conventions for Layouts

Debugging MVC Applications

Preparing the Example Project

Creating the Controller

Creating the View

Launching the Visual Studio Debugger

Causing the Visual Studio Debugger to Break

Using Breakpoints

Viewing Data Values in the Code Editor

Viewing Application State in the Debugger Windows

Breaking on Exceptions

Using Edit and Continue

Enabling Edit and Continue

Modifying the Project

Editing and Continuing

Using Browser Link

Summary

Chapter 15: URL Routing

Preparing the Example Project

Creating the Example Controllers

Creating the View

Setting the Start URL and Testing the Application

Introducing URL Patterns

Creating and Registering a Simple Route

Using the Simple Route

Defining Default Values

Using Static URL Segments

Defining Custom Segment Variables

Using Custom Variables as Action Method Parameters

Defining Optional URL Segments

Using Optional URL Segments to Enforce Separation of Concerns

Defining Variable-Length Routes

Prioritizing Controllers by Namespaces

Constraining Routes

Constraining a Route Using a Regular Expression

Constraining a Route to a Set of Specific Values

Constraining a Route Using HTTP Methods

Using Type and Value Constraints

Defining a Custom Constraint

Using Attribute Routing

Enabling and Applying Attribute Routing

Creating Routes with Segment Variables

Applying Route Constraints

Combining Constraints

Using a Route Prefix

Summary

Chapter 16: Advanced Routing Features

Preparing the Example Project

Simplifying the Routes

Adding the Optimization Package

Updating the Unit Test Project

Generating Outgoing URLs in Views

Using the Routing System to Generate an Outgoing URL

Targeting Other Controllers

Passing Extra Values

Specifying HTML Attributes

Generating Fully Qualified URLs in Links

Generating URLs (and Not Links)

Generating Outgoing URLs in Action Methods

Generating a URL from a Specific Route

Customizing the Routing System

Creating a Custom RouteBase Implementation

Routing Incoming URLs

Generating Outgoing URLs

Creating a Custom Route Handler

Working with Areas

Creating an Area

Populating an Area

Resolving the Ambiguous Controller Issue

Creating Areas with Attributes

Generating Links to Actions in Areas

Routing Requests for Disk Files

Configuring the Application Server

Defining Routes for Disk Files

Bypassing the Routing System

URL Schema Best Practices

Make Your URLs Clean and Human-Friendly

GET and POST: Pick the Right One

Summary

Chapter 17: Controllers and Actions

Preparing the Example Project

Setting the Start URL

Introducing the Controller

Creating a Controller with IController

Creating a Controller by Deriving from the Controller Class

Receiving Request Data

Getting Data from Context Objects

Using Action Method Parameters

Understanding How Parameters Objects Are Instantiated

Understanding Optional and Compulsory Parameters

Specifying Default Parameter Values

Producing Output

Understanding Action Results

Returning HTML by Rendering a View

Passing Data from an Action Method to a View

Providing a View Model Object

Passing Data with the View Bag

Performing Redirections

Redirecting to a Literal URL

Redirecting to a Routing System URL

Redirecting to an Action Method

Returning Errors and HTTP Codes

Sending a Specific HTTP Result Code

Sending a 404 Result

Sending a 401 Result

Summary

Chapter 18: Filters

Preparing the Example Project

Setting the Start URL and Testing the Application

Using Filters

Introducing the Filter Types

Applying Filters to Controllers and Action Methods

Using Authorization Filters

Applying the Custom Authorization Filter

Using the Built-in Authorization Filter

Using Authentication Filters

Understanding the IAuthenticationFilter Interface

Implementing the Authentication Check

Combining Authentication and Authorization Filters

Handling the Final Challenge Request

Using Exception Filters

Creating an Exception Filter

Applying the Exception Filter

Using a View to Respond to an Exception

Avoiding the Wrong Exception Trap

Using the Built-in Exception Filter

Preparing to Use the Built-in Exception Filter

Applying the Built-in Exception Filter

Using Action Filters

Implementing the OnActionExecuting Method

Implementing the OnActionExecuted Method

Using Result Filters

Using the Built-in Action and Result Filter Class

Using Other Filter Features

Filtering Without Attributes

Using Global Filters

Ordering Filter Execution

Overriding Filters

Summary

Chapter 19: Controller Extensibility

Preparing the Example Project

Setting the Start URL

Creating a Custom Controller Factory

Dealing with the Fallback Controller

Instantiating Controller Classes

Implementing the Other Interface Methods

Registering a Custom Controller Factory

Working with the Built-in Controller Factory

Prioritizing Namespaces

Customizing DefaultControllerFactory Controller Instantiation

Using the Dependency Resolver

Using a Controller Activator

Overriding DefaultControllerFactory Methods

Creating a Custom Action Invoker

Using the Built-in Action Invoker

Using a Custom Action Name

Using Action Method Selection

Creating a Custom Action Method Selector

Handling Unknown Actions

Improving Performance with Specialized Controllers

Using Sessionless Controllers

Managing Session State in a Custom IControllerFactory

Managing Session State Using DefaultControllerFactory

Using Asynchronous Controllers

Creating the Example

Creating an Asynchronous Controller

Consuming Asynchronous Methods in a Controller

Summary

Chapter 20: Views

Creating a Custom View Engine

Preparing the Example Project

Creating a Custom IView

Creating an IViewEngine Implementation

Registering a Custom View Engine

Testing the View Engine

Working with the Razor Engine

Preparing the Example Project

Understanding Razor View Rendering

Configuring the View Search Locations

Adding Dynamic Content to a Razor View

Using Layout Sections

Testing For Sections

Rendering Optional Sections

Using Partial Views

Creating a Partial View

Using Strongly Typed Partial Views

Using Child Actions

Creating a Child Action

Rendering a Child Action

Summary

Chapter 21: Helper Methods

Preparing the Example Project

Setting the Start URL

Testing the Example Application

Creating Custom Helper Methods

Creating an Inline Helper Method

Creating an External Helper Method

Using a Custom External Helper Method

Managing String Encoding in a Helper Method

Demonstrating the Problem

Encoding Helper Method Content

Using the Built-In Form Helper Methods

Creating Form Elements

Creating Form Elements

Specifying the Route Used by a Form

Using Input Helpers

Generating the Input Element from a Model Property

Using Strongly Typed Input Helpers

Creating Select Elements

Summary

Chapter 22: Templated Helper Methods

Preparing the Example Project

Using Templated Helper Methods

Generating Label and Display Elements

Using Whole-Model Templated Helpers

Using Model Metadata

Using Metadata to Control Editing and Visibility

Using Metadata for Labels

Using Metadata for Data Values

Using Metadata to Select a Display Template

Applying Metadata to a Buddy Class

Working with Complex Type Properties

Customizing the Templated View Helper System

Creating a Custom Editor Template

Creating a Generic Template

Replacing the Built-in Templates

Summary

Chapter 23: URL and Ajax Helper Methods

Preparing the Example Project

Defining Additional CSS Styles

Installing the NuGet Packages

Creating Basic Links and URLs

Using MVC Unobtrusive Ajax

Creating the Synchronous Form View

Preparing the Project for Unobtrusive Ajax

Creating an Unobtrusive Ajax Form

Preparing the Controller

Creating the Ajax Form

Understanding How Unobtrusive Ajax Works

Setting Ajax Options

Ensuring Graceful Degradation

Providing the User with Feedback While Making an Ajax Request

Prompting the User Before Making a Request

Creating Ajax Links

Ensuring Graceful Degradation for Links

Working with Ajax Callbacks

Working with JSON

Adding JSON Support to the Controller

Processing JSON in the Browser

Preparing Data for Encoding

Detecting Ajax Requests in the Action Method

Summary

Chapter 24: Model Binding

Preparing the Example Project

Understanding Model Binding

Using the Default Model Binder

Binding to Simple Types

Binding to Complex Types

Creating Easily-Bound HTML

Specifying Custom Prefixes

Selectively Binding Properties

Binding to Arrays and Collections

Binding to Arrays

Binding to Collections

Binding to Collections of Custom Model Types

Manually Invoking Model Binding

Dealing with Binding Errors

Customizing the Model Binding System

Creating a Custom Value Provider

Creating a Custom Model Binder

Registering the Custom Model Binder

Registering a Model Binder with an Attribute

Summary

Chapter 25: Model Validation

Preparing the Example Project

Creating the Layout

Creating the Views

Explicitly Validating a Model

Displaying Validation Errors to the User

Displaying Validation Messages

Displaying Property-Level Validation Messages

Using Alternative Validation Techniques

Performing Validation in the Model Binder

Specifying Validation Rules Using Metadata

Creating a Custom Property Validation Attribute

Deriving from the Built-In Validation Attributes

Creating a Model Validation Attribute

Defining Self-Validating Models

Performing Client-Side Validation

Enabling Client-Side Validation

Adding the NuGet Packages

Using Client-Side Validation

Understanding How Client-Side Validation Works

Performing Remote Validation

Summary

Chapter 26: Bundles

Preparing the Example Application

Adding the NuGet Packages

Creating the Model and Controller

Creating the Layout and View

Profiling Script and Style Sheet Loading

Using Script and Style Bundles

Adding the NuGet Package

Defining the Bundles

Applying Bundles

Optimizing the JavaScript and CSS Files

Summary

Chapter 27: Web API and Single-page Applications

Understanding Single-page Applications

Preparing the Example Application

Creating the Model

Adding the NuGet Packages

Adding the Controller

Adding the Layout and Views

Setting the Start Location and Testing the Example Application

Using Web API

Creating the Web API Controller

Testing the API Controller

Understanding How the API Controller Works

Understanding API Controller Action Selection

Mapping HTTP Methods to Action Methods

Using Knockout for Single-page Applications

Adding the JavaScript Libraries to the Layout

Implementing the Summary

Defining the Ajax Functions

Defining the Model

Defining the Bindings

Processing the Bindings

Testing the Summary Bindings

Improving the Delete Feature

Implementing the Create Feature

Extending the Model

Implement the Input Elements

Creating the Event Handler

Testing the Create Feature

Completing the Application

Simplify the Home Controller

Manage Content Visibility

Summary

Index