Review: Building An ASP.NET Intranet
 
Published: 07 Oct 2003
Unedited - Community Contributed
Abstract
A brief review of the Wrox book, Building An ASP.NET Intranet.
by J. Ambrose Little
Feedback
Average Rating: This article has not yet been rated.
Views (Total / Last 10 Days): 21491/ 56

Initial Reaction

Originally Published: 4 February 2003

When I first began reading this book, a feeling of intense disappointment whelmed me. I was only familiar with it by its title, and, since I have been developing ASP.NET applications for a corporate intranet for over a year now, I was looking forward to discovering what other experts are doing in similar environments.

This feeling remained with me until I reached the seventh chapter, at which point my spirits were raised by a useful application that could easily be abstracted out of the IBuySpy Portal framework. In fact, this chapter and the subsequent two that conclude the tome redeem it by providing content that is both useful and usable for companies without the option of beginning with a blank slate for their intranets.

The book’s primary fault is that it starts from the somewhat naïve assumption that we developers have the luxury of starting with a tabula rasa. One would be hard-pressed to find a company having no existing intranet architecture to build upon or one willing to scrap the existing one in favor of developing an entirely new architecture based on a demo product.

This fault is compounded by the book’s overly copious amounts of code examples from the IBuySpy Portal, including many very basic snippets such as nearly-identical data and business tiers for various modules. In fact, it is not until Chapter Seven that the authors break away from the Portal mold and the book’s tedious methodology.

Up to that point, there are details as mundane as how to install the Portal and a gruelingly detailed inspection of the Portal itself and some directions and examples of how to modify it in simple ways. As far as I am concerned, the book up to this point could be scrapped into an MSDN article called Understanding and Extending the IBuySpy Portal.

 

Something to Write Home About

With Chapter Seven begins the meat of the book. Though I would not recommend developing a from-scratch content management system today without compelling reasons, considering the number of options in that category available today, it is nonetheless an essential component of any corporate intranet.

The author begins by going over the major elements of a typical content management system. Unfortunately, there is at least one major component missing from this list that has been necessary in most content management systems I have come into contact with—workflow, multiple levels of approval. In fact, there is no workflow in this system at all, neither recommended nor demonstrated.

On the other hand, the author’s method of creating and implementing the rich text editor in the system brings out one of the most useful features for any ASP.NET intranet—web custom controls. His mercy in sparing the reader a walkthrough of every stored procedure, method, and page was much appreciated. And other than a user interface that is a bit cluttered with too many wordy links for each item, some of which could have been eliminated by the use of tiny meaningful images and standard linking practices (i.e., linking from the title and not having a separate ‘Read’ link) and poor error handling, this chapter was a welcome stimulus after the plain-thinking chapters preceding it.

Following on the seventh chapter’s legacy, Chapter Eight presents what is probably the most useful and usable example in the book. Though the document management system proposed certainly has its share of limitations, it is nonetheless a great starting point for an intranet document management system. All three tiers make use of great practices in storage and retrieval of binary information, and the UI is both simple and pleasant.

My only qualm about this chapter is its brevity, that is, it attempts to cover too much in tool little space. Several chapters could justifiably have been devoted to it, and it suffers by moving too quickly and too sparingly over the code. Either removing most of the code and simply discussing it at a high level or providing the user a higher level overview would have been more beneficial. In any case, the system merits investigation at a depth that could likely only be provided by looking at the code itself.

The last chapter provides us with an in-depth review of an example employee information system. In itself, it is more valuable than the first six or so in that it again provides us with an application that is not simply a minor extension of the Portal framework (and thus could easily be modified to be used apart from it), and it is, as the author points out, an integral part of a corporate intranet.

On the other hand, it seems unlikely that a company would not have such an application in place, and seeing as such an application could be easily and likely extended to provide a central repository for each employee’s information that can be used in other intranet applications, it seems unlikely that it could be replaced without much cost to the company. In addition, the demo is tremendously lacking in auditing. Given the sensitive nature of this information, a detailed audit system including easy rollback would be essential.

Along with that, I would expect a more flexible security paradigm would likely be needed for this as well as the other applications presented in this book (including the Portal itself). Beyond that, the application uses a rather stunning amalgam of technologies and ASP.NET functionality, but the author belabors the point by providing a tiny primer on each that seems a bit too elementary for anyone but a beginning developer and a bit off topic for the book.

Finally, the book concludes with an appendix describing the WROX database access wrapper class used throughout the examples. There are two things of note about this. First, the author makes the case that providing such a class for an application keeps the users from needing to ‘reinvent the wheel’, but the keystrokes saved by this class are not impressive and it adds a learning curve to any developer coming on to the project and could, if a developer used it exclusively, cause the developer’s expertise with the built-in ADO.NET data objects to wane.

Second, the suppression of all exceptions in the class, requiring a return value to inform the calling class of the exception and the necessity checking of various properties to retrieve exception information when they occur is a considerable step backwards, particularly for VB developers who are finally getting the error handling functionality they deserve with VB.NET’s try-catch blocks. I must acknowledge that the author recognizes this with an altruistic statement about everyone always needing to review and improve their code.

 

Bottom Line

Overall, I would not recommend this book to intranet developers unless their company has the luxury to start from square one or to trash existing systems as desired. This book sorely lacks in a critical area of intranet development, which is integration with existing systems, particularly poignant when introducing a new technology like ASP.NET. I would recommend, however, procuring a copy of at least the document management system, if not the CMS and employee information system as well. The book may serve as a somewhat helpful accompaniment to this code, but the code itself, if used, would easily pay for the price of the book.


User Comments

No comments posted yet.

Product Spotlight
Product Spotlight 





Community Advice: ASP | SQL | XML | Regular Expressions | Windows


©Copyright 1998-2019 ASPAlliance.com  |  Page Processed at 2019-04-23 10:25:56 PM  AspAlliance Recent Articles RSS Feed
About ASPAlliance | Newsgroups | Advertise | Authors | Email Lists | Feedback | Link To Us | Privacy | Search