Rob Cameron

Event-Based Programming

In this chapter, we explore the intricacies of working with server control events. The first part of this chapter is a general discussion of the .NET event architecture. We discuss how to add events to a control, bringing back our favorite Textbox control as part of the demonstration. Then we illustrate how to define custom events and add them to yet another version of our famous Textbox. We also examine System.Web.UI. Control’s support for maintaining events. Next, we show how to initiate and capture a postback using a Button control that we create named SuperButton. This section examines Command events and event bubbling with an example composite control to demonstrate these concepts. In the final portion of the chapter, we bring it all together with a discussion of the page life cycle, focusing on events. The next section provides an overview of events and ASP.NET controls.

Packaging and Deployment

This chapter is second in our two-part discussion of the Google control. In the previous chapter, we covered the design of each control, configuration management and, of course, the Google API and the design decisions that went into the control to interact with the Google API. In this chapter, we start off with a discussion of design-time support in the Google control and then jump into the packaging and deployment process with server controls using our Google control as an example control. We focus on the following topics for packaging and deploying server controls: Design-time support (data binding and templates) Testing the Google controls Licensing Implementing globalization and localization Using FxCop to check design decisions and coding conventions Using XML comments in code to generate documentation

Templates and Data Binding

The vast majority of web sites that provide dynamic content do so by rendering HTML that represents a data source to a database back-end system. A common task for web developers is to retrieve data and manually format it for output. To simplify this process, ASP.NET borrows the data-binding concept from the Visual Basic desktop world. Data binding dynamically merges a collection of data with a server control at runtime to produce HTML content representing the data source, as shown in Figure 7-1.

Developing Custom Server Controls

The previous chapter provided a high-level overview of the large number of prebuilt controls available in ASP.NET. These battle-tested components serve admirably in a variety of scenarios that web application designers can dream up. In addition, control builders can extend and enhance the capabilities of the components delivered out of the box through inheritance and encapsulation.

Integrating Client-Side Script

Software development, like any other engineering discipline, progresses toward an architecture resulting from a set of design decisions. There are trade-offs between competing issues such as browser compatibility versus display richness and the number of round-trips versus client-side computation, to name a couple. This chapter focuses on how these trade-offs come into play with respect to integrating client-side script into your ASP.NET server control development efforts.

User Interface Reuse

In this chapter, we highlight the challenges inherent to web application development and discuss the state of web development up to the release of Visual Studio .NET. Next, we compare ASP to ASP.NET, highlighting the advantages of ASP.NET and the modularity that ASP.NET server controls can provide in web development efforts.

Server Control Basics

In this chapter, we examine the basics of working with server controls. In order to create server controls, it is important to understand how they work. We start by reviewing what a server control provides to clients and we take a look at some of the prebuilt controls supplied by ASP.NET. At the start of this journey, we study the controls’ inheritance bloodlines, examining how the namespaces are organized to become familiar with what is available for immediate use in ASP.NET. Because inheritance and composition of existing controls are important timesaving control-building techniques available in ASP.NET, this rapid journey through the object model is well worth the effort.

Design-Time Support

Design-time support refers to working with server controls within the Visual Studio .NET development environment. Dragging controls onto the web page Component Designer surface from the Toolbox tool window, editing server control properties in the Properties tool window, and right-clicking a control to bring up a context menu are all examples of design-time support.

Building a Complex Control

At this point in the book we have covered all the major concepts in developing server controls. In this chapter and the next we bring these concepts together and develop a powerful custom server control from the ground up to illustrate the techniques put forth in this book. This server control programmatically interacts with the Google Web APIs to provide a nice package that can be dropped into an ASP.NET application to provide search functionality. We hope that it provides a useful example and framework for building your own custom server controls and serves as a useful addition to your server control toolkit.

Customizing and Implementing Mobile Controls

ASP.NET mobile server controls provide a rich, extensible framework for delivering content viewable on a wide array of mobile devices. In the previous chapter, we looked at out-of-the-box controls and the feature set available in.NET Framework version 1.1 as a means to examine mobile server control technology. In this chapter, we drill down into extensibility and customization mechanisms available to mobile server control developers. The extensibility hooks fall into the following categories: The StyleSheet control Templates Device-specific UI choices User controls Custom controls Device adapters