ASP (Active Server Page)/ASP.Net/ADO.Net Information

General Tech

MapInfo / GIS

Oracle / Database

Misc / Useless

ASP/ASP.Net/ADO.Net/
Visual Basic for Applications (VBA) Information

ADO.Net Best Practices

Use the System.Data.SqlClient Namespace - gives you better performance than the other providers, is on average 10 times faster than the OLEDB Managed Provider accessing the same data source. Connect like conn = New SqlConnection("User ID=sa;Password=;Database=NorthWind;Server=server1;Connect Timeout=15;Workstation ID=workstation1;Packet Size=8192;Pooling=True;Min Pool Size=1;Max Pool Size=10") instead of "Provider=SQLOLEDB.1;User ID=sa;Initial Catalog=Northwind;Data Source=NYKMALAP-XP\VSdotNET;Packet Size=4096;Workstation ID=NYKMALAP-XP"
Use the SqlTypes Namespace - helps prevent type-conversion errors and can control the conversion process and avoid overhead

Take Advantage of Connection Pooling (set of connections maintained by ADO.Net) - info:
- connection string must match exactly, User ID (UID) or password (if you specify Integrated Security=SSPI in the ConnectionString, you get one pool for your process's User Account), process identifier (PID), and transaction scope - won't work if specific user info is in the connection string
- pooling property of connection string is set to true by default
- if the pool fills up with connections the .NET Data Provider waits for another instance of the application to close an existing connection - if the .NET Data Provider can't get a connection in time (i.e., within the limit that the Connection Timeout setting specifies), it throws a System.InvalidOperationException with the message Timeout expired. "The timeout period elapsed prior to obtaining a connection from the pool. This may have occurred because all pooled connections were in use and max pool size was reached can increase the value of the Connection Timeout connection-string argument or the Connection object's ConnectionTimeout property" - instead can have error handler that can retry the connection possibly after asking the customer to be patient while your application deals with other requests (or is busy working on their requests). In all cases, you should log these failures to help diagnose what's going wrong and document that you've run out of resource
- if you shut down the SQL Server system (or your database management system�DBMS) or it shuts down on its own, any existing SqlClient connection pools remain unless IIS or MTS shuts down, too. These remaining pools are called zombied pools. If you subsequently restart SQL Server, the SqlClient .NET Data Provider tries to use the zombied pools to reconnect to the server. The result is the System.Data.SqlClient.SqlException General network error. Check your network documentation. Fortunately, this exception destroys the zombied pools, and when the component restarts, the SqlClient .NET Data Provider creates a new pool. However you should add an exception handler to deal with this contingency.
- the default number of connections a pool can handle is 100; you can set a higher number, but when the number of connections within the pool reaches this value, the .NET Data Provider won't create more pooled connections, so 100 connections per pool is more than enough.
- if some components are likely to compete for connections in a heavily used pool, it's a good idea to separate those components by creating two or more pools � one for each functional operation. One way to establish this separation is to set the application name in the ConnectionString to a unique value for each pool you want the .NET Data Provider to create.
- when the Web site is under heavy use, a good strategy for making sure you have enough connections is to open each connection just before you need it and close it as soon as you can�the just-in-time (JIT) strategy. ADO.NET can help in this because it opens connections automatically when you use the DataSet Fill or Update method. If you're using a DataReader, you have to open and close the connection yourself If you don't close the SqlConnection your code "leaks" a connection with each operation, so the pool accumulates connections and eventually overflows. None of the .NET languages can guarantee your connection will close when a Connection object (such as SqlConnection) falls out of scope, you still have to close the DataReader to get the associated connection to close. If you bind to a complex bound control such as the DataGrid, the control closes the DataReader and the connection, but only if you've set the CommandBehavior.CloseConnection option. If you execute a query by using another Execute method (e.g., ExecuteScalar, ExecuteNonQuery, ExecuteXMLReader), you are responsible for opening the SqlConnection object and, more importantly, closing it when the query finishes Looping through a DataReader result set to the end of its rowset - when the DataReader's Read method returns false isn't enough to trigger automatic connection closing
- the Max Pool Size doesn't limit the number of pools you can create � that limit is determined by the number of SQL Server connections that your sa setting or license makes available (about 32,768 per cluster).
- the Min Pool value can help connection performance for an application that doesn't run often but can't wait for the .NET Data Provider to construct a new SqlConnection object and establish a connection. You can also use this technique as a way to reserve connections.
- after close a connection in code, ADO.NET notifies the connection pooler to release the connection back to the pool, and after a time a connection-pool routine closes the database connection. Generally the connection-pool mechanism uses a random connection lifetime of between 4 and 7 minutes 40 seconds. After you close the ADO.NET Connection object, connections remain open for the randomly selected period of time after your application releases them. The .NET Data Provider calculates the pool lifetime starting from the time the pooled connection was created. The Connection Lifetime ConnectionString keyword isn't what it appears to be. Microsoft included this option to handle a very special circumstance (when using clustered servers). Connection Lifetime helps release connections more quickly when several SQL Servers are working in a cluster. In nonclustered systems, the argument has no bearing on how long the connection remains in the pool.
- to monitor the pool can run sp_who or sp_who2 which return information from the sysprocesses system table that shows the status of and information about all working processes. Generally will see one server process ID (SPID) per connection. If named the connection by using the Application Name argument in the connection string can easily find the connections. Can also use SQL Server Profiler with the SQLProfiler TSQL_Replay template to trace open connections or use the Performance Monitor to monitor the pools and connections. Can monitor the health of connection pool and the number of established connections by using routines to extract the counters or by using the new .NET PerformanceCounter controls. The connection-pool counters creates pools on the system where the ADO.NET code runs, but in contrast, the SQL Server performance counters are on the SQL Server system�not on the client. Can graph the SqlClient counters by selecting .NET CLR Data from the Performance object drop-down list. Note that can monitor all processes by selecting the _global_ counter instances or can look at a specific instance, each pool generates its own set of counters. Performance Monitor lists these counters and exposes them as instances of the selected performance object, but doesn't expose these counters unless there are instances to monitor. Means have to create at least one connection to get the _global_ instance to appear along with a specific instance for each process. Can also monitor the number of open connections by using the SQL Server performance counter User Connections. This counter is listed under SQL Server: General Statistics in the Performance object dropdown list. To access the SqlClient counters, set the category to .NET CLR Data.

Counter	Description
SqlClient: Current # of pooled and nonpooled connections	The current number of connections, pooled or not.
SqlClient: Current # pooled connections	The current number of connections in all pools associated with the process.
SqlClient: Current # connection pools	The current number of pools associated with the process.
SqlClient: Peak # pooled connections	The highest number of connections in all pools since the process started. Note that this counter is available only when associated with a specific process instance. The _global_ instance always returns 0.
SqlClient: Total # failed connects	The total number of connection-open attempts that have failed for any reason.

Keyword	Default	Function
Connection Lifetime	0	How long (in seconds) a connection remains open after an application returns it to the pool: 0 is the "maximum" timeout value. This maximum value means that the connection isn't released as long as the process that created the pool is alive. Only valid in clustered systems
Connection Reset	true	In SQL Server 2000, this keyword determines whether the connection is reset when being drawn out of the pool. Setting this value to false avoids an additional round-trip to the server, but the data provider won't reset the connection state
Enlist	true	When this keyword's value is set to true, the connection pool automatically enlists the connection in the creation thread's current transaction context.
Max Pool Size	100	This value defines the maximum number of connections allowed in the pool.
Min Pool Size	0	This value defines the minimum number of connections allowed in the pool.
Pooling	true	When this value is set to true, it enables connection pooling for this connection. When the value is set to false, connection pooling is disabled for this connection.

Take Advantage of Stored Procedures - SQL Server adds a compiled and optimized data-access plan to the database when you create a stored procedure, resulting in faster execution of queries and other data-manipulation actions. You can also use stored procedures to implement stronger database security, restricting end-user access to just the data that the stored procedures return. They also help resist script attacks.
Cache Nonvolatile Web Application Data - ADO.NET DataSet (like disconnected recordset in ADO) provides the ideal basis for caching Web application data - also provides an interface to establish relationships between tables, retrieve and update data and the DataReader (any sorting/filtering must happen in the SQL statement) provides read-only and forward-only retrieval of data - accessing data through the DataReader is a magnitude of 25-50 times faster than accessing data using the DataSet (use SqlCommand or OleDbCommand object). DataView's represent views built on top of a DataSet's DataTable - caching it doesn't provide any benefit since it's only indexes back to rows in the original table - cache the DataTable instead
Re-use open connections (if using connection in Page_Load event and also a button event handler) and explicitly close connections - the connection object isn't necessarily destroyed when it goes out of scope. You must execute the Close method to make sure you release all connection resources
Use index instead of name to identify datareader columns since it allows the provider to go directly to the buffer (if use column name the provider uses the GetOrdinal method to translate the name into the corresponding index).
nothing like ADO 2.x's GetRows (where entire resultset is copied to a multi-dimensional array), but supports GetValues and GetSqlValues methods which retrieves all columns of current row into an array
DataTable's select method returns back an array of DataRow's - can use DataView's RowFilter method instead to just rebuilt the view.
Rely on the database to sort if at all possible - using the DataView's Sort method takes place in memory and is an expensive operation (n*log(n) operation like quick sort).
Use EXISTS instead of COUNT(*) when checking for existence of rows, e.g.
IF EXISTS (SELECT * FROM users WHERE username = 'xyz')
Use OUTER JOIN instead of IN clause with large list, e.g. to find customers w/o orders:
SELECT c.* FROM customer c LEFT OUTER JOIN orders o ON o.customerid = c.customerid WHERE o.customerid IS NULL
When retreiving large data fields (e.g. XML data) set default packet size in connection string to higher number, e.g.:
...;Packet Size=32767;...
Use ADOX (ActiveX Data Object Extensions for Data Defintion Language and Security) to create/modify schema information. If just want to read then use DataGetSchemaTable method on datareader classes (when executereader use the KeyInfo command behavior to returjn more accurate data):
reader = cmd.ExecuteReader(CommandBehavior.KeyInfo Or CommandBehavior.CloseConnection)
Oracle Select example:
Dim conn as New OracleConnection()
conn.ConnectionString = "data source=zzz;user id=scott;password=tiger"
Dim cmd As New OracleCommand("select * from emp", conn)
Dim rdr As OracleDataReader
Try
  conn.Open()
  rdr = cmd.ExecuteReader()
  While rdr.Read = True
    Console.WriteLine("empno = {0}, ename = {1}", rdr("empno"), rdr("ename"))
  End While
Catch e As Exception
  Console.WriteLine(e.Message)
Finally
  If conn.State = ConnectionState.Open Then
    conn.Close()
  End If
  cmd.Dispose()
  conn.Dispose()
End Try
Oracle Update example:
Dim ds As New DataSet()
Dim da As New OracleDataAdapter( "select * from emp", "data source=zvm43;user id=tiger;password=tiger")
Try
  da.Fill(ds, "emp")
  Dim r As DataRow
  For Each r In ds.Tables(0).Rows
    Console.WriteLine( "empno = {0}, ename = {1}", r("empno"), r("ename"))
  Next
  ds.Tables(0).Rows(0)(2) = "JONES"
  da.Update(ds, "emp")
Catch e As Exception
  Console.WriteLine(e.Message)
End Try
Oracle stored procedure example:
OracleConnection conn = new OracleConnection("data source=zmv43;user id=scott;password=tiger");
OracleCommand cmd = new OracleCommand("Employes.GetEmpRecords", conn);
cmd.CommandType = CommandType.StoredProcedure;
conn.Open();
cmd.Parameters.Add("p_cursor", OracleDbType.RefCursor);
cmd.Parameters.Add("j_cursor", OracleDbType.RefCursor);
cmd.Parameters.Add("indeptno", OracleDbType.Decimal);
cmd.Parameters.Add("p_errorcode", OracleDbType.Int32);
cmd.Parameters[0].Direction = ParameterDirection.Output;
cmd.Parameters[1].Direction = ParameterDirection.Output;
cmd.Parameters[2].Value = 10;
cmd.Parameters[3].Direction = ParameterDirection.Output;

OracleDataReader rdr = cmd.ExecuteReader();
Console.WriteLine(cmd.Parameters[3].Value);
do {
while (rdr.Read())
Console.WriteLine(rdr[0]);
} while (rdr.NextResult() == true);

- or -

int i = cmd.ExecuteNonQuery();
OracleDataReader rdr1 = ((OracleRefCursor)cmd.Parameters[0].Value).GetDataReader();
OracleDataReader rdr2 = ((OracleRefCursor)cmd.Parameters[1].Value).GetDataReader();
while ((rdr1.Read()) && (rdr2.Read())) {
Console.WriteLine(rdr1.GetName(0) + " = " + rdr1[0]);
Console.WriteLine(rdr2.GetName(0) + " = " + rdr2[0]);
}

ASP.Net

To see real errors: Tools-->Internet Options-->Advanced tab - browsing category - uncheck 'Show Friendly HTTP error messages'
Processes to manage requests:
ASPNET_ISAPI.DLL - ISAPI DLL which gets reditects from IIS for ASPX, ASCX, ASHX, and ASMX requests
ASPNET_WP.EXE - worker process which loads classes to service requests
Event Model: Page_New -> Control_New -> Control_Init -> Page_Init -> Load_State -> Process_State -> Page_Load -> Control_Load -> Page_Postback -> Control_Postback -> Control_ButtonClick -> Page_ButtonClick -> Page_Prerender -> Control_Prerender -> Control_Unload -> Page_Unload -> Save_State
Caching options:
Application - useful for global read-only settings, requires locking before read or write access (using Application.Lock and Unlock - should use Application_OnStart method in Global.asax instead), stays up until you remove it programmatically - if you need to control application-wide data and ensure local policies for locking, use Application (not shared across web farm) - example:
Global.asax:
Sub Application_Start(ByVal sender As Object, ByVal e As EventArgs)
Application.Add("ApplicationStartDay", DateTime.Now.ToLongDateString())
Application.Add("RequestedSessionCount", 0)
End Sub
Sub Session_Start(ByVal sender As Object, ByVal e As EventArgs)
Application.Lock()
Application("RequestedSessionCount") = Application("RequestedSessionCount") + 1
Application.UnLock()
End Sub
page.aspx:
Application.Get("RequestedSessionCount").ToString()

Session - is thread-safe, subject to a variety of expiration policies - useful to keep user-specific data during session instead of using cookies (can be shared across web farm) - example:
Session.Contents.RemoveAll()
Session.Add("var1") = "some value"

ViewState - allows user to cache small amounts of page specific data useful for postbacks using hidden form field (doesn't use any server resources)

Several methods to do caching:

Complete Page Caching:
- use OutputCache page directive
<%@ OutputCache
Duration="num of seconds" *required
Location="where"
VaryByCustom="custom"
VaryByHeader="headers"
VaryByParam="paramname or none" *required
%>

Partial Page Caching:
- use user controls with OutputCache page directive above

HttpCachePolicy class's methods and properties:
Cache.SetExpires(DateTime.Now.AddSeconds(30));
Cache.SetCacheability(HttpCacheability.Public);

data caching:
Cache.Add("someKey", "someValue", New CacheDependency(Server.MapPath("db.xml")), DateTime.Now.AddSeconds(10), TimeSpan.Zero, CacheItemPriority.High, Nothing) - use Cache.Insert with same parameters to overwrite existing cache object with the same key
var = Cache.Get("someKey")
Cache.Remove("someKey")
to set dependencies:
Dim arrCacheKey(1)
Cache.Insert("triggerKey", DateTime.Now.ToString, Nothing, DateTime.Now.AddSeconds(10), TimeSpan.Zero)
arrCacheKey(0) = "triggerKey"
Cache.Insert("DS_XML", ds, New CacheDependency(Nothing, arrCacheKey))
Enable tracing instead of using Response.Write statements either globally in Web.config file or also for display on specific pages:
<trace enabled="true" requestLimit="10" pageOutput="false" traceMode="SortByTime" localOnly="true" />
<%@ Page Language="vb" AutoEventWireup="false" Codebehind="WebForm1.aspx.vb" Inherits="WebApplication1.WebForm1" Trace="True" %>

To write messsages use the following:
Trace.Write("message here")
Trace.Write("category here", "message here")
Trace.Write("category here", "message here", objX)
Trace.Warn("...") - which writes text in red instead of black

(can also use System.Diagnostics classes to do all-the-time production logging)
Cookie Info:
Setting a cookie - Response.Cookies.Add(New HTTPCookie("State", "NJ"))
Reading the value of a cookie - strState = Request.Cookies("State").Value
machine.config - location at %windir%\Microsoft.NET\Framework\version\CONFIG\
application config files:
either <app>.exe.config or web.config

<configuration>
<appSettings>
<add key="connectionString" value="server=MyServer;trusted_connection=yes;database=TestDB"/>
<add key="timeout" value="60" />
</appSettings>
</configuration>

read from .config file:
Imports System.Configuration
Dim configReader As New AppSettingsReader()
strConn = CType(configReader.GetValue("connectionString", GetType(System.String)), String)
- or -
strConn = ConfigurationSettings.AppSettings.Item("connectionString")

Dim strKey As String
Response.Write("AppSettings")
For Each strKey In ConfigurationSettings.AppSettings.Keys
Response.Output.WriteLine(strKey & "=" & ConfigurationSettings.AppSettings.Item(strKey))
Next

If don't care about changes to the configuration settings as the application is running, you can use the AppSettingsReader object. If you need to detect configuration changes while the application is running, you need to use the FileSystemWatcher object to watch for file changes to the .config file. When a change occurs, you need to load the .config file's contents into an XML document and search for the value that changed.

Imports System.Xml

Dim strConfigFile As String
Dim foFile As IO.FileInfo
Dim xmlDoc As New XMlDocument
Dim nsMgr As XmlNamespaceManager
Dim nodeRoot As XMLNode
Dim node As XMLNode
Dim strSearch As String
Dim strKey As String
Dim nodeValue As XMLNode

strConfigFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile
foFile = New IO.FileInfo(strConfigFile)
xmlDoc.Load(foFile.FullName)
nsMgr = New XmlNamespaceManager(xmlDoc.NameTable)
nodeRoot = xmlDoc.SelectSingleNode("/configuration/appSettings")
node = Nothing
strKey = "connectionString"
strSearch = string.Format("add[@key='{0}']", strKey)
node = nodeRoot.SelectSingleNode(strSearch)
nodeValue = node.Attributes.GetNamedItem("value")
Use client-side validation to eliminate calls to the server - use asp.net validators for this - RequiredFieldValidator, CompareValidator, RangeValidator, RegularExpressionValidator, and CustomValidator
Examples:
<asp:requiredfieldvalidator id="RequiredFieldValidator1" runat="server" ControlToValidate="tbUsername" Display="Dynamic" ErrorMessage="User Name is required" CssClass="error" />
<asp:CustomValidator id="CustomValidator1" ControlToValidate="tbUsername" OnServerValidate="checkLogin" runat="server" ErrorMessage="custom message here" Display="Dynamic" CssClass="error" />
Sub checkLogin(ByVal source As Object, ByVal args As UI.WebControls.ServerValidateEventArgs)
'use args.Value for value in control validating
'set args.IsValid = False or True
End Sub
submit onclick method - If Page.IsValid = True Then ... End If
authentication - changes to web.config:
forms-based:
<authentication mode="Forms"> <forms name="loginCookie" loginUrl="login.aspx" protection="All" timeout="30"> <credentials passwordFormat="Clear" > <user name="kevin" password="password1"/> <user name="bob" password="pwd"/> </credentials> </forms> </authentication> <authorization> <deny users="?" /> </authorization> custom:
<authentication mode="None"/> 
don't allow anonymous users to site:
<authorization>
<allow users="*" />
<deny users="?"/> 
</authorization>
need anonymous access to file providing credentials at:
<location path="login.aspx">
<system.web>
<authorization>
<allow users="*"/>
</authorization>
</system.web>
</location>
AutoEventWireup - framework calls page events automatically, specifically the Page_Init and Page_Load methods. The disadvantage of the AutoEventWireup attribute is that it requires that the page event handlers have specific, predictable names. In Visual Studio, the AutoEventWireup attribute is set to false by default and the designer generates explicit code to bind page events to methods. If you do set AutoEventWireup to true, Visual Studio will generate code to bind the events and the page framework will automatically call events based on their names. This can result in the same event code being called twice when the page runs. As a consequence, you should always leave AutoEventWireup set to false when working in Visual Studio
Src @page declaration in .asax/.aspx/.ascx files - the attribbute is the name of the code-behind page, and it is used if the Web application is not recompiled. CodeBehind - this is the attribute that Visual Studio .NET uses internally to associate the files. The src attribute is used by the ASP.NET runtime. It first compiles the file declared by the src attribute and then compiles the aspx. The CodeBehind attribute is ignored by ASP.Net, but is used by vs.net to know the name of the code behind file. VS.Net compiles all the code behind files into one dll stored in the bin directory.
Use IsPostBack property in Page_Load (Page.IsPostBack) to only validate when needed (and only load/initialize data on the first execution of the page) - can also use Page.Request.Form("__EVENTTARGET") to find out what control (if any) triggered the postback event
Use HttpServerUtility Server.Transfer instead of Response.Redirect (eliminates unnecessary client/server round trips and improves site performance). Use Request.Redirect if want user to see new URL on address line on browser though.
Don't rely on exceptions - don't use to pass information from one routine to the next with queries such as, "Did the method succeed or fail?" - overhead required to unwind a call stack and perform an exception notification vastly exceeds the overhead needed to make a change in the program's execution path. Only use if not expecting the method to fail.
restrict use of session state - control on page-by-page basis with <%@ Page EnableSessionState="false" %> and <%@ Page EnableSessionState="readonly" %> - turn off entirely for site in web.config like: <sessionState mode="off" /> - can also store it as in-process session state:
<sessionState mode="InProc" stateConnectionString="tcpip=127.0.0.1:4 2424" sqlConnectionString="data source=127.0.0.1;Trusted_Connection=yes" cookieless="false" timeout="20" />
limit use of server controls since they take impose overhead - only use if plan to control the properties of a control programmatically, use view state to hold data values of the control; or handle server-side events generated by the control.
Use validateRequest="False" in the @Page tag if entering HTML tags within textbox controls.
To enter quotes within <%# ... %> tags on aspx pages do like the following:
NavigateUrl='<%# "javascript:window.open(" & Chrw(39) & "productPreview.aspx?id=" & DataBinder.Eval(Container.DataItem, "ID") & Chrw(39) & ", " & Chrw(39) & "winProduct" & Chrw(39) & ", " & Chrw(39) & "dependent=yes,width=800,height=600,scrollbars=no,toolbar=no,directories=no,location=no,menubar=no,status=no,resizable=yes,titlebar=yes" & Chrw(39) & ")" %>'
Turn off ViewState generation if page is output only (use the EnableViewState property for server controls or the page directive - <%@ Page EnableViewState="false" %>) - only use it to cache data that will be used in the page post back and that won't be re-populated on each page request (like items in the control's Attributes collection). Complex controls like a data grid add a lot of viewstate overhead to the page size.
GUID support:
Dim guid1 As Guid = Guid.NewGuid
Console.WriteLine(guid1.ToString)
DataGrid - when pagination is used the data is not cached in the page's view state. If want to cache store data in the Session or Cache objects.
Methods to Insert Client-Side Script - RegisterArrayDeclaration, RegisterClientScriptBlock, RegisterHiddenField, RegisterOnSubmitStatement, RegisterStartupScript:
If Not Page.IsClientScriptBlockRegistered("JSImageProtection") Then
Page.RegisterClientScriptBlock("JSImageProtection", sbJS.ToString())
End If
use Application Center Test tool to stress test application - comes with Visual Studio.Net Enterprise, otherwise use MS Web Application Stress (WAST) Tool (http://webtool.rte.microsoft.com/):
measure the following metrics:
Performance Counter (Performance Object in .NET)
ASP Requests/Sec (ASP.NET Applications)
ASP Execution Time (ASP.NET) and ASP Wait Time (ASP.NET) - Average ASP Latency = (Avg. ASP Execution Time + Avg. ASP Wait Time) and should be less than 2 seconds
Requests Queued (ASP.NET)

other metrics:
ASP Queuing - should be 1 or lower
Context Switches/sec - should be below 15,000

- start with a relatively low number of Simultaneous Browser Connections (SBCs) like 5 or 10 SBCs and slowly move up if your application can handle a higher load
- never run Application Center Test on the same machine that you are stress testing
- if CPU% usage on the machine running Application Center Test approaches or stays at 100% then you have a bottleneck on that machine and you need to add more clients
- look at the web server log to ensure that the 200 server codes (a successful HTTP request code) are for the page/files being accessed and not a successful hit on the default error page
enable/disable browser and proxy caching (if enabled get less hits recorded on your web server):
Response.Expires = -1
Response.ExpiresAbsolute = DateTime.Parse("1/1/1980 00:00:00")
Response.AddHeader("pragma", "no-cache")
Response.CacheControl = "Private"
Meta tags to add to page:
<meta name="robots" content="noarchive, noindex, nofoloow, noimageindex, noimageclick"> // to prevent robots
<meta http-equiv="cache-control" content="no-store"> // for browsers that support HTTP 1.1 to prevent caching
<meta http-equiv="Pragma" content="no-cache"> <meta http-equiv="expires" content=0> // put prior to no-store tag in case don't support HTTP 1.1
to load control dynamically:
Me.Panel.Controls.Add(Page.LoadControl("~/myControl.ascx") - if using server-side controls use tilde (~) at beginning of URL to reference web application root
to use Mobile Controls - install Device Update 3.0 and then install Openwave (http://www.openwave.com) or Nokia (http://forum.nokia.com)

ASP.Net/ADO.Net Best Practices

Never use Response.Write statements in aspx pages - put all logic in code behind pages and have it manipulate server controls on pages
no need to import adovbs.inc file - just import proper namespaces on code behind pages and classes
Settings to change when deploy live:
Ensure the ASP.NET ISAPI filters are configured for the .NET Framework version needed for the site/virtual directory - use C:\WINNT\Microsoft.NET\Framework\version\aspnet_regiis.exe -r for this (to see what mappings are currently set to execute aspnet_regiis.exe -lk).
machine.config:
enableSessionState � if the application does not use ASP.NET sessions at all, then it�s a good idea to completely disable session state - <sessionState mode="off" />.
enableViewStateMac � If this is not turned off (false), then the page view state is tied to a specfic server in the farm (the �Mac� means �machine� in enableViewStateMac). The viewstate binary data is encrypted somehow using possibly the mac address of the server as part of the encryption key. Users will see �View state is corrupt� errors whenever moving from one box to another. Probably set to �false� for all sites. View state will still work if enableViewStateMac is set to false.

ASP Best Practices

Basic ASP

always use Server.CreateObject - the Server. portion allows ASP to track the object instance and allows the object to be created in a transaction server package so resources are pooled (if just use CreatObject then each new object is attached to a separate thread so system resources are consumed much faster)
instead of looping through recordset one row at a time use it's GetRows() and rs.GetString() methods to return data as an array - avoid String Concatenation in Loops - repeatedly concatenating a string takes quadratic time, the time that it takes to run a loop is proportional to the square of the number of records times the number of fields - example:
Set rsData = conn.Execute(strSQL)
arrData = rsData.GetRows()
For iRow = LBound(arrData, 2) To UBound(arrData, 2)
  For iCol = LBound(arrData, 1) To UBound(arrData, 1)
    Response.Write "data point (row:" & iRow & "/col:" & iCol & " = " & arrData(iCol,iRow)
  Next
Next
Set rsData = nothing
avoid putting any ADO Objects in Sessions - scalability limitations and threading issues come into play and high stress is placed on both the Web server and the database - it also disables the use of connection pooling because variables stored in a Session object persist for the entire user-session - by default, ADO objects are marked as apartment-threaded in the registry. This is fine when you create your objects with page-level scope - by default, a Session object has a 20-minute timeout - avoid sessions all together - turn them off for application through the Internet Services Manager or on page-by-page basis with <% @EnableSessionState=False %> - also get rid of Session_OnStart or Session_OnEnd methods from global.asa - also allows ASP requests to no longer be serialized
use Server.Transfer in IIS 5.0 instead of Response.Redirect whenever possible - Response.Redirect tells the browser to request a different page so the browser has to make two round trips to the Web server (puts a code in the HTTP header that tells the browser to request the next page), and the Web server has to handle an extra request - with IIS 5.0 use Server.Transfer which transfers execution to a different ASP page on the same server
use Server.Execute in IIS 5.0 as an alternative to Server-Side Includes - it will process another ASP page as part of the current ASP page - provides a new way to encapsulate code and maintain more modular ASP pages - now provides truly conditional #includes
caching - faster to retrieve from memory than the db - combo-box lists, reference tables, DHTML scraps, Extensible Markup Language (XML) strings, menu items, and site configuration variables are good candidates for caching - use application object in Application_OnStart() in global.asa - can also just cache something in application object the first time it's needed - can also use ADO recordset Save() and Open() to write results to disk (or can use FileSystemObject, MSXML parser, or LookupTable object) - to cache the recordset itself ADO must be marked as free-threaded and need to use a disconnected recordset (using rs.CursorLocation=adUseClient) - however better off not doing it and also shouldn't cache any COM objects at all

'global.asa settings
Application("TNav_HTML") = ""
Application("TNav_Cache_Minutes") = 60
Application("TNav_LastUpdate") = ""

'example to only update data every 5 minutes
'- can also just update once per application when string is empty strLastUpdate = Application("TNav_LastUpdate")
If (Application("TNav_HTML") = "") Or (Application("TNav_Cache_Minutes") < DateDiff("n", CDate(Application("TNav_LastUpdate")), Now)) Then
  ... 'create recordset
  '2=adClipString format, -1 returns all rows, ColumnDelimiter, RowDelimiter, NullExpr
  strData = rsData.GetString(2, -1, strColumn, strRow, "")
  Application.Lock
  Application("TNav_HTML") = strData
  Application("TNav_LastUpdate") = CStr(Now)
  Application.Unlock
End If
use Response Buffering - minimizes the amount of writes to the browser and thus improves overall performance - TCP/IP works much more efficiently when it can send a few large blocks of data than when it has to send many small blocks - turn on buffering for an entire application, using the Internet Services Manager or on page-by-page bas with <% Response.Buffer = True %> - for long running pages can also it with Response.Flush method periodically along with Response.IsClientConnected before running long query - If it returns False, you should call Response.End and abandon the rest of the page - IIS 5.0 codifies this practice�whenever ASP is about to execute a new request, it checks to see how long the request has been in the queue. If it has been there for more than 3 seconds, ASP will check to see if the client is still connected and immediately terminate the request if it's not - Response.IsClientConnected has some costs, so only use it before an operation that takes at least, say 500 milliseconds
use TypeLib Declarations for ADO and Other Components - when using ADO, developers often include adovbs.txt (get latest one from http://www.aspsweden.com/manual/adovbs21.asp.txt) to get access to ADO's various constants - this file must be included on every page that wants to use the constants - IIS 5.0 introduces the ability to bind to a component's type library - to access the ADO TypeLib, place one of the following statements in Global.asa:

or
batch inline script and Response.Write statements - interspersing small amounts of script and HTML causes switching between the script engine and HTML, reducing performance - tip has a much bigger effect when response buffering is disabled
use Use Option Explicit in your .asp files - declared variables are faster than undeclared variables - the scripting run time references undeclared variables by name, every time they are used - declared variables are assigned an ordinal, either at compile time or run time so declared variables are referenced by this ordinal
use Trailing Slashes in Directory URLs - if omit trailing slash the browser will make a request to the Web server, only to be told that it's asking for a directory - the browser will then make a second request with the slash appended to the URL, and only then will the server respond with the default document for that directory, or a directory listing if there is no default document and directory browsing has been enabled - appending the slash cuts out the first, futile round trip
don't use Server.MapPath - it generates an additional request for the server to process - to improve performance, replace Server.MapPath with a fully qualified path
never access the Request object unqualified - for items not in Request.Cookies, Request.Form, Request.QueryString, or Request.ClientCertificate, there is an implicit call to Request.ServerVariables - the Request.ServerVariables collection is much slower than the other collections
avoid using Server Variables (Request.ServerVariables) - accessing server variables causes your Web site to make a special request to the server and collect all server variables, not just the one that you requested
use local variables in Subroutines and Functions if possible - variable access is faster than global variable access
copy Frequently-Used Data to Script Variables - will cut down on COM method calls, which are relatively expensive compared to accessing script variables - Prime targets for this optimization are Request variables (Form and QueryString variables)
avoid Redimensioning Arrays (ReDim statement) - better to set the initial dimension of the array to its worst-case scenario
take advantage of the browser's validation abilities - cutting down on client-server round trips, you'll reduce the stress on the Web server and cut down network traffic - however should also do validation on server-side to ensure integrity (not all browsers will run the client-side code)
stress test application - don't save all performance testing for the end of the project - often at the end of a project it's too late to make necessary architectural changes, - use MS Web Application Stress (WAST) Tool - also see Load Test Your ASP Application and Performance monitor counters for web server testing
encapsulate complex code in compiled COM objects - however performance advantage enjoyed by compiled code over ASP code has decreased with the introduction of IIS 5.0 - can also use VBScript classes
try to make code as readable as possible - indent, declare variables consistently, use new VBScript 5 With statement like:
With Response
.Write("Hello<br>")
.write("Goodbye")
End with

Database/ADO

if using ODBC then in general use DSN-less connections which are faster than System DSNs which are also faster than File DSNs (System DSNs are 3 times faster than File DSNs) - also use SQLOLEDB (native SQL Server OLE DB provider) over MSDASQL (ODBC OLE DB provider) - also need to use if want to use stream object
use stored procedures instead on inline dyanamic SQL - for performance reasons since it pre-compiles code (it is optimized and a query execution plan is compiled), after it is run the first time it stays cached in SQL Server�s memory, it enhances security because you don't need to grant users access to objects accessed by the stored procedure, it abstracts the database schema from application programs which insulates your code from changes, and reduces network traffic for batch SQL statements
when executing a stored procedure from an application reference it using it's fully qualified name like database_name.dbo.myProcedure, instead of myProcedure since doing so allows SQL Server to access the stored procedures execution plan more directly
if a stored procedure needs to return only a single value, and not a recordset, consider returning the single value as an output statement using RETURN in T-SQL since it's faster than returning a single value as part of a recordset - in the ASP page it would look like the following:
params.Append cmd.CreateParameter("@RETURN_VALUE", adInteger, adParamReturnValue , -1)
explictly use hint to tell procedure that it doesn't have to be transaction safe
DECLARE @intCount int
SET NOCOUNT ON
SELECT @intCount = COUNT(au_id) FROM authors WITH (NOLOCK)
RETURN @intCount
acquire resources Late, release early - ADO connections and recordsets are the prime candidates for this optimization - call Close() on recordsets and connections before setting them = Nothing since it releases the database connection to the connection pool as quickly as possible
explicitly create parameters (specify type, direction, and size) - if not it forces ADO to handle extra processing (more round-trips to the server) as well as make assumptions about the parameters you pass in (can use refresh method to determine what they are, use sp_paramter_test.asp script for this) - also if dont want to list parameters ordinally use cmd.NamedParameters = True - examples:
Set params = cmd.Parameters

params.Append cmd.CreateParameter("@RETURN_VALUE", adInteger, adParamReturnValue, -1)
params.Append cmd.CreateParameter("@SKU", adVarChar, adParamInput, 50)
cmd.Parameters("@SKU").Value = m_strSKU

params.Append cmd.CreateParameter("@RETURN_VALUE", adInteger, adParamReturnValue)
params.Append cmd.CreateParameter("@ISBN", adVarChar, adParamInput, 20)
params.Append cmd.CreateParameter("@PRICE", adCurrency, adParamOutput)
params.Append cmd.CreateParameter("@TITLE", adVarChar, adParamOutput, 200)
cmd.Execute , Array(0, "0-0230362-0-6"), adExecuteNoRecords
Response.Write "Title=" & cmd("@Title") & ", Price=" & cmd("@Price")
remember to set the Command object's ActiveConnection property last so that ADO will let you construct the Parameters collection before trying to refresh it from the server
use NamedParameters=False, the default, which interprets parameters in the order in which they were created - changing the value to True causes ADO to pass their names to the provider, which then are used to match up the parameters - False is more efficient though because the provider does not have to do any matching
choose correct SQL cursor - use forward-only cursors when only need to make a single pass through the data (fastest performance with the least amount of overhead, but doesn't support RecordCount property) - fast forward only recordsets are forward-only, read-only, and have cachesize=1 - when use syntax like Set rs = cmd.Execute the returned Recordset object is always a read-only, forward-only cursor
use command objects over updateable recordset cursors to execute action queries (INSERT, UPDATE, and DELETE statements)
whenever query doesn't return a rowset, be sure to use the adExecuteNoRecords option to tell ADO to bypass any code required to set up and receive a rowset (in Recordset form) - can pass this option to the Execute method or as a Command option, e.g. cmd.Execute , , adExecuteNoRecords
pool connections wisely - it's on by default for SQL Server, and the default timeout is 60 seconds (a connection will remain in the pool for 60 seconds while not in use). You can edit CPTimeout for the SQL ODBC Driver by launching RegEdit and navigating to the key HKEY_LOCAL_ MACHINE\Software\ODBC\ODBCINST.INI\SQL Server - it only applies when you connect to the database using the same user name and password for each connection - take advantage of connection pooling by creating and destroying the Connection object on a per-page basis, rather than storing it in a Session variable - if using SQLOLEDB, and not ODBC, add "OLE DB Services=-1;" to the connection string to utilize resource pooling
to improve performance when you refer to recordset values use the ordinal form so don't force COM to resolve the reference for you - also explicitly refer to the Value property of a specific member of the Recordset Fields collection:
Enum enumQuery1
CatName
CatType
CatSize
End Enum
set rs = [open a recordset]
set [var] = rs.Fields(enumQuery1.CatName).Value
optimize queries - rather than using SELECT * only include the columns that you need within your SELECT statement - avoid resource-intensive operations such as IN, NOT IN, OR, !=, SUM
instead of using SELECT count(*) to get count of entire table use: DECLARE @intCount int
SET NOCOUNT ON
SELECT @intCount = rows FROM sysindexes WITH (NOLOCK) WHERE id = OBJECT_ID('table_name') AND indid < 2
RETURN @intCount
create useful indexes - clustered index results in the data being physically stored after being sorted by the key defining the index - choose a clustered index if you will be querying the data for values that fall within a given range and for queries that will return data ordered in the same way as the clustering key (may not want the primary key to be this index which it is by default) - also in composite keys (a key composed of more than one column), you need to make the most distinguishing column the leftmost part of the index - indexes are not created automatically for foreign keys unlike primary keys - try to keep indexes narrow, avoid multicolumn, compound indexes - also every table contain a primary key
never re-use recordset or command variables - it may cause failure within ADO and the command object was not designed or intended to be utlized that way
avoid blobs - SQL Server does not store the Blob data on the data page along with the other fields in the row, instead, SQL Server maintains a pointer to the Blob data - if search on text in where then must use like clause
use TCP/IP as Network Library - TCP/IP provides the fastest connectivity of any network library option since it doesn't require an NT trusted connection - use the SQL Server Client Configuration Utility Net Library tab - limits you to standard security within SQL Server - using integrated security can severely limit the effectiveness of connection pooling in your Web application
if SQL Server is running locally on the same box as ASP then use Named Pipes - instead of SERVER=machinename use SERVER=<local> since it prevents the round trip to the domain controller for authentication which saves network bandwidth
to help identify performance problems with stored procedures, use SQL Server's Profiler Create Trace Wizard to run the "Profile the Performance of a Stored Procedure"
include in stored procedures the statement "SET NOCOUNT ON" so that every time a SQL statement is executed SQL Server doesn't send a response to the client indicating the number of rows affected by the statement
if don't want to cache compilation plan of stored procedure (if it's dynamic SQL and it changes each time or has if statement in it so only the SQL called the 1st time it is run is pre-compiled) then add the "WITH RECOMPILE" option when you create the stored procedure - instead can use a delegate stored procedure (which allows compilation plans to be cached) to call other stored procs with only one stored procedure each in them:
CREATE PROCEDURE dbo.spTestDelegator (@query bit) AS
IF @query = 0
EXEC spTestFromAuthors
ELSE
EXEC spTestFromPublishers
GO

CREATE PROCEDURE dbo.spTestFromAuthors AS
SELECT * FROM authors
GO

CREATE PROCEDURE dbo.spTestFromPublishers AS
SELECT * FROM publishers
GO
if stored procedire isn't run in the MASTER database then don't start it's name with sp_ since by default any stored procedure executed that begins with the prefix "sp_" is first attempted to be resolved in the Master database which wastes time
all objects that are called within the same stored procedure should all be owned by the same owner, preferably dbo so that SQL Server doesn't have to perform name resolution on the objects if their names are the same
when need to execute a string of Transact-SQL use the sp_executesql stored procedure instead of the EXECUTE statement since it supports parameter substitution and it creates query execution plans that are more likely to be reused by SQL Server
remember that SQL Server will automatically recompile a stored procedure when (create trace using Profiler and track the SP:Recompile event to see if it is happending a lot):
- If include a WITH RECOMPILE clause in a CREATE PROCEDURE or EXECUTE statement.
- If run sp_recompile for any table referenced by the stored procedure.
- If any schema changes occur to any of the objects referenced in the stored procedure - includes adding or dropping rules, defaults, and constraints.
- New distribution statistics are generated - like when "Auto Update Statistics" are turned on for a busy database this could happen many times each hour.
- If restore a database that includes the stored procedure or any of the objects it references.
- If the stored procedure is aged out of SQL Server's cache.
- An index used by the execution plan of the stored procedure is dropped.
- A major number of INSERTS, UPDATES or DELETES are made to a table referenced by a stored procedure.
- The stored procedure includes both DDL (Data Definition Language) and DML (Data Manipulation Language) statements, and they are interleaved with each other - should include all of your DDL statements at the first of the stored procedure so they are not intermingled with DML statements.
- If the stored procedure performs certain actions on temporary tables - use the KEEP PLAN query hint which is used to stop stored procedure recompilations caused by more than six changes in a temporary table - stored procedure should not declare any cursors that refer to a temporary table.

Web Server

tune web server - with IIS 4.0 increasing the ASP ProcessorThreadMax parameter (see IIS documentation) can have significant benefits, especially on sites that tend to wait on back-end resources such as databases - also use appropriate isolation configuration:
- Low Isolation - it's the fastest and runs ASP in Inetinfo.exe, which is the primary IIS process - if the ASP application crashes, so does IIS - IIS 5.0 introduces reliable restart, which automatically restarts a failed server - won't see much benefit to the Low isolation level if you have a relatively low hit rate or low maximum throughput. Therefore, you should not feel the need to reach for the Low isolation level until you need hundreds or thousands of pages per second per Web server - single-purpose Web servers can be run at Low isolation
- Medium Isolation - out-of-process, since ASP runs outside of the IIS process - all ASP applications configured to run as Medium share a single process space. This reduces the number of processes required to run multiple out-of-process ASP applications on one box. Medium is the default isolation level in IIS 5.0
- High Isolation - out-of-process, if ASP crashes, the Web server doesn't - each ASP application that is configured to run as High runs in its own process space. This protects ASP applications from each other. Its drawback is that it requires a separate process for each ASP application. This can add up to a lot of overhead when dozens of applications need to be hosted on one box

MS ASP/ASP.NET References

.NET Framework Class Library Reference
.NET Framework Web Server Controls
.NET Architecture Center ("The structure of the components of a program/system, their interrelationships, and principles and guidelines governing their design and evolution over time." - David Garlan and Dewayne Perry (IEEE Transactions on Software Engineering 4/1995)
ASP.NET Developer Center
Microsoft Patterns
Microsoft patterns and practices for Application Architecture and Design
Microsoft Enterprise Solution Patterns: Model-View-Controller
Data Access Technologies
HOW TO: Create, Use, and Manage Macros in Visual Studio .NET
Automating Repetitive Actions by Using Macros
Web Projects and Source Control Integration in Visual Studio .NET
25+ ASP Tips to Improve Performance and Style
Maximizing the Performance of Your Active Server Pages
Leveraging ASP in IIS 5.0
The Art and Science of Web Server Tuning with Internet Information Services 5.0
Top Ten Tips: Accessing SQL Through ADO and ASP
ASP Guidelines
HOW TO: Access Network Files from IIS Applications

ASP/ASP.NET Articles

ASP/ASP.NET Web Sites

Other Information

<%@ Language="VBScript" %> - force ASP to use as specified language as default when interpreting code - must be on 1st line
use Server.ScriptTimeout to increase timeout for long running pages - i.e. admin/manager stuff
use vbCRLF instead of Chr(13) & Chr(10)
to use 1 instead of 0 as starting point in array do either:
- Option Base 1 'in general section
- Dim iMyArray(1 To 3) As Integer
credit card info to test with (will pass checksum tests):
American Express 3111-1111-1111-1117
Visa 4111-1111-1111-1111
Mastercard 5111-1111-1111-1118
Discover 6111-1111-1111-1116
to delete a cookie:
Response.Cookies("cookiename") = ""
Response.Cookies("cookiename").Expires = #01/01/1980#
use the following rules when setting Web server permissions:
- Enable Read OR Script permissions for virtual directories containing ASP files
- Enable Read AND Script permissions for virtual directories containing both ASP and other files, such as HTML files, that contain scripts
- Enable Read AND Execute permissions for virtual directories containing both ASP and other executable files, such as EXE and DLL files, which require the Execute permission to run
to display a comment message box:
' rest of ASP code goes here
%>
<SCRIPT LANGUAGE="java-script">
alert("<% = strMessageToShow %>")
</SCRIPT>
<%
' rest of ASP code goes here

Database

database example:
Dim db as Database
Dim rst as Recordset
Dim varBookmark As Variant

Set db = OpenDatabase("Orders.mdb")
Set rst = OpenRecordset("tblCustomers")
rst.AbsolutePostion = 15
varBookmark = rst.Bookmark
rst.Bookmark = varBookmark 'when you're ready to return to the referenced record

1. Is the ADO connection (Conn) returned to the connection pool?
2. What statement returns the connection to the pool?

	Recordset created with Server.CreateObject	Recordset created with CreateObject	Command created with Server.CreateObject	Command created with CreateObject
Explicit connection created with Server.CreateObject	1.Yes 2.Conn.Close	1.Yes 2.Conn.Close	1.Yes 2.Conn.Close	1.Yes 2.Conn.Close
Explicit connection created with CreateObject	1.Yes 2.Conn.Close	1.Yes 2.Conn.Close	1.Yes 2.Conn.Close	1.Yes 2.Conn.Close
Implicit connection	1.No N/A	1.Yes Set Recordset=Nothing	1.No N/A	1.No N/A

Explicit Connection with Server.CreateObject

sConnect="DRIVER={SQL Server};SERVER=ServerName;DATABASE=Pubs;UID=sa"
Set Conn = Server.CreateObject("ADODB.Connection")
Conn.Open sConnect
Explicit Connection with CreateObject

sConnect="DRIVER={SQL Server};SERVER=ServerName;DATABASE=Pubs;UID=sa"
Set Conn = CreateObject("ADODB.Connection")
Conn.Open sConnect
Implicit Connection with Recordset

sConnect="DRIVER={SQL Server};SERVER=ServerName;DATABASE=Pubs;UID=sa"
Set Rs = CreateObject("ADODB.Recordset")
Rs.Open "SELECT * FROM Authors", sConnect
to delete duplicate row from database
Set Rowcount 1
DELETE FROM xyz WHERE name='Smith'
Set Rowcount 0
forward-only, read-only recordset:
Dim dcnDB ' As ADODB.Connection
Dim rsData ' As ADODB.Recordset

Set dcnDB = Server.CreateObject("ADODB.Connection")
dcnDB.Open "some connection string"
Set rsData = dcnDB.Execute("SELECT * FROM LookupTable")
connect via .udl file
Dim oConn as New ADODB.Connection
oConn.ConnectionString = 'File name=C:\temp\myUDL.udl"
oConn.open
to connect to Access 2000 DB (DSN-LESS):
Dim dcnDB ' As ADODB.Connection

Set dcnDB = Server.CreateObject("ADODB.Connection")
dcnDB.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;" _
& "Data Source=" & Server.Mappath("../database/database.mdb")
dcnDB.Open
to connect to SQL Server 7 DB (DSN-LESS):
Set conn = Server.CreateObject("ADODB.Connection")
conn.Open "Provider=MSDASQL;DRIVER={SQL Server};SERVER=SERVER1;DATABASE=TEST;UID=sa;PWD="
see how many records affected by dml statement
cnDB.Execute "UPDATE Products SET UnitPrice = UnitPrice * 1.05", lngRecords
- variable lngRecords will hold number of records updated
show column names in database query:
Dim i ' As Integer

For i = 0 To rsData.Fields.Count - 1
Response.Write "" & vbCrLf
Next ' i
simulate table query/manipulation without accessing database:

<%
Option Explicit
Dim objFSO ' As Scripting.FileSystemObject
Dim objFolder ' As Scripting.Folder
Dim objFile ' As Scripting.File
Dim rsData ' As ADODB.Recordset

Set rsData = Server.CreateObject("ADODB.Recordset")
With rsData.Fields
  .Append "Filename", adVarChar, 40, adFldUpdatable
  .Append "Size", adInteger, , adFldUpdatable
End With
rsData.Open , , adOpenDynamic

Set objFSO = Server.CreateObject("Scripting.FileSystemObject")
Set objFolder = objFSO.GetFolder(Server.MapPath("/"))
For Each objFile in objFolder.Files
  rsData.AddNew
  rsData("Filename") = objFile.Name
  rsData("Size") = objFile.Size
  rsData.Update
Next ' objFile

rsData.Sort = "Filename"
rsData.MoveFirst
Do Until rsData.EOF
  Response.Write rsData("Filename") & " (" & rsData("Size") & " bytes)<br>"
  rsData.MoveNext
Loop

rsData.Close
%>
to check the Description field and return a True or False if this field can be null - Response.Write CBool(rsData("Description").Attributes And adFldIsNullable)
put BeginTrans before dynaset update code and CommitTrans just after it - it will speed things up

Sample Functions

see functions.asp

Other Examples

running an Access report example (make sure Access Object Library is referenced first - Project Menu->References check for MS Access 8.0 or 9.0 Object Library):
Dim app As Access.Application
Set app = New Access.Application

app.OpenCurrentDatabase("c:\folder\database.mdb")
app.DoCmd.OpenReport "reportyouwanttoprint"
app.CloseCurrentDatabase