Pro ASP.NET 4 CMS - Advanced Techniques for C# Developers Using the .NET 4 Framework

Title Page

Copyright Page

Contents at a Glance

Table of Contents

About the Author

About the Technical Reviewer

Acknowledgments

Introduction

About This Book

What You Need to Use This Book

Code Samples

Feedback

CHAPTER 1 Visual Studio 2010 and .NET 4

Who This Book Is For

Who This Book Is Not For (or “Buy Me Now, Read Me Later”)

What’s New in .NET 4

C# Optional and Named Parameters

C#’s dynamic Keyword

Dynamic and Functional Language Support

Parallel Processing

Parallel LINQ (PLINQ)

Task Parallel Library (TPL)

Axum

Managed Extensibility Framework (MEF)

Distributed Caching with Velocity

ASP.NET MVC

A Tour of Visual Studio 2010

Windows Presentation Foundation

Historical Debugging

Improved JavaScript IntelliSense

jQuery Support

Building a CMS

CMS Functional Requirements

Creating the Application Framework

Summary

CHAPTER 2 CMS Architecture and Development

Motivations for Building a CMS

Motivations for Using .NET

Application Architecture

The CMS Application Tiers

CommonLibrary: The Data Transfer Objects

GlobalModule: The HttpModule

Components of a CMS Page

Buckets

Embeddable Objects

Embeddable Permissions

Handling CMS Content

The Content Table

The ContentVersion Table

Assembling Content on Demand

How Embeddable Objects Handle Versions

Summary

CHAPTER 3 Parallelization

What Is Parallelization?

Good Parallelization Candidates

Differences from Multithreading

Parallel Pitfalls

Deadlocks

Race Conditions

Thread Starvation

Amdahl’s Law

.NET 4 Parallelization Concepts

Task vs. Data Parallelism

Task Parallel Library

Task.Wait()

Parallel.For() and Parallel.ForEach()

Parallel LINQ (aka PLINQ)

.AsParallel()

CMS Parallelization Opportunities

Creating a Data Mining Embeddable

Expanding the Data Mining Tasks

Tagging

Tagging on the Client

Fleshing Out the Tagging Embeddable

What’s in a Name?

Handling Tag Input

Tag Processing in the Business Tier

POST Problems

Finalizing Tag Storage

Content Tags

Summary

CHAPTER 4 Managed Extensibility Framework and the Dynamic Language Runtime

Managed Extensibility Framework

The Manual Way

The MEF Way

Working from Usage to Implementation

Exposing Libraries via MEF

A Simple Plug-in Contract

Implementing the Plug-In

Using the Plug-In

Catalogs and Containers

Supporting Multiple Parts

Dynamic Language Runtime

The dynamic Keyword

Benefits of the dynamic Keyword

CMS Plug-Ins

IEmbeddable

Server Controls as Embeddables

Displaying Embeddables

PageAssembler

Additional Methodology Benefits

Missing DLLs

Exceptions in Embeddables

A More Complex Emeddable

Breadcrumbs

Navigating the CMS Tree

Summary

CHAPTER 5 jQuery and Ajax in the Presentation Tier

An Introduction to jQuery

The $() Factory

Implicit Iteration

Ajax via jQuery

Caching and Ajax

Avoiding Caching on GET Requests

Lightweight Content Delivery with Ajax and HTTP Handlers

Handling Asynchronous Errors

Handling DOM Modifications

Improving the CMS Admin with jQuery

Creating Collapsible Panels

Expanding with jQuery

Displaying the JavaScript Disabled Message

Poka-Yoke Devices

Summary

CHAPTER 6 Distributed Caching via Memcached

What Is a Distributed Cache, and Why Is it Important?

Memcached

Acquiring a Memcached Client Library

Getting Started with Memcached

Using the Client Libraries Directly

Writing a Memcached Library

Testing the Library

Deleting Objects from the Cache

Complex Object Types

Protocol Considerations

Memcached Internals and Monitoring

Building a Cache-Friendly Site Tree

Visualizing the Tree

Defining a Node

Defining the Tree

Finding Nodes

Inserting Nodes

Serializing/Deserializing the Tree for Memcached Storage

Memcached Configuration Considerations

Summary

CHAPTER 7 Scripting via IronPython

How Does the CMS Benefit from Scripting Capabilities?

Easier Debugging

Rapid Prototyping

An Introduction to IronPython and Its Syntax

What Is IronPython?

Installing IronPython

The IronPython Type System

Creating Classes and Controlling Scope

Constructors as Magic Methods

self

Exception Handling

Conditional Logic, Iterators, and Collections

Accessors and Mutators

Assembly Compilation

Compiling IronPython Code to a DLL

Compiling IronPython Code to an Executable

Building Scripting Capabilities into the CMS

Handling Script Files Between Tiers

Calling Scripts for a CMS Page

A Simple Scripting Example

Summary

CHAPTER 8 Performance Tuning, Configuration, and Debugging

The CMS Definition of Performance

Latency

Throughput

Establishing Baselines

Component vs. System Baselines

The Web Capacity Analysis Tool

Installing WCAT

WCAT Concepts

Configurations

Scenarios

Running a WCAT Test Against the CMS

Interpreting Performance Results

Improving CMS Performance with Caching

HTTP.sys and the OutputCache

Benchmarking CMS Performance

Configuration Considerations

Enable Release Mode for Production

Removing the Server, X-Powered-By, and X-AspNet-VersionHeaders

Debugging Concepts

White-Box vs. Black-Box Debuggers

User Mode vs. Kernel Mode

Historical Debugging via IntelliTrace

Collaborative Debugging

Importing and Exporting Breakpoints

DataTip Pinning and Annotation

Summary

CHAPTER 9 Search Engine Optimization and Accessibility

An Introduction to Search Engine Optimization

Science or Dark Art?

General Guidelines

Establishing Clear Markup

HTML Metadata the .NET 4 Way

Graceful JavaScript Degradation

Providing alt Text for Images

Color Scheme Sensitivity

Friendly URLs

Data Requirements for Friendly URLs

Stored Procedures for Friendly URLs

Exploiting the Page Life Cycle

Request Exclusion

Retrieving Friendly URLs

Retrieving Alias URLs and Response.RedirectPermanent()

Summary

Index