PowerWEB LiveControls for ASP.NET
AJAX Made Easy
You may have heard some of the buzz lately about client-side callback technologies
such as AJAX and XMLHTTP. These techniques are an efficient way to keep Web page
content current without requiring the page to continually post back. Postbacks are
slow and ugly, causing all page content to post back to the server, which must then
re-render the entire page and send the whole thing back to the browser, which then
redraws the entire page from scratch.
Conversely, lightweight client-side technologies like
prefix="ST1" ?>AJAX
and XMLHTTP send minimal amounts of data between the client and the server, and
allow the Web browser to only redraw the relevant controls, while leaving the rest
of the page untouched. This can create a much more graceful and enjoyable Web surfing
experience for your users.
PowerWEB LiveControls by Dart Communications uses such lightweight techniques to
extend the standard ASP.NET Web controls and make them far more efficient. It then
goes above and beyond with new controls that most Web developers wish they had.
Free Test Drive
Developer licenses are free, so go ahead and download the demo and try it out risk-free.
You only need to pay if you like the product enough to deploy it to your live site.
The installation is quick and easy. The set-up program goes beyond most, offering
to integrate its comprehensive help documentation with Visual Studio and to automatically
create the virtual directories needed to run the sample applications (see Figure
1). It would have been nice if the installation program automatically added the
controls to my Visual Studio.NET toolbox, but adding the controls manually only
took a minute or two.
Figure 1: The user-friendly installation offers to create the sample application
virtual directories automatically so you can get started quickly.
The sample applications are relevant, useful, and easy to understand. The sample
code (provided in both C# and VB.NET) is well written and suitably commented. Thanks
to the thorough set-up program, the sample applications ran immediately with no
tinkering necessary.
The controls are intuitive, with almost no learning curve necessary. In my first
experiment I dropped a LiveButton control and a LiveLabel control onto a form. In
the LiveButton’s server-side Click event I added a standard line of code to update
the LiveLabel’s Text property with the current date/time:
LiveLabel1.Text = Date.Now.ToString
I then ran the application; I clicked the button and saw the label immediately update
with the server’s current time without an ugly postback. It’s as simple as that
— the controls just work. You write normal code inside normal server-side events
and, generally, everything works just as you’d expect from standard Web controls,
except all the communication happens smoothly behind the scenes with client-side
callbacks.
When the server events are fired you can expect all forms of state to be fully hydrated,
including ViewState, Session, Application state, etc. As far as your server-side
code need be concerned, it can function as if the callback were a normal postback.
However, keep in mind that if you try to update a control other than a PowerWEB
LiveControl during a callback, that control’s user interface won’t be updated by
default because the page is not being re-rendered. (If you really want to be able
to update a non-PowerWEB control, there are a couple controls provided in the suite
that can wrap other Web controls to provide them with the benefits of client-side
callbacks.)
A Full Suite of Feature-rich Controls
There are more than 20 controls included in the LiveControls suite. Many of them
are simple extensions of the standard ASP.NET Web controls, and then there are some
extras that really sell the suite as a whole.
In addition to the LiveButton and LiveLabel controls mentioned previously, there
are also LiveImage (see Figure 2) and LiveImageButton controls that can update their
own images dynamically. This is a great way to provide a slick slideshow for users,
but the enhancements don’t stop there. Their interactivity approaches that of a
Windows Forms application. The LiveImage control (as well as most of the other controls)
have events such as MouseDown, MouseUp, MouseLeave, DoubleClick, and other kinds
of server-side events that Web developers have been deprived of for far too long.
The events are fired quickly and efficiently, so Web page response is snappy.
Figure 2: The LiveImage control can update itself via client-side callbacks
to provide slick slideshows that don’t interfere with the user’s Back button functionality.
There are other familiar controls that have equally impressive features, such as
the LiveCheckBox, LiveCheckBoxList, LiveRadioButton, LiveRadioButtonList, LiveDropDownList,
LiveListBox, LiveHyperLink, LiveLinkButton, LivePanel, etc.
The LiveTextBox control can stream keystrokes back to the server as they happen,
allowing you to make a back-up copy of the user’s data entry in case of a browser
crash or other unfortunate incident that might otherwise cause data loss.
The LiveDataGrid control allows a grid to page and sort itself without refreshing
the rest of the page. It also permits users to select, delete, and edit records
just as fluidly.
All of the controls in the suite share some common properties, such as the IsLive
and EnableCallback properties that permit the controls to do standard postbacks
in case you should ever yearn for the old days. They also provide a WaitMessage
property that can display a message in cases where a callback requires unusually
intensive processing. The WaitElementID property can specify a particular control
to display that message. The UpdateAll property allows other LiveControls to update
themselves too, whenever a callback occurs from any control. When set to False,
only the form element that caused the callback will participate in the callback.
There are also properties that allow callback errors to be handled in a variety
of customized ways, and an extended Font object that permits controls to change
their appearance dynamically.
Create Unique Solutions with Unique Controls
All the controls mentioned previously extend the standard ASP.NET Web controls in
useful and efficient ways, but what really sells the suite are the extra controls
that can’t be compared to any of those within the stock Visual Studio.NET Web controls
toolbox.
The LiveMessageBox control allows messages to be displayed dynamically, including
alerts, confirmations, and input boxes. The LiveMessageBox_Response event allows
the developer to collect and process the user’s response.
The LiveTimer control (see Figure 3) acts very much like a Windows Forms timer control.
After the specified number of milliseconds, a Timer event is sent to the server,
allowing processing to happen on a frequent and reliable basis. While I expect the
timer can’t be especially accurate when set to a small number of milliseconds, the
tiny and efficient callbacks can happen far more quickly (and therefore far more
often) than standard page postbacks ever could. One of the sample projects demonstrates
how this control can be used to create a progress bar that continually updates the
status of an ongoing server operation.
Figure 3: The LiveTimer control can call back to the server at regular
intervals so status bars and other page elements can be updated in real time. The
LiveSound control can be used to trigger audible alarms in the case of important
events that demand attention.
The LiveSound control allows audio to be played from within a Web page. These sounds
can be played dynamically in response to user actions or events occurring on the
server.
The LiveWrapper and LiveCallback controls provide a way to enhance other (non-PowerWEB)
controls to participate in callbacks too, so you can use callbacks easily with virtually
any Web control in existence.
Competition from ASP.NET 2.0?
If you are developing ASP.NET 1.x and you want to bless your users with the power
of client-side callbacks, the decision to use PowerWEB LiveControls for ASP.NET
is a no-brainer. Without this powerful cross-browser-compatible control suite, client-side
callbacks in ASP.NET 1.x are too complex to be feasible for most Web applications.
However, with these controls it becomes as simple as the code you already write
every day.
If you read my November 2005 ControlFreak article about the new client-side callback
capabilities of ASP.NET 2.0, then you know client-side callbacks are becoming more
feasible with standard Web controls than they used to be (see
ASP.NET 2.0 Callbacks). Of these new client-side callback capabilities,
they’re most easily used with the new TreeView and GridView controls because callback
features have been specifically built into these two controls. As for the other
controls of ASP.NET 2.0, well, it’s easier than it used to be to power them up with
client-side callbacks, but that’s not saying much. It still takes a moderate amount
of slightly convoluted code to make it happen. I wish all the primary controls of
ASP.NET 2.0 had callback technology built into them like the TreeView and GridView.
Coincidentally, that’s exactly what PowerWEB LiveControls provides, plus some very
enticing new controls, as well. So when it comes to comparing PowerWEB LiveControls
to the new client-side callback technology of ASP.NET 2.0, there’s really no competition.
Development licenses are free, a single-server license is US$499, and prices decrease
as you buy more server licenses. But when you think about it, can you really put
a price on happy users and effective developers? When you buy these high-quality
controls you’re purchasing a superior user experience for your Web sites along with
turbocharged development efficiency.
Rating:
ééééé
Web Site:
http://dart.com/powerweb/livecontrols.asp
Price: US$499
Review Date: 2005