This is a book for one who is currently using ASP.NET 1.0 and moving on to 2.0. It is all about the differences, new features, and changes in use. It goes directly into code examples, Web page control use, and operational deployment. If the reader is starting from scratch, or not familiar with ASP.NET 1.0, Onion and Brown suggest beginning with Onion’s first book [1], or perhaps another book directed more toward the novice. Certainly, the user must be familiar with ordinary Hypertext Markup Language (HTML), basic cascading style sheets (CSS), and the basics of client-server interoperation.

I found it refreshing that this book dived directly into useful examples of HTML and C# code, while also recognizing that this isn’t for everybody. A Visual Basic (VB) or Java programmer, or one starting from a Tomcat background or non-ASP approach, will have a harder time synching up.

Diving into chapter 1, the reader is exposed to the architecture, the fundamentals of client side and server side (what happens where), how controls are formed and set up on the server side, and the life cycle of the page. The writing style is crisp and friendly, focusing on the changes in 2.0. I was able to find out how a lot of things worked, things that I assumed I knew (from learning by trial-and-error or just Google surfing). The ASP.NET 2.0 features of site compilation and Web management are sophisticated and advanced.

The chapter on user interface is about new features built into ASP.NET 2.0 (which might have previously been hand-crafted or third-party features). Master pages, laying out standardized navigation, menus, headers, and footers are now tightly integrated. Themes and skins are applied within the system, instead of added on. These features come from capabilities that were first used to support the tiny and varying browsers on mobile devices. They have now grown into the full product, allowing it to support the full range of commercial browsers.

Data binding has changed greatly too. The most significant change is the switch to declarative coding as a means to express table and hierarchical data bindings. Though the prior imperative (code-driven) data binding features still exist, the increased coupling by declarative specification should lead to significant reduction of code, as well as enhanced maintainability (faster development time). Though it was always possible with direct coding, it is now common to see structured query language (SQL) embedded in .aspx pages. The hierarchical binding is new, and discussed with a tree view control. In my work, I’ve found it necessary to use third-party tree grids (where the rows can open up and expand). Consequently, this will be a useful feature.

State management is divided into four topics, though somewhat strained. Cross-page posting, which can utilize state management techniques, Wizard controls, and MultiView controls appear in this chapter, perhaps because before these features existed, the user was faced with homemade equivalents that relied on state management. Profile data (a persistent form of session data) is clearly introduced through examples, including the serialization of a shopping cart item.

A chapter on security, login, and integration with SQL and custom providers is written in a different, more tutorial, and explanatory style. The introduction notes that this section, and the diagnostics chapters, were written by the coauthor. I appreciated this section, as security has always been somewhat of a mystery to me.

In a sense, the security topic acts as a buffer between the ordinary issues of ASP.NET page development and a totally different issue, portals and Web parts. More of an architectural than technological change, it’s the style by which users can manage zones, panels, and areas on screen real estate (by using new ASP.NET 2.0 features and building blocks). This chapter returns to the style of using interspersed code examples and crisp prose. There’s a good ratio of hands-on code, step-by-step description, and architectural guidance (such as how the personalization, at a user level, integrates with shared scope for many classes of users).

“Diagnostics” returns to Brown’s tutorial style. As with a live training, where different personalities trade off podium time, it is refreshing to have this topic presented with a different flavor and spin. Here, the user learns about the health monitoring side of system features. The tracing and diagnostic features, for debugging and tracking down issues, are also discussed.

Performance focuses on caching (at the data source), SQL interaction, and output caching. Then, a great topic is included at the end of this chapter: client callbacks for asynchronous Javascript and Extensible Markup Language (XML) (Ajax), and methods of obtaining client information without posting a Web page to the server. This is just a threadbare introduction to Ajax; what I didn’t find was what I’m used to doing on the Javascript side, which is third-party controls, downloaded shareware, and bought functions. I realize these may be off topic for the new user of ASP.NET, but I’ve found a great deal of client focused things that get done in Javascript, particularly, responding to buttons and actions without posting a form to the server. Another example is when parts of a Web page can be updated by direct server interaction (without posting) via asynchronous connection (often by .aspx on load coding that generates XML refresh of sub-page control areas).

There is a wonderful world of third-party controls, many supporting both client-side Javascript and ASP.NET server integration by asynchronous calls. These have both been a big part of my recent Web development life. With the start of Microsoft Silverlight, what was once obscure Javascript has now become robust declarative-style coding, with compiled speed and robust client-side code. Developers who have the background for this book, from the perspective of ASP.NET 1.0 to 2.0 differences, may also have the sophistication necessary for pointers to these other features.

The book ends with a chapter on asynchrony, not from the Ajax acronym but referring to the server-side threads created with server requests. Web pages that combine information from sources, which might have latency (SQL processes, SOAP, or other remote Web services), allow the parts to proceed in parallel, and be synchronized in the page life cycle.

In summary, this is a well-written book by two knowledgeable and communicative authors, each writing with his own personality and style. I highly recommend it to the reader who already knows something about ASP.NET, from experience or from Onion’s first book. In any case, the reader must be ready for a no-nonsense, code-driven launch into ASP.NET 2.0.