Hello ASP / DCOM experts -

I'm designing my first HTML/ASP/MTS/SQL Server application, though I've read
just enough on the subject to be dangerous. I've come up with a general
design, and would appreciate critiques from experienced developers. I
expect this to appear pretty ridiculous to the experienced among you, but I
hope this design will be useful as a straw-man for you guys to take whacks
at.

My goal was to come up with a generic web editing pattern that has the
following characteristics:

- Allows the user to edit data freely in an HTML grid
- Handles concurrency in a "batch-optimistic" way
- Minimizes network traffic between web server and DB server
- Minimizes state on the web server
- Relatively browser-neutral

Before I describe any further, Here are some files that document what I've
come up with:

A pidgin-UML sequence diagram illustrating interaction between tiers,
important objects, and data stores:

http://www.twilight-systems.com/webedit/webedit.gif

A discussion of the preceding diagram (and the RecSetPersist object):

http://www.twilight-systems.com/webedit/webedit.htm

A discussion of the "HTMLGrid" object in the diagram:

http://www.twilight-systems.com/webedit/HTMLGrid.htm

In brief, here is how I tried to reach the objectives I outlined earlier:

To allow the user to edit data freely in a grid, I plan to implement an
HTMLGrid object, which accepts a recordset and returns it as HTML form
elements embedded in an HTML table. The table definition and formatting
information will be predefined and stored in a database on the web server.

To handle concurrency, I plan to use a timestamp column ("LastUpdate") on
each row in the recordset. If, upon updating, this value has changed since
it was fetched, the update will not be allowed to continue (since it means
someone else has fetched, modified, and saved the same record in the
meantime).

To minimize network traffic between web server and DB server, I want to
store a "pre-image" of the recordset on the web server before it is edited
by the user. When the user submits the data to be saved, it is compared
against the pre-image, and a third recordset is created - containing only
records that have been changed - and this recordset is returned to the DB
server for update. (I had intended to use ADO's native ability to track
edits but have been warned off this due to performance reasons...?).

To minimize state on the web server, I've designed a "RecSetPersist" object.
This object allows ASP to "check in" a recordset, which is saved to disk as
a file, and then "check out" the recordset again at a later time. This
would be used to save the "pre-image" recordset described in the previous
paragraph without having to retain it in memory.

To keep this whole process browser-neutral, the only thing that gets sent to
the browser is the HTML table with form elements embedded in the table
cells.

That's the basic idea. I would love some constructive criticism.

Thanks very much for your replies!