Review: Building An ASP.NET Intranet
page 2 of 3
by J. Ambrose Little
Average Rating: This article has not yet been rated.
Views (Total / Last 10 Days): 18227/ 48

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.


View Entire Article

User Comments

No comments posted yet.

Product Spotlight
Product Spotlight 

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

©Copyright 1998-2024  |  Page Processed at 2024-05-29 10:06:34 AM  AspAlliance Recent Articles RSS Feed
About ASPAlliance | Newsgroups | Advertise | Authors | Email Lists | Feedback | Link To Us | Privacy | Search