Before embarking on the inevitable—and not painless—migration to ASP+, it's best to know what
compatibility issues you'll have to deal with
by Chris Kinsman
Microsoft is set to release an exciting upgrade to ASP later in 2000. This is a major upgrade unlike the
minor changes from ASP 2.0 to 3.0. Unlike past upgrades, however, this one will not be painless. When they
designed ASP+, Microsoft had to make the hard decision occasionally to break backward compatibility in the
interest of improved functionality and features.
What you need:
ASP+ PDC Preview
At the Professional Developer Conference 2000 ASP+ Development Lead Scott Guthrie mentioned that Microsoft
was guided by the idea that "There is more Internet time ahead of us than behind us." As an ASP developer
with hundreds of thousands of lines of code directly affected by this, I am worried. At the same time, I
sincerely feel that they made the right decision.
Compatibility Issues
What does Microsoft's decision about selective backwards-compatibility mean for you? At the most basic it
means that migrating will require work. All but the most simple pages will likely require changes before
they will run correctly under ASP+. Microsoft has made available a migration path from ASP to ASP+. Both
ASP and ASP+ will run side by side on the same server without interacting. This means that your ASP
applications will continue to run—albeit without taking advantage of new ASP+ functionality—while you
are developing your new ASP+ pages. No modifications have been made to asp.dll, and nothing should break
by installing ASP+.
This side-by-side operability is accomplished by using separate filename extensions for ASP and ASP+. All
ASP+ filename extensions that I have seen so far end in an x (for example, .aspx, .asmx, etc.). The only
exception would be new pagelets (miniature ASP+ pages—more about them later) that use the .aspc
extension. This means that migration will typically entail copying an .asp file to an .aspx file, testing
it, fixing the problems, and then deploying it by relinking the rest of the site to the file with the new
extension.
Microsoft has mentioned that by the time the product ships they hope to have a conversion tool ready which
will point out incompatibilities and, in some instances, fix them for you. This won't fix all
incompatibilities but it will cover the majority. Compatibility issues come in three broad categories: API
changes, semantic changes, and language changes.
API Changes: The first set of compatibility issues arise around changes to the core ASP objects. All of
the arrays are now 0 index based. In the previous versions some arrays were 1 based and others were 0
based. For consistency, all now use a 0 base.
The second change has to do with the return types of certain objects. In ASP, Request,
Request.QueryString, and Request.Form return different results based on what is in them. If I access a
page with the following Url—http://localhost/apichanges.asp?Language=VB&Language=C#—and it contains the
following code:
1
2' Writes out: VB, C#
3Response.Write Request.QueryString("Language")
4
5' Writes out: VB
6Response.Write Request.QueryString("Language")(1)
then depending on the way I invoke Request.QueryString, I will get differing results. One would have
thought that the first invocation would return a string array, as opposed to a CSV string. ASP+ has
changed this model. Now to get the individual items you must call an explicit method to get access to the
items. Using the same URL as above, the following ASP+ code will provide the same functionality:
1
2' Writes out: VB, C#
3Response.Write(Request.QueryString("Language"))
4
5' Writes out: VB
6Response.Write(Request.QueryString.GetValues("Language")(0))
The most common places you are going to find code like the preceding—which requires updating—is in
places where you have multiple select listboxes, multiple radio buttons or checkboxes with the same name,
and multiple submit buttons.
There isn't really much that you can do when writing code to prepare for this change except potentially
wrap control access with your own subroutines so that you can centralize the fixes for the API change.
Although changes in the intrinsic objects are easily fixed in ASP pages using script code, what about
compiled COM components for which you don't have the source? As it turns out, if your COM components use
GetObjectContext to gain access to the intrinsic ASP objects, ASP+ will return to them a copy of the
intrinsic ASP objects compatible with ASP. This support is not in the PDC build of ASP+ but will be
forthcoming in future builds. That being said, using compiled Visual Basic 6 objects yields a performance
penalty in ASP+ of 10 to 15 percent. This is due to the increased cost of marshalling data between managed
and unmanaged code as well as threading issues due to ASP+ switching to an MTA thread pool. For the long
term this means that you are going to want to rewrite your components using managed code.
--------------------------------------------------------------------------------------------------------
ASP to ASP+ Migration (cont'd)
Semantic Changes: ASP+ also introduces several changes to the basic semantics of the page. From a
compatibility and migration standpoint, the most important ones boil down to three:
Only one language per page
Functions must be in script blocks
Render functions are not supported
ASP allowed you to mix more than one scripting language per page. You could write one function in
JavaScript, another in VBScript, and use them interchangeably on the same page. ASP+ has eliminated this
capability. In ASP+ only one language is allowed per page. This doesn't mean you can't have client-side
JavaScript and server-side Visual Basic in the same page. If you really must mix server-side languages in
a single page, check out the new pagelets capability. Pagelets are miniature ASP+ pages that can be
embedded in other pages. This allows you to use JavaScript in a pagelet and Visual Basic in the page that
embeds it. The main reason for this change is the move from scripted languages to compiled languages. With
a common scripting engine runtime it was relatively easy for multiple interpreted scripting languages to
share the same symbol table and coexist on a page. With ASP+ all code is compiled into a class that
represents the page. Two different languages would require two different compiles with two different
outputs and two different symbol tables.
In addition, functions must be placed inside of script blocks. I suspect this is also due to the move from
scripting languages to compiled languages, but I don't know the exact technical reasons. What it means to
developers is that instead of:
1
2Function MyFunc()
3
4
5End Function
you must now write like this:
1<script language="VB" runat="server">
2Function MyFunc()
3
4End Function
5</script>
This isn't a big deal, but it's a change that you must make nonetheless.
Tip: Start placing your functions and subroutines into script blocks today to make the migration easier
later on.
Render functions are really a specialized form of the fact that functions must be declared in script
blocks. As a side-effect of the way scripting was implemented, it was possible to write functions like
this:
1
2Function DrawTable()
1<table>
2<tr>
3<td>
Response.Write "Hello World"
1</td>
2</tr>
3</table>
1
2End Function
This code fragment uses the ASP ```
1chunks of HTML as though they had been emitted using Response.Write and inserts them into the calling
2page. Now that functions must be enclosed in script blocks there isn't an easy way to do escape embedded
3HTML and the above must be changed to look like this:
1VB Language Changes: The final category of compatibility issues doesn't really deal with ASP itself but
2with the languages it uses. ASP+ no longer uses scripting languages. If you previously used VBScript, all
3that code will be executed using the Visual Basic compiler. Visual Basic itself has had several
4significant changes in this revision and therefore creates additional compatibility issues. There are four
5known issues at this point, although additional ones may crop up as Visual Basic continues to change
6during development:
7Visual Basic no longer has default properties. You must now fully qualify all non-indexed properties to
8identify which property you want. Instead of writing "rsData("Name")" you must write "rsData
9("Name").Value."
10Tip: Prepare for this now by always explicitly specifying the property you want and not relying on the
11default property.
12
13Visual Basic no longer has both a set and a let. Set was originally introduced in Visual Basic 4 to
14differentiate between value assignments and object assignments. Some objects in Visual Basic 4 would
15return either an object or a string. The ActiveConnection property of an ADO command object is an example
16of this. Because of this dual nature, Set was needed to indicate an object assignment and Let was used to
17indicate the string assignment. With the elimination of default properties, however, this is no longer an
18issue. Instead of writing:
19Set cn = Server.CreateObject("ADODB.Connection")
20you can now write:
21cn = Server.CreateObject("ADODB.Connection")
22
23
24Visual Basic now requires parentheses around all subroutine calls. In previous versions of Visual Basic
25they could be used with a single argument but could not be used with more than one argument unless you
26used the Call keyword. In my code this is going to be the one that requires the most cleanup. The common
27case will be the use of Response.Write. Where I previously used it like this:
28Response.Write "Test: " & iCount
29it will now have to be called like this:
30Response.Write("Test: " & iCount)
31
32
33The way arguments are passed to subroutines and functions has changed from VBScript to Visual Basic. In
34VBScript arguments were passed ByRef by default. With Visual Basic arguments are passed ByVal by default.
35Tip: If you rely on the passing of arguments ByRef, explicitly include the keyword in your code to make
36your code more portable to ASP+.
37Performance Considerations
38Although this is not strictly a migration issue, ASP+ developers will see significant performance
39increases when porting their ASP code if they move all of their variable instances from loosely typed
40variants to strongly typed data types. This one change alone can yield significant performance increases.
41Additionally, rewriting existing COM components as managed code will eliminate many performance penalties
42due to marshalling and threading.
43In summary, ASP+ offers some very cool new features but they aren't entirely free. Migrating from ASP to
44ASP+ will require some work. However, careful attention to the aforementioned issues today will mean that
45your code ports much easier once ASP+ ships.
46
47
48Chris Kinsman is Vice President of Technology at DevX.com. He is reponsible for the site architecture,
49development, and day-to-day maintenance of the DevX network of sites.
50
51
52ASP to ASP+ Migration (cont'd)
53
54
55
56Semantic Changes: ASP+ also introduces several changes to the basic semantics of the page. From a
57compatibility and migration standpoint, the most important ones boil down to three:
58Only one language per page
59
60Functions must be in script blocks
61
62Render functions are not supported
63ASP allowed you to mix more than one scripting language per page. You could write one function in
64JavaScript, another in VBScript, and use them interchangeably on the same page. ASP+ has eliminated this
65capability. In ASP+ only one language is allowed per page. This doesn't mean you can't have client-side
66JavaScript and server-side Visual Basic in the same page. If you really must mix server-side languages in
67a single page, check out the new pagelets capability. Pagelets are miniature ASP+ pages that can be
68embedded in other pages. This allows you to use JavaScript in a pagelet and Visual Basic in the page that
69embeds it. The main reason for this change is the move from scripted languages to compiled languages. With
70a common scripting engine runtime it was relatively easy for multiple interpreted scripting languages to
71share the same symbol table and coexist on a page. With ASP+ all code is compiled into a class that
72represents the page. Two different languages would require two different compiles with two different
73outputs and two different symbol tables.
74In addition, functions must be placed inside of script blocks. I suspect this is also due to the move from
75scripting languages to compiled languages, but I don't know the exact technical reasons. What it means to
76developers is that instead of:
77
Function MyFunc()
End Function
1you must now write like this:
1This isn't a big deal, but it's a change that you must make nonetheless.
2Tip: Start placing your functions and subroutines into script blocks today to make the migration easier
3later on.
4
5Render functions are really a specialized form of the fact that functions must be declared in script
6blocks. As a side-effect of the way scripting was implemented, it was possible to write functions like
7this:
8
Function DrawTable()
|
```
Response.Write "Hello World" This code fragment uses the ASP ```
comments powered by Disqus
|