Pro ASP.NET 4 in VB 2010

Title Page

Copyright Page

Contents at a Glance

Table of Contents

About the Authors

About the Technical Reviewer

Introduction

What Does This Book Cover?

Who Is This Book For?

What Do You Need to Use This Book?

Customer Support

Sample Code

Errata

PART I Core Concepts

CHAPTER 1 Introducing ASP.NET

The Seven Pillars of ASP.NET

#1: ASP.NET Is Integrated with the .NET Framework

#2: ASP.NET Is Compiled, Not Interpreted

#3: ASP.NET Is Multilanguage

#4: ASP.NET Is Hosted by the Common Language Runtime

#5: ASP.NET Is Object-Oriented

#6: ASP.NET Supports all Browsers

#7: ASP.NET Is Easy to Deploy and Configure

The Evolution of ASP.NET

ASP.NET 1.0 and 1.1

ASP.NET 2.0

ASP.NET 3.5

LINQ

ASP.NET AJAX

ASP.NET 4

ASP.NET MVC

ASP.NET Dynamic Data

Silverlight

Summary

CHAPTER 2 Visual Studio

Introducing Visual Studio

Websites and Web Projects

Creating a Projectless Website

The Development Language

The Framework Version

The Template

The Location

Designing a Web Page

Absolute Positioning

Smart Tags

Static HTML Tags

HTML Tables

Structuring HTML Markup

The Visual Studio IDE

Solution Explorer

Document Window

Toolbox

Error List and Task List

Server Explorer

The Code Editor

Adding Assembly References

IntelliSense and Outlining

Outlining

Member List

Error Underlining

Visual Studio 2010 Improvements

IntelliSense Gets More Intelligent

New Tools for Search and Navigation

Draggable Document Windows

The Code Model

How Code-Behind Files Are Connected to Pages

How Control Tags Are Connected to Page Variables

How Events Are Connected to Event Handlers

Web Projects

Project-Based Development

Creating a Web Project

Migrating a Website from a Previous Version of Visual Studio

Visual Studio Debugging

Single-Step Debugging

Variable Watches

Advanced Breakpoints

The Web Development Helper

Summary

CHAPTER 3 Web Forms

Page Processing

HTML Forms

Dynamic User Interface

The ASP.NET Event Model

Automatic Postbacks

Automatic Postbacks “Under the Hood”

View State

View State “Under the Hood”

View State Chunking

XHTML Compliance

Document Type Definitions

Configuring XHTML Rendering

Visual Studio’s Default Doctype

XHTML Validation

Client-Side Control IDs

Web Forms Processing Stages

Page Framework Initialization

User Code Initialization

Validation

Event Handling

Automatic Data Binding

Cleanup

A Page Flow Example

The Page As a Control Container

Showing the Control Tree

The Page Header

Dynamic Control Creation

The Page Class

Session, Application, and Cache

Request

Response

Moving Between Pages

HTML and URL Encoding

User

Trace

Application Tracing

Tracing with the Web Development Helper

Accessing the HTTP Context in Another Class

Summary

CHAPTER 4 Server Controls

Types of Server Controls

The Server Control Hierarchy

HTML Server Controls

The HtmlControl Class

The HtmlContainerControl Class

The HtmlInputControl Class

The HTML Server Control Classes

Setting Style Attributes and Other Properties

Programmatically Creating Server Controls

Handling Server-Side Events

The ServerClick and ServerChange Events

Web Controls

The WebControl Base Class

Basic Web Control Classes

Units

Enumerations

Colors

Fonts

Focus

The Default Button

Scrollable Panels

Handling Web Control Events

The Click Event and the ImageButton Control

The List Controls

The Selectable List Controls

The BulletedList Control

Input Validation Controls

The Validation Controls

The Validation Process

The BaseValidator Class

The RequiredFieldValidator Control

The RangeValidator Control

The CompareValidator Control

The RegularExpressionValidator Control

The CustomValidator Control

The ValidationSummary Control

Using the Validators Programmatically

Validation Groups

Rich Controls

The AdRotator Control

The Calendar Control

Summary

CHAPTER 5 ASP.NET Applications

Anatomy of an ASP.NET Application

The Application Domain

Application Lifetime

Application Updates

Application Directory Structure

The global.asax Application File

Application Events

Demonstrating Application Events

ASP.NET Configuration

The machine.config File

The web.config File

Configuration Inheritance

Using Elements

Reading and Writing Configuration Sections Programmatically

The Website Administration Tool (WAT)

Extending the Configuration File Structure

Creating a Section Class

Registering a Section Class

Encrypting Configuration Sections

Programmatic Encryption

Command-Line Encryption

.NET Components

Creating a Component

Using a Component Through the App_Code Directory

Using a Component Through the Bin Directory

Extending the HTTP Pipeline

HTTP Handlers

Creating a Custom HTTP Handler

Configuring a Custom HTTP Handler

Using Configuration-Free HTTP Handlers

Creating an Advanced HTTP Handler

Creating an HTTP Handler for Non-HTML Content

HTTP Modules

Creating a Custom HTTP Module

Summary

CHAPTER 6 State Management

ASP.NET State Management

View State

A View State Example

Storing Objects in View State

Assessing View State

Selectively Disabling View State

View State Security

Transferring Information Between Pages

The Query String

Using the Query String

URL Encoding

Cross-Page Posting

Getting Page-Specific Information

Performing Cross-Page Posting in Any Event Handler

The IsPostBack and IsCrossPagePostBack Properties

Cross-Page Posting and Validation

Cookies

Session State

Session Architecture

Using Session State

Configuring Session State

Mode

Compression

Cookieless

Timeout

Securing Session State

Application State

Shared Application Variables

Summary

PART II Data Access

CHAPTER 7 ADO.NET Fundamentals

The ADO.NET Architecture

ADO.NET Data Providers

Standardization in ADO.NET

Fundamental ADO.NET Classes

The Connection Class

Connection Strings

User Instance Connections

Testing a Connection

Connection Pooling

The Command and DataReader Classes

Command Basics

The DataReader Class

The ExecuteReader() Method and the DataReader

Null Values

CommandBehavior

Processing Multiple Result Sets

The ExecuteScalar() Method

The ExecuteNonQuery() Method

SQL Injection Attacks

Using Parameterized Commands

Calling Stored Procedures

Transactions

Transactions and ASP.NET Applications

Stored Procedure Transactions

Client-Initiated ADO.NET Transactions

Isolation Levels

Savepoints

Provider-Agnostic Code

Creating the Factory

Create Objects with Factory

A Query with Provider-Agnostic Code

Summary

CHAPTER 8 Data Components and the DataSet

Building a Data Access Component

The Data Package

The Stored Procedures

The Data Utility Class

Concurrency Strategies

Testing the Database Component

Disconnected Data

Web Applications and the DataSet

XML Integration

The DataSet

The DataAdapter Class

Filling a DataSet

Working with Multiple Tables and Relationships

Searching for Specific Rows

Using the DataSet in a Data Access Class

Data Binding

The DataView Class

Sorting with a DataView

Filtering with a DataView

Advanced Filtering with Relationships

Calculated Columns

Summary

CHAPTER 9 Data Binding

Basic Data Binding

Single-Value Binding

Other Types of Expressions

Custom Expression Builders

Repeated-Value Binding

Binding to a DataReader

The Rich Data Controls

Binding to a DataView

Data Source Controls

The Page Life Cycle with Data Binding

The SqlDataSource

Selecting Records

Data Binding “Under the Hood”

Parameterized Commands

Stored Procedures

More Parameter Types

Handling Errors

Updating Records

Strict Concurrency Checking

Updating with Stored Procedures

Deleting Records

Inserting Records

Disadvantages of the SqlDataSource

The ObjectDataSource

Selecting Records

Using a Parameterized Constructor

Using Method Parameters

Updating Records

Updating with a Data Object

Dealing with Nonstandard Method Signatures

Handling Identity Values in an Insert

The Limits of the Data Source Controls

The Problem

Adding the Extra Items

Handling the Extra Options with the SqlDataSource

Handling the Extra Options with the ObjectDataSource

Summary

CHAPTER 10 Rich Data Controls

The GridView

Defining Columns

Formatting the GridView

Formatting Fields

Styles

Defining Styles

Configuring Styles with Visual Studio

Formatting-Specific Values

GridView Row Selection

Using Selection to Create a Master-Details Form

The SelectedIndexChanged Event

Using a Data Field As a Select Button

Sorting the GridView

Sorting with the SqlDataSource

Sorting with the ObjectDataSource

Sorting and Selection

Advanced Sorting

Paging the GridView

Automatic Paging

Paging and Selection

Custom Pagination with the ObjectDataSource

Counting the Records

A Stored Procedure to Get Paged Records

The Paged Selection Method

Customizing the Pager Bar

GridView Templates

Using Multiple Templates

Editing Templates in Visual Studio

Binding to a Method

Handling Events in a Template

Editing with a Template

Editing with Advanced Controls

Editing Without a Command Column

Client IDs in Templates

The ListView

Grouping

Paging

The DetailsView and FormView

The DetailsView

Defining Fields

Record Operations

The FormView

Advanced Grids

Summaries in the GridView

A Parent/Child View in a Single Table

Editing a Field Using a Lookup Table

Serving Images from a Database

Displaying Binary Data

Reading Binary Data Efficiently

Integrating Images with Other Content

Detecting Concurrency Conflicts

Summary

CHAPTER 11 Caching and Asynchronous Pages

Understanding ASP.NET Caching

Output Caching

Declarative Output Caching

Caching and the Query String

Caching with Specific Query String Parameters

Custom Caching Control

Caching with the HttpCachePolicy Class

Post-Cache Substitution and Fragment Caching

Fragment Caching

Post-Cache Substitution

Cache Profiles

Cache Configuration

Output Caching Extensibility

Building a Custom Cache Provider

Using a Custom Cache Provider

Data Caching

Adding Items to the Cache

A Simple Cache Test

Cache Priorities

Caching with the Data Source Controls

Caching with SqlDataSource

Caching with ObjectDataSource

Cache Dependencies

File and Cache Item Dependencies

Aggregate Dependencies

The Item Removed Callback

Understanding SQL Cache Notifications

How Cache Notifications Work

Enabling Notifications

Creating the Cache Dependency

Custom Cache Dependencies

A Basic Custom Cache Dependency

A Custom Cache Dependency Using Message Queues

Asynchronous Pages

Creating an Asynchronous Page

Querying Data in an Asynchronous Page

Handling Errors

Using Caching with Asynchronous Tasks

Multiple Asynchronous Tasks and Timeouts

Summary

CHAPTER 12 Files and Streams

Working with the File System

The Directory and File Classes

The DirectoryInfo and FileInfo Classes

The DriveInfo Class

Working with Attributes

Filter Files with Wildcards

Retrieving File Version Information

The Path Class

A File Browser

Reading and Writing Files with Streams

Text Files

Binary Files

Uploading Files

Making Files Safe for Multiple Users

Creating Unique Filenames

Locking File Access Objects

Compression

Serialization

Summary

CHAPTER 13 LINQ

LINQ Basics

Deferred Execution

How LINQ Works

LINQ Expressions

Projections

Filtering and Sorting

Grouping and Aggregation

LINQ Expressions “Under the Hood”

Extension Methods

Lambda Expressions

Multipart Expressions

LINQ to DataSet

Typed DataSets

Null Values

LINQ to Entities

Generating the Data Model

The Data Model Classes

The Derived Object Context Class

The Entity Classes

Entity Relationships

One-to-Many Relationships

One-to-One Relationships

Querying Stored Procedures

LINQ to Entities Queries “Under the Hood”

Filtering Too Late

Using Lazy and Eager Data Loading

Using Explicit Loading

Compiling Queries

Database Operations

Inserts

Creating Partially Populated Entity Classes

Inserting Associated Entities

Updates

Deletes

Managing Concurrency

Handling Concurrency Conflicts

The EntityDataSource Control

Displaying Data

Getting Related Data

Editing Data

Validation

Using the QueryExtender Control

Using a SearchExpression

Using a RangeExpression

Using a PropertyExpression

Using a MethodExpression

Summary

CHAPTER 14 XML

When Does Using XML Make Sense?

An Introduction to XML

The Advantages of XML

Well-Formed XML

XML Namespaces

XML Schemas

Stream-Based XML Processing

Writing XML Files

Reading XML Files

In-Memory XML Processing

The XmlDocument

The XPathNavigator

The XDocument

Creating XML with XDocument

Reading XML with XDocument

Namespaces

Searching XML Content

Searching with XmlDocument

Searching XmlDocument with XPath

Searching XDocument with LINQ

Validating XML Content

A Basic Schema

Validating with XmlDocument

Validating with XDocument

Transforming XML Content

A Basic Stylesheet

Using XslCompiledTransform

Using the Xml Control

Transforming XML with LINQ to XML

XML Data Binding

Nonhierarchical Binding

Using XPath

Nested Grids

Hierarchical Binding with the TreeView

Using XSLT

Binding to XML Content from Other Sources

Updating XML Through the XmlDataSource

XML and the ADO.NET DataSet

Converting the DataSet to XML

Summary

PART III Building ASP.NET Websites

CHAPTER 15 User Controls

User Control Basics

Creating a Simple User Control

Converting a Page to a User Control

Adding Code to a User Control

Handling Events

Adding Properties

Using Custom Objects

Adding Events

Exposing the Inner Web Control

Dynamically Loading User Controls

Portal Frameworks

Partial Page Caching

VaryByControl

Sharing Cached Controls

Summary

CHAPTER 16 Themes and Master Pages

Cascading Style Sheets

Creating a Stylesheet

Applying Stylesheet Rules

Themes

Theme Folders and Skins

Applying a Simple Theme

Handling Theme Conflicts

Creating Multiple Skins for the Same Control

Skins with Templates and Images

Using CSS in a Theme

Applying Themes Through a Configuration File

Applying Themes Dynamically

Standardizing Website Layout

Master Page Basics

A Simple Master Page

A Simple Content Page

Default Content

Master Pages with Tables and CSS Layout

Master Pages and Relative Paths

Applying Master Pages Through a Configuration File

Advanced Master Pages

Interacting with the Master Page Class

Dynamically Setting a Master Page

Nesting Master Pages

Summary

CHAPTER 17 Website Navigation

Pages with Multiple Views

The MultiView Control

The Wizard Control

Wizard Steps

Wizard Events

Wizard Styles, Templates, and Layout

Site Maps

Defining a Site Map

Binding to a Site Map

Breadcrumbs

Showing a Portion of the Site Map

Skipping the Root Node

Starting from the Current Node

Starting from a Specific Node

The Site Map Objects

Adding Custom Site Map Information

Creating a Custom SiteMapProvider

Storing Site Map Information in a Database

Creating the Site Map Provider

Adding Sorting

Adding Caching

Security Trimming

URL Mapping and Routing

URL Mapping

URL Routing

The TreeView Control

The TreeNode

Populating Nodes on Demand

TreeView Styles

Applying Styles to Node Types

Applying Styles to Node Levels

TreeView Images

The Menu Control

Menu Styles

Menu Templates

Summary

CHAPTER 18 Website Deployment

Installing and Configuring IIS

Installing IIS 7

Managing IIS 7

Deploying a Website

Deploying by Copying Files

Preparing IIS

The Website

Deploying the Website

Configuring the Deployment

Using Web Deployment

Preparing IIS

The Website

Transforming web.config

Publishing Databases

Deploying the Website

Using FTP Deployment

Preparing IIS

The Website

Deploying the Website

Variation: Deploying a Project-less Website

Managing a Website

Creating a New Site

Creating Virtual Directories

Using the VirtualPathProvider

Using Application Pools

Creating a New Application Pool

Assigning an Application to an Application Pool

Starting and Stopping an Application Pool

Using Side-by-Side Execution

Using Application Warm-Up

Preparing IIS 7

Configuring Application Warm-Up

Extending the Integrated Pipeline

Creating the Handler

Deploying the Handler

Configuring the Handler

Testing the Handler

Summary

PART IV Security

CHAPTER 19 The ASP.NET Security Model

What It Means to Create Secure Software

Understanding Potential Threats

Secure Coding Guidelines

Understanding Gatekeepers

Understanding the Levels of Security

Authentication

Impersonation

Authorization

Confidentiality and Integrity

Pulling It All Together

Understanding Secure Sockets Layer

Understanding Certificates

Understanding SSL

Configuring SSL in IIS 7.x

Configuring Bindings for SSL

Encoding Information with SSL

Summary

CHAPTER 20 Forms Authentication

Introducing Forms Authentication

Why Use Forms Authentication?

Controlling the Authentication Code

Controlling the Appearance of the Login Form

Working with a Range of Browsers

Storing User Information

Why Would You Not Use Forms Authentication?

Creating Your Own Login Interface

Maintaining User Details

Intercepting Network Traffic

Why Not Implement Cookie Authentication Yourself?

Keeping the Authentication Cookie Secure

Forms Authentication Is Well Tested

Integrating with the ASP.NET Security Framework

The Forms Authentication Classes

Implementing Forms Authentication

Configuring Forms Authentication

Credentials Store in web.config

Denying Access to Anonymous Users

Creating a Custom Login Page

Logging Out

Hashing Passwords in web.config

Cookieless Forms Authentication

Custom Credentials Store

Persistent Cookies in Forms Authentication

IIS 7.x and Forms Authentication

Summary

CHAPTER 21 Membership

Introducing the ASP.NET Membership API

Using the Membership API

Configuring Forms Authentication

Creating the Data Store

Database Scripts for ASP.NET Services

File-Based SQL Server Store

Configuring Connection String and Membership Provider

Creating and Authenticating Users

Using the Security Controls

The Login Control

Templates and the Login Control

Programming the Login Control

The LoginStatus Control

The LoginView Control

The PasswordRecovery Control

PasswordRecovery Templates

The ChangePassword Control

The CreateUserWizard Control

Configuring Membership in IIS 7.x

Configuring Providers and Users

Using the Membership API with Other Applications

Using the Membership Class

Retrieving Users from the Store

Updating Users in the Store

Creating and Deleting Users

Validating Users

Summary

CHAPTER 22 Windows Authentication

Introducing Windows Authentication

Why Use Windows Authentication?

Why Would You Not Use Windows Authentication?

Mechanisms for Windows Authentication

Basic Authentication

Digest Authentication

Integrated Windows Authentication

Implementing Windows Authentication

Configuring IIS 7.x

Configuring ASP.NET

Deeper Into the IIS 7.x Pipeline

Denying Access to Anonymous Users

Accessing Windows User Information

The WindowsPrincipal Class

The WindowsIdentity Class

IdentityReference and Role Information

Impersonation

Impersonation and Delegation in Windows

Configured Impersonation

Programmatic Impersonation

Getting a Token

Performing the Impersonation

Summary

CHAPTER 23 Authorization and Roles

URL Authorization

Authorization Rules

Controlling Access for Specific Users

Controlling Access to Specific Directories

Controlling Access to Specific Files

Controlling Access for Specific Roles

File Authorization

Authorization Checks in Code

Using the IsInRole() Method

Using the PrincipalPermission Class

Merging PrincipalPermission Objects

Using the PrincipalPermission Attribute

Using the Roles API for Role-Based Authorization

Using the LoginView Control with Roles

Accessing Roles Programmatically

Using the Roles API with Windows Authentication

Authorization and Roles in IIS 7.x

Authorization with ASP.NET Roles in IIS 7.x

Managing ASP.NET Roles with IIS 7.x

Summary

CHAPTER 24 Profiles

Understanding Profiles

Profile Performance

How Profiles Store Data

Profiles and Authentication

Profiles vs. Custom Data Components

Using the SqlProfileProvider

Creating the Profile Tables

Configuring the Provider

Defining Profile Properties

Using Profile Properties

Profile Serialization

Profile Groups

Profiles and Custom Data Types

Custom Type Serialization

Automatic Saves

The Profiles API

Anonymous Profiles

Migrating Anonymous Profiles

Custom Profile Providers

The Custom Profile Provider Classes

Designing the FactoredProfileProvider

Coding the FactoredProfileProvider

Initialization

Reading Profile Information

Updating Profile Information

Testing the FactoredProfileProvider

Summary

CHAPTER 25 Cryptography

Encrypting Data: Confidentiality Matters

The .NET Cryptography Namespace

Understanding the .NET Cryptography Classes

Symmetric Encryption Algorithms

Asymmetric Encryption

The Abstract Encryption Classes

The ICryptoTransform Interface

The CryptoStream Class

Encrypting Sensitive Data

Managing Secrets

Using Symmetric Algorithms

Using the SymmetricEncryptionUtility Class

Using Asymmetric Algorithms

Encrypting Sensitive Data in a Database

Encrypting the Query String

Wrapping the Query String

Creating a Test Page

Summary

CHAPTER 26 Custom Membership Providers

Architecture of Custom Providers

Basic Steps for Creating Custom Providers

Overall Design of the Custom Provider

Designing and Implementing the Custom Store

Implementing the Provider Classes

Creating Users and Adding Them to the Store

Validating Users on Login

Using Salted Password Hashes

The Remaining Functions of the Provider

Implementing the XmlRoleProvider

Using the Custom Provider Classes

Debugging Using the WAT

Using Custom Providers with IIS 7.x

Summary

PART V Advanced User Interface

CHAPTER 27 Custom Server Controls

Custom Server Control Basics

Creating a Bare-Bones Custom Control

Using a Custom Control

Custom Controls in the Toolbox

Creating a Web Control That Supports Style Properties

The Rendering Process

Dealing with Different Browsers

The HtmlTextWriter

Browser Detection

Browser Properties

Overriding Browser Type Detection

Adaptive Rendering

Control State and Events

View State

Control State

Postback Data and Change Events

Triggering a Postback

Extending Existing Web Controls

Composite Controls

Derived Controls

Creating a Label for Specific Data

Summary

CHAPTER 28 Graphics, GDI+, and Charting

The ImageMap Control

Creating Hotspots

Handling Hotspot Clicks

A Custom Hotspot

Drawing with GDI+

Simple Drawing

Image Format and Quality

The Graphics Class

Using a GraphicsPath

Pens

Brushes

Embedding Dynamic Graphics in a Web Page

Using the PNG Format

Passing Information to Dynamic Images

Custom Controls That Use GDI+

The Custom Control Class

The Rendering Page

Using the Chart Control

Creating a Basic Chart

Populating a Chart with Data

Binding to a Database Table

Binding to a Object DataSource

Binding to an XML File

Binding to LINQ

Summary

CHAPTER 29 JavaScript and Ajax Techniques

JavaScript Essentials

The HTML Document Object Model

Client-Side Events

Adding JavaScript Attributes Declaratively

The OnClientClick Property

Script Blocks

Manipulating HTML Elements

Debugging JavaScript

Basic JavaScript Examples

Creating a JavaScript Page Processor

Using JavaScript to Download Images Asynchronously

Rendering Script Blocks

Script Injection Attacks

Request Validation

Disabling Request Validation

Extending Request Validation

Custom Controls with JavaScript

Pop-Up Windows

Rollover Buttons

Frames

Frame Navigation

Inline Frames

Understanding Ajax

The XMLHttpRequest Object

Sending a Request

Handling the Response

An Ajax Example

Using Ajax with Client Callbacks

Creating a Client Callback

Building the Basic Page

Implementing the Callback

Writing the Client-Side Script

Disabling Event Validation

Client Callbacks “Under the Hood”

Client Callbacks in Custom Controls

The DynamicPanel

The DynamicPanelRefreshLink

The Client Page

Summary

CHAPTER 30 ASP.NET AJAX

Introducing ASP.NET AJAX

ASP.NET AJAX on the Client: The Script Libraries

ASP.NET AJAX on the Server: The ScriptManager

Server Callbacks

Web Services in ASP.NET AJAX

Creating the Web Service

Creating the Web Method

Calling the Web Service

Placing a Web Method in a Page

ASP.NET AJAX Application Services

Authentication Service

Role Service

Profile Service

ASP.NET AJAX Server Controls

Partial Rendering with the UpdatePanel

Handling Errors

Conditional Updates

Interrupted Updates

Triggers

Optimizing the UpdatePanel

Timed Refreshes with the Timer

Time-Consuming Updates with UpdateProgress

Cancellation

Managing Browser History

Adding History Points

Restoring Page State

How State Is Stored in the URL

Deeper into the Client Libraries

Understanding the Client Model

Object-Oriented Programming in JavaScript

Closures

Prototypes

Registering Classes with ASP.NET AJAX

Base Types

Namespaces

Inheritance

Interfaces

The Web-Page Framework

The Application Class

The PageRequestManager Class

A Client-Side AJAX Control

Control Extenders

Installing the ASP.NET AJAX Control Toolkit

The AutoCompleteExtender

The ASP.NET AJAX Control Toolkit

Summary

CHAPTER 31 Portals with Web Part Pages

Typical Portal Pages

Basic Web Part Pages

Creating the Page Design

WebPartManager and WebPartZone Controls

Adding Web Parts to the Page

Customizing the Page

Creating Web Parts

Simple Web Part Tasks

Implementing the IWebPart Interface

Developing Advanced Web Parts

Before You Start: Creating Typed DataSets

The Custom WebPart’s Skeleton

Initializing the Web Part

Loading Data and Processing Events

The Final Rendering

More Customization Steps

Using the Web Part

Web Part Editors

Creating a Custom Editor

Connecting Web Parts

Defining the Communication Contract

Implementing the Provider Web Part

Creating the Consumer Web Part

Static Connections Between Web Parts

Dynamically Configuring Connection Points

Multiple Connection Points

Custom Verbs and Web Parts

User Controls and Advanced Web Parts

Uploading Web Parts Dynamically

Authorizing Web Parts

Final Tasks for Personalization

Clearing Personalization

Summary

CHAPTER 32 MVC

Choosing Between MVC and Web Forms

Creating a Basic MVC Application

Creating the Model

Creating the Controller

Creating the Index View

Testing the (Incomplete) Application

Completing the Controller and Views

Modifying the Site.Master File

Extending the Basic MVC Application

Configuring Routing

Adding Error Handling

Adding Authentication

Consolidating Data Store Access

Adding Support for Foreign Key Constraints

Customizing Views

Modifying the View

Adding View Data

Adding to the Model

Validating Data

Performing Basic Validation

Adding Validation Annotations

Using Action Results

Returning JSON Data

Calling Another Controller Method

Summary

CHAPTER 33 Dynamic Data

Creating a Dynamic Data Application

Creating the Dynamic Data Site

Exploring the Dynamic Data Site

Understanding the Anatomy of a Dynamic Data Project

Customizing a Dynamic Data Site

Customizing with Templates

Editing the Default Templates

Creating a Custom Page Template

Using Entity Templates

Customizing Field Templates

Customizing with Routes

Understanding Routes

Switching to Single-Page Editing

Using Different Templates for Tables

Customizing with Metadata

Creating a Metadata Class

Changing Display Names

Changing Visibility

Customizing Field Formatting

Using a Custom Field Template

Customizing Validation

Requiring a Field Value

Specifying a Valid Range

Customizing Validation Using Extensibility Methods

Summary

CHAPTER 34 Silverlight

Understanding Silverlight

Silverlight vs. Flash

Silverlight System Requirements

Creating a Silverlight Solution

Silverlight Compilation

The Entry Page

Creating a Silverlight Project

Designing a Silverlight Page

Understanding XAML

Setting Properties

The XAML Code-Behind

Handling Events

Browsing the Silverlight Class Libraries

Layout

The Canvas

Layering Elements in a Canvas

Dragging Circles

The Grid

Fine-Tuning Rows and Columns

Nesting Layout Containers

Spanning Rows and Columns

Animation

Animation Basics

Defining an Animation

The Animation Class

The Storyboard Class

Configuring Animation Properties

An Interactive Animation Example

Transforms

Using a Transform

Animating a Transform

Using Web Services with Silverlight

Creating the Web Service

Adding a Web Reference

Calling the Web Service

Configuring the Web Service URL

Cross-Domain Web Service Calls

Summary

Index