Pro ASP.NET 4.5 in C# by Freeman, Adam -- Read -- Imperial Library of Trantor

Index

Cover Title Copyright Dedication Contents at a Glance Contents About the Author About the Technical Reviewer Acknowledgments Part 1: Getting Started

Chapter 1: Your First ASP.NET Application

Preparing Your Workstation Creating a New ASP.NET Project

Adding a New Web Form Testing the Example Application

Creating a Simple Application

Setting the Scene Creating a Data Model and Repository Creating and Styling the Form Handling the Form

Creating the Summary View

Formatting the Dynamic HTML Testing the Dynamic Code Calling a Code-Behind Method

Performing Validation Summary

Chapter 2: Putting ASP.NET in Context

An Overview of the ASP.NET Framework

The Evolution and Restructuring of ASP.NET

About This Book

What Do You Need to Know? What Software and Technology Do I Need? Are There Lots of Examples in This Book?

The Structure of This Book Understanding Web Forms

Understanding Web Forms Strengths Understanding Web Forms Weaknesses

Summary

Chapter 3: Essential C# Language Features

Creating the Example Project 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 Using Generic Typing

Using a Common Base Class Using Generic Typing

Explicitly Implementing Interfaces Performing Language Integrated Queries

Understanding Deferred LINQ Queries

Using Async Methods

Applying the async and await Keywords

Summary

Chapter 4: Using jQuery

Creating the Example Project

Adding jQuery to the Example Project Adding jQuery to the Web Form

Getting Started with jQuery

Waiting for the DOM Understanding jQuery Statements

Selecting Elements

Selecting Elements by Type, Class, or ID Selecting Elements Using Relationships and Unions Selecting Elements Using Attributes Selecting Elements Using Filters Using jQuery Functions

Using jQuery Events Working with JSON Data Summary

Chapter 5: Essential Development Tools

Creating the Example Project Using the Visual Studio Debugger

Creating Conditional Breakpoints Understanding the Application State Using the Immediate Window

Using the Page Inspector and Browser F12 Tools

Using the JavaScript Console Using the Network Monitor Using the JavaScript Profiler

Using NuGet Using Opera Mobile Useful JavaScript Libraries

jQuery, jQuery UI, and jQuery Mobile Knockout Modernizr requireJS

Summary

Chapter 6: SportsStore: A Real Application

Creating the Project

Creating the Folder Structure Adding the Global Application Class Creating the Database Defining the Database Schema Adding Data to the Database

Creating the Data Model and Repository

Creating the Data Model Class Adding the Entity Framework Creating the Entity Framework Context Creating the Product Repository

Creating the Product Listing Adding Pagination

Displaying a Page of Products Adding Pagination Links

Styling the List Web Form

Creating a Master Page Customizing the Master Page Applying the Master Page Testing the Master Page

Summary

Chapter 7: SportsStore: Navigation & Cart

Configuring URL Routing

Creating the Routing Configuration Class Updating the Global Application Class Using Routing Variables Testing the Routing Configuration Generating Routed Links

Adding the Category Information

Creating the User Control Applying the User Control to the Master Page Adding the CSS Styles Expanding the URL Scheme Adding Support for Displaying Categories Highlighting the Current Category

Building the Shopping Cart

Defining the Cart Class Adding the Cart Buttons Creating a Session Helper Handling the Form Post Displaying the Contents of the Cart Testing the Cart

Summary

Chapter 8: SportsStore: Completing the Cart

Removing Unwanted Cart Items

Understanding View State Disabling View State

Adding the Cart Summary

Defining the CSS Styles Applying the Cart Summary Control Consolidating User Control Declarations

Submitting Orders

Extending the Database and Data Model Adding the Checkout Link and URL Processing the Order

Adding Validation

Adding the NuGet Packages Creating and Using a Script Bundle Setting up Client-Side Validation Creating a Server Control Applying the Server Control

Summary

Chapter 9: SportsStore: Administration

Adding the Common Building Blocks

Extending the Routing Configuration Adding the Admin Master Page Adding the CSS Style Sheet Adding a Web Form

Adding Order Management

Cleansing and Populating the Database Adding the Web Form Content Creating the Code-Behind Class

Adding Catalog Management

Extending the Repository Adding the Web Form Setting up the CRUD Methods Testing Catalog Management

Setting up Authorization

Securing the Administration Pages Creating the Authentication Login Web Form Testing Failed Authentication Testing Successful Authentication and Authorization

Summary

Chapter 10: SportsStore: Deployment

Disabling Debug Mode for Final Testing Preparing Windows Azure

Creating the Web Site and Database Preparing the Database for Remote Administration Creating the Schema

Deploying the Application Summary

Chapter 11: Testable Web Apps

Understanding the Problem Understanding the Solution

Why Not Just Use MVC?

Creating the Example Project

Setting Up the Static Content Setting Up the Data Model Implementing the Repository Adding the Infrastructure

Implementing the RSVP Page

Creating the Presenter Creating the View Testing the RSVP Page

Adding Unit Testing

Creating the Unit Test Project Creating Unit Tests Testing Input Values

Adding Dependency Injection

Adding the Ninject Package Configuring Injection

Completing the Application

Creating the Presenter Configuring Dependency Injection

Summary

Part 2: The Core ASP.NET Platform

Chapter 12: Working with Web Forms

Creating the Example Project Understanding the Web Form File

Using Code Nuggets Understanding Programmable HTML Elements Understanding Controls

Understanding Code-Behind Classes

Avoiding Duplication in Code-Behind Classes

Understanding How a Web Form Works

Handling Programmable HTML Elements Compiling the Web Form

Using Master Pages

Configuring Master Pages Understanding Master Page Placeholders Applying the Master Page Using the Master Page Code-Behind Class Nesting Master Pages

Summary

Chapter 13: Lifecycles and Context

Creating the Example Project

Understanding the Global Application Class

Understanding the Application Lifecycle Understanding the Request Lifecycle

Understanding Modules and Handlers Handling Request Lifecycle Events Handling Multiple Events in a Method

Understanding Context Objects

Working with HttpContext Objects Working with HttpApplication Objects Working with HttpRequest Objects Working with HttpResponse Objects

Putting It All Together

Timing the Request Restricting Access Logging the Request

Summary

Chapter 14: Modules

Preparing the Example Application Understanding Modules

Creating a Module Registering a Module

Creating a Module Project

Creating the Visual Studio Project Creating the Modules Registering the Modules

Working with Module Events

Defining the Module Event Handling the Module Event Locating Modules by Name

Working with the Built-In Modules Putting It All Together Summary

Chapter 15: Handlers

Preparing the Example Application Understanding Handlers Handlers and the Request Lifecycle Creating a Generic Handler

Implementing Custom Behavior Testing the Generic Handler

Creating Custom Handlers

Creating a Custom Handler Registering a Custom Handler

Creating Custom Handler Factories

Controlling Handler Instantiation Selecting Handlers Dynamically Recycling Handlers

Coordinating between Modules and Handlers

Using the Items Collection Using Declarative Interfaces

Putting It All Together

Finding the Right Built-In Handler Factory Building on the Base Class Writing the Handler Registering the Handler Factory Testing the Handler Factory

Summary

Chapter 16: Page and Control Lifecycle Events

Preparing the Example Application Understanding the Page Class

Recreating the Handler Factory

Understanding the Page Lifecycle

Handling the Page Events

Handling Control Events

Creating a Simple Control Registering and Applying the Control

Receiving Control Events

Handling the Control Event

Understanding the End-to-End Web Lifecycle The Page Context

Getting Access to Context Objects Setting the Page Directive Values Providing Web Form-Specific Information

Putting It All Together Summary

Chapter 17: Managing Request Execution

Preparing the Example Application Using URL Redirection

Performing URL Redirection Manually Performing Redirections

Managing Handler Selection and Execution

Preempting Handler Selection Transferring a Request Composing Responses by Explicitly Executing Handlers

Putting It All Together

Creating the Source Code View Handler Using an HTTP Redirection Remapping the Handler Executing Multiple Handlers

Summary

Chapter 18: Managing State Data

Creating the Example Application Understanding State Data Storing Application Data Storing User Data

Creating the Profile Database Configuring the Database Connection Configuring Profiles and Profile Properties Defining Profile Providers Defining Profile Properties Using Profile Data

Storing Session Data

Using Session Data Configuring Session Data Using the State Server Using a SQL Database

Using View Data

Configuring View State

Using Cookies Putting It All Together

Creating the Module Creating the Web Form

Summary

Chapter 19: Caching

Preparing the Example Application Using the Application Cache Managing Item Caching Caching with Dependencies

Caching with an Internal Dependency Creating a Custom Dependency Caching with Aggregate Dependencies Caching with Expiration Constraints Caching with Scavenging Prioritization

Receiving Cache Notifications

Receiving Notification of Cache Ejection Using Notifications to Prevent Cache Ejection

Configuring Caching Putting It All Together Summary

Chapter 20: Caching Output

Preparing the Example Application Caching Web Form Output

Controlling End-to-End Caching Caching Multiple Copies of Content Creating Cache Profiles

Selectively Updating Content Caching User Control Output

Caching Multiple Copies Based on Nested Controls

Caching Server Control Output Creating Cache Dependencies Using a Custom Output Cache

Creating the Custom Cache Implementation Registering the Custom Output Cache Implementation Dynamically Selecting an Output Cache Implementation

Configuring the Output Cache Putting It All Together

Creating the Handler Factory Class Registering the Handler Factory

Summary

Chapter 21: Handling Errors

Preparing the Example Project Understanding Errors Customizing the Default Behavior

Providing a Catchall Error Page Handling Specific HTTP Errors Specifying an Error Page Specific to a Web Form

Taking Control of the Error Handling Process

Handling the Error in the Web Form Handling the Error at the Application Level Handling Errors without Redirection

Handling Multiple Errors

Reporting the Errors Displaying the Errors Intercepting the Errors

Putting It All Together

Removing the Existing Error Handling Code Defining the Module

Summary

Chapter 22: Managing Paths

Preparing the Example Project

Creating a Module Creating Additional Content

Working with Paths

Getting Path Information Manipulating Paths

Managing Virtual Paths

Setting Default Documents Handling Requests for Extensionless URLs Rewriting Paths

Using the Friendly URLs Package

Disabling the Previous Examples Installing and Configuring the NuGet Package Using the FriendlyUrls Library Features

Putting It All Together

Writing Files Rewriting Paths

Summary

Chapter 23: URL Routing

Preparing the Example Project Preparing the Application for Routing Working with Fixed Routes

Getting Route Information

Adding Variable Segments

Dealing with Over-Eager Routes Creating Hackable URLs Creating Variable-Length Segments

Model Binding to Route Segment Values Generating Outgoing URLs

Manually Generating Outgoing URLs

Putting It All Together

Generating the Diagnostic HTML Testing URL Matching

Summary

Chapter 24: Advanced URL Routing

Preparing the Example Project Using Advanced Constraints

Restricting a Route by HTTP Method Creating a Custom Route Restriction

Routing Requests for Files

Disabling File Requests for Individual Routes

Working with Routing Handlers

Preventing Routing for a Request Creating a Custom Route Handler

Creating a Custom RouteBase Implementation Putting It All Together

Disabling ASPX Requests Routing to Other File Types Letting ASP.NET Select the Route for an Outgoing URL

Summary

Chapter 25: Authentication and Authorization

Preparing the Example Project Understanding Forms Authentication Configuring ASP.NET Authentication Performing Authentication

Authenticating the User Getting Authentication Information

Performing Authorization

Understanding Authorization and Authentication Integration Creating an Authorization Policy Creating Location-Specific Authorization Policies

Bypassing Authorization Authorization Routed URLs Putting It All Together

Rebuilding the Authentication Web Form Adding a Master Page Testing the Revised Authorization and Authentication

Summary

Chapter 26: Membership

Preparing the Example Project Adding Membership to the Application

Installing the Universal Providers Configuring the Application for Membership Creating Users and Roles Performing Authentication Using Membership

Using Membership

Performing Password Change Performing Password Recovery Performing Registration

Putting It All Together Summary

Chapter 27: ASP.NET Configuration

Preparing the Example Project Understanding the Configuration Hierarchy Getting Configuration Information Programmatically

Working with Application Settings Working with Connection Strings Working with Configuration Sections Working with the Complete Configuration

Creating Custom Configuration Sections and Groups

Creating a Simple Configuration Section Creating a Collection Configuration Section Creating a Configuration Section Group

Using External Configuration Files Locking Configuration Sections Putting It All Together Summary

Chapter 28: Asynchronous Request Handling

Preparing the Example Project Understanding the Problem Creating an Asynchronous Web Form

Using an Asynchronous Method Creating and Registering the Asynchronous Page Task Performing Multiple Tasks

Creating Asynchronous Modules Creating Asynchronous Handlers Summary

Part 3: Forms and Controls

Chapter 29: Working with Controls

Preparing the Example Project Understanding Controls

Understanding the Base Control Class Using Controls for Programmatic Access to HTML Elements Using Custom Controls to Generate Fragments of HTML Using Custom Server Controls Using Controls to Display Data Using Controls to Model Desktop Development

Working with the Control Hierarchy

Navigating the Control Hierarchy Locating and Manipulating Controls in the Hierarchy Adding Controls Programmatically

Putting It All Together

Removing the Rich UI Controls

Summary

Chapter 30: Forms and Request Validation

Preparing the Example Project

Adding jQuery

Understanding the Server-Side Form Element

Using the DefaultButton and DefaultFocus Properties

Detecting Form Posts and Postbacks

Looking for Form Data in the Query String Checking for POST Requests

Working with Form Data Understanding the One-Form Limit Understanding Request Validation

Using Eager Request Validation Using Lazy Request Validation Using Unvalidated Form Data Request Validation in Controls

Putting It All Together Summary

Chapter 31: Creating Custom Controls

Preparing the Example Project

Adding jQuery

Creating a Basic Control

Understanding the Control Directive Registering and Applying a Control Registering a Control in the Web.config File

Adding Functionality to the Control Understanding Control IDs

Identifying HTML Elements Generated by Controls Identifying Controls within the Control Hierarchy

Defining Element Attributes

Creating Enumeration Attributes Creating Collection Attributes

Creating a Server Control

Registering a Server Control Using the HtmlTextWriter Class

Putting It All Together Summary

Chapter 32: Stateful Controls

Preparing the Example Project

Registering and Applying the User Control

Understanding Statelessness and the Control Lifecycle

Using Session State Adding State through Form Elements Using View State Using Control State

Managing Application View State

Configuring Application View State Configuring Web Form and Control View State Configuring Control View State

Putting It All Together

Using View State for Input Elements Using View State in Child Controls Adding to View State Data Confusing View State and Control State

Summary

Chapter 33: Server-Side HTML Elements

Preparing the Example Project Understanding Server-Side Elements

Using the Base Class Features Using Container Elements

Working with Page Structure Elements Working with Form Elements

Working with the input Element Working with Other Form Elements

Working with HTML Tables

Enumerating the Table Working with Specific Table Elements Creating Tables Programmatically

Working with Other Elements Putting It All Together Summary

Chapter 34: Model Binding

Preparing the Example Project Understanding the Problem Applying Model Binding

Applying Model Validation Attributes

Handling Model Binding and Validation Errors

Using the Validation Summary

Using Binding Attributes

Applying Model Binding Attributes Using Model Binding Attributes for Complex Types

Putting It All Together

Creating Self-Validating Model Classes Creating Field-Level Error Controls

Summary

Chapter 35: Data Binding

Preparing the Example Project Understanding Data Binding

Configuring Data Binding Combining Elements and Data Controls

Writing a Custom Data Control

Managing Data Control View State Adding a Template to a Custom Data Control Adding Features to the Template

Putting It Together Summary

Chapter 36: Basic Data Controls

Selecting a Data Control Preparing the Example Project

Adding jQuery

Using the List Data Controls

Using the CheckBoxList Control Using the DropDownList Control Using the ListBox Control Using the RadioButtonList Control Using the BulletedList Control

Using the Repeater Control

Our Standard Repeater Usage Using the Repeater Templates Creating Templates Programmatically

Putting It All Together Summary

Chapter 37: Complex Data Controls

Preparing the Example Project

Preparing Script Management Extending the CSS

Using the FormView Control

Defining the Code-Behind Class Defining the Templates Managing the Outer Element Editing Data with the FormView Control Implementing the Data Methods Understanding FormView Events

Using the ListView Control

Using the Basic ListView Functionality Sorting Data with the ListView Control Paging Data Understanding ListView Events

Putting It All Together Summary

Chapter 38: Other ASP.NET Controls

Preparing the Example Application Working with the Rich UI Controls

Rich UI Controls Are Unnecessary Abstractions Rich UI Controls Modify Element Behavior Rich UI Controls Rely on C# Events Rich UI Controls Are Styled Directly

Selecting a Rich UI Control

Understanding Core Rich UI Control Features

Using the Odds-and-Ends Controls

Using the Literal Control Using the PlaceHolder Control Using the MultiView Control

Putting It All Together Summary

Part 4: Client-Side Development

Chapter 39: Managing Scripts and Styles

Preparing the Example Project Understanding Script Management Issues

Managing JavaScript File Versioning Managing Library Dependencies Managing Minification

Using Bundles

Preparing the Project for Bundles Creating a Script Bundle Creating a Style Bundle

Using Bundling Optimizations

Using Local Optimization Using Content Delivery Networks

Ensuring Libraries Are Available for Controls Putting It All Together Summary

Chapter 40: Ajax and Web Services

Preparing the Example Project Creating Web Services Using Web API

Understanding the Goal Creating the Web API Controller Creating the Routing Configuration Testing the Web Service Implementing the Controller Methods

Consuming the Web Service

Dealing with Model Validation Errors

Dealing with Event Validation

Disabling Event Validation Replacing the Control

Putting It All Together Summary

Chapter 41: Client-Side Validation

Preparing the Example Project

Installing the JavaScript Packages Creating the Validation Script Bundle

Using HTML5 Validation Using the Built-In Validation Controls Applying Validation Attributes Directly

Defining the Validation Policy

Removing Validation Policy Duplication Putting It All Together

Updating the Web Service Updating the Model Object Creating the JavaScript

Summary

Chapter 42: Targeting Mobile Devices

Preparing the Example Project

Adding the jQuery Mobile Package

Identifying Mobile Devices Switching Master Pages for Mobile Devices

Applying JavaScript Libraries via the Master Page

Delivering Different Web Forms

Installing and Configuring the Package Delivering Custom Content Allowing the User to Choose

Putting It All Together Summary

Index

← Prev
Back
Next →

← Prev
Back
Next →