6. Be Specific When Using The Request Object Collections.

When a browser asks for a page from a server, it is called a request. The ASP Request object is used to get information from the user. This code is what normally programmers do:

<%
	Dim name
	name = Request("name")
%>

The request object has FIVE COLLECTION plus a default collection. The default collection is what you are seeing above. The other collections are:

• QueryString
• Form
• Cookies
• ClientCertificates
• ServerVariables

Every ASP programmer is familiar with these collections. They are pretty much the most crucial tools available in the Request object. They allow you to gain access to the client’s request information.
When you do a call to the default Request collection, each of the sub collections are searched in that following order.

The process stops when the first match is found. If you’re passing a lot of information between pages, using the default collection to get inputs can result in slowdowns, especially if you’re looking for servervariables that way. What I usually do is use the default collection if I am looking for form or querystring variables only. That provides a bonus because then the application works with both GET and POST request.

7. Minimise ASP Request Object Call.

This is a common mistake that programmers make. Consider this code which illustrates what NOT to do:

<%
    If Request.Form("name") <> "" Then
    SQL = "INSERT INTO table1 (name) VALUES ('" & Request.Form("name") & "')"
    Response.Write "Your name is : " & Request.Form("name")
    End If
%>

Wherever ASP objects are used, it is better to store session or querystring objects in a variable at the start of the page and subsequently use the variable. What’s happened above is the Request.Form collection keeps getting called over and over again for the “name” input, and yet we know that the input’s value hasn’t changed. The Engine needs to read the value of from the Querystring collection each time which increases overhead. This translates to cycles wasted and a slowdown in the ASP application. A better way to write that code that would run your ASP page much faster would be like this:

<%
    Dim name
    name = Request.Form("name")

    If name <> "" Then
        SQL = "INSERT INTO table1 (name) VALUES ('" & Request.Form("name") & "')"
        Response.Write "Your name is : " & Request.Form("name")
    End If
%>

Now the collection has only been searched for that input one time. Effectively using this technique throughout your ASP pages will definitely speed up the page.

8. Open A Database Connection One Time Per Page.

Database work takes cycles. Consider bad code like this which opens a database more than one time:

<%
    Dim conn, rs, id

    Set conn = Server.CreateObject("ADODB.Connection")
    conn.open "connstring"
    Set rs = Server.CreateObject("ADODB.recordset")

    rs.open "SELECT id FROM table1 ORDER BY id DESC", conn
    id = rs.fields(0).value
    rs.close
    Set rs = nothing

    'Close Database Connection!
    conn.close
    Set conn = nothing

    'Re-Open The Database Connection!
    Set conn = Server.CreateObject("ADODB.Connection")
    conn.open "connstring"
    conn.execute "INSERT INTO table1 (id) VALUES(" & id + 1 & ")"

    'Close Database Connection!
    conn.close
    Set conn = nothing
%>

What you see above is code which gets a value out of a database and then creates a new row in the same database. This code makes the mistake of closing the database between sql executions. That code will be slower than it could be by rewriting it properly like this:

<%
    Dim conn, rs, id

    'Open Database Connection
    Set conn = Server.CreateObject("ADODB.Connection")
    conn.open "connstring"

    Set rs = Server.CreateObject("ADODB.recordset")
    rs.open "SELECT id FROM table1 ORDER BY id DESC", conn
    id = rs.fields(0).value
    rs.close
    Set rs = nothing

    conn.execute "INSERT INTO table1 (id) VALUES(" & id + 1 & ")"

    'Close Database Connection!
    conn.close
    Set conn = nothing
%>

The difference is, the database connection is only opened one time above, saving time. When used comprehensively on every page of a website, these guidelines can make your applications run as fast as possible in the ASP environment.

9. Reference Columns In A Recordset Ordinally.

When working with an ADO Recordset object, there are a number of ways to grab the value of a particular column. The most common way is to use the column’s name. For example, if we had a Recordset object named objRS that had three columns, Name, Age, and Salary, we could display these contents of these three columns for the current row in the Recordset using the following code:

<%
    Employees Name: <%=objRS("Name")%><br>
    Employees Age: <%=objRS("Age")%><br>
    Employees Salary:<%=objRS("Salary")%><br>
%>

These values can also be accessed ordinally. Each column is given an ordinal index starting at zero. Hence, these three columns could also be displayed with the slightly modified code:

<%
	Employees Name: <%=objRS(0)%><br>
	Employees Age: <%=objRS(1)%><br>
	Employees Salary: <%=(objRS(2)%><br>
%>

Now, you may say that using the ordinal notation decreases code readability, and I would agree.

There is a disadvantage of using this method but it can easily be solved. Consider this situation, if more than one person is working on a site, it could get you in trouble. Someone else adding one field to the SQL string NOT at the end will throw off all your code. The solution is to use a constant.

You could use constant to refer to your recordset elements. Although this has a very slight performance penalty in terms of script size and initial interpreter processing, it represents a nice trade-off between code readability and efficiency, example:

<%
    strSQL = "SELECT Name, Age, Salary from People ORDER BY id"
    Const NAME = 0
    Const AGE = 1
    Const SALARY = 2

    objRS.Open strSQL, conn

    Response.Write ("Employees Name: " & objRS(NAME) & "<br>")
    Response.Write ("Employees Age: " & objRS(AGE) & "<br>")
    Response.Write ("Employees Salary: " & objRS(SALARY) & "<br>")
%>

I think that’s a nice compromise between performance and maintainability/readability…

10. Use .HTM As Your Extension

Use .htm files when possible as they never block and get maximum caching benefits. ASP files are generally blocked. So if the file contains pure HTML, give it an .htm extension. If you can avoid tables, that’s good news but we can’t always do that, so try to avoid nested complex tables. This will boost the load performance. The solution to this is by using CSS (Cascading Style Sheet) to position your HTML elements. As I said before, HTML file is executed 3 to 4 times faster than complex ASP script.

Conclusion

Now that I’ve made you sufficiently worried and excited at the same time about your asp applications, I must hasten to tell you that this is only the tip of the iceberg. Best coding practices don’t come easy. It comes with a passion for self-improvement. Enjoy coding…

Source: ASP101 4GuysFromRolla

What is CDOSYS?

CDO (Collaboration Data Objects) is a Microsoft technology that is designed to simplify the creation of messaging applications.

CDOSYS is a built-in component in ASP. This component is used to send e-mails with ASP.

We all know that whenever you put your email address onto the internet for you to communicate with your visitors, you instantly get hit with tons of spam. This is because a spammer’s email finder application saw your email address and added it to their nasty hit list.

This is why website owners created a contact form for their visitors to interact with them. With this kind of technology (CDOSYS), you can receive emails from your visitors without letting the general public know your email address, reducing the spammer activity on your site.

This following tutorial will show you how you could send email using ASP built in component to a remote server.

The Basic HTML

Before we start worrying about how to send the email, let’s make a basic HTML form that will gather the following information from the user. Save this file with .htm extension, in this example I’ll name them as contact.htm.

<html>
<head>
<title>Tutorial: Send Email Using CDOSYS</title>
</head>
<body>

<form name="feedback" method="post" action="cdosys_mail.asp">
    Your Name : <input type="text" name="txtName">
    Your Email Address: <input type="text" name="txtEmail">
    Cc: <input type="text" name="txtCc">
    Bcc <input type="text" name="txtBcc">
    Subject: <input type="text" name="txtSubject">
    Comment/Suggestion : <textarea name="txtComment"></textarea>
    <input name="submit" type="submit">
</form>

</body>
</html>

The CDOSYS

Now that we have our HTML Form ready, we need to create the ASP file containing the CDOSYS code that will retrieve this data and shoot off an email. All the properties that are set in the following code are self-explanatory and write only. Please take note that a Message is an object, it must be Set equal to nothing after we have finished with it to release the memory allocated to it.

Save this file with .asp extension and in the same directory with your previous html form. In our previous html form, we have a form action pointing to cdosys_mail.asp which is the name that we will give to this page.

<%
Dim txtName, txtEmail, txtCc, txtBcc, txtSubject, txtComment, htmlBody
    txtName = Request.Form("txtName")
    txtEmail = Request.Form("txtEmail")
    txtCc = Request.Form("txtCc")
    txtBcc = Request.Form("txtBcc")
    txtSubject = Request.Form("txtSubject")
    txtComment = Request.Form("txtComment")

    htmlBody = "<b>Tutorial: Send Email Using CDOSYS</b><br>"
    htmlBody = htmlBody & txtComment

Dim objCDOSYSCon
Set objCDOSYSMail = Server.CreateObject("CDO.Message")
Set objCDOSYSCon = Server.CreateObject ("CDO.Configuration")
	objCDOSYSCon.Fields("http://schemas.microsoft.com/cdo/configuration/smtpserver") = "YourMailServerAddress"
	objCDOSYSCon.Fields("http://schemas.microsoft.com/cdo/configuration/smtpserverport")  = 25 'Your mail SMTP Port Number
	objCDOSYSCon.Fields("http://schemas.microsoft.com/cdo/configuration/sendusing") = 2
	objCDOSYSCon.Fields("http://schemas.microsoft.com/cdo/configuration/smtpconnectiontimeout") = 60 'Timeout Setting
	objCDOSYSCon.Fields.Update

Set objCDOSYSMail.Configuration = objCDOSYSCon
    objCDOSYSMail.From = txtEmail
    objCDOSYSMail.To = webmaster@mywebsite.com 'Set your email address here!
    objCDOSYSMail.Cc = txtCc
    objCDOSYSMail.Bcc = txtBcc
    objCDOSYSMail.Subject = txtSubject
    objCDOSYSMail.HTMLBody = htmlBody
    objCDOSYSMail.Send 'Send the email out

'Clear connection and redirect user
Set objCDOSYSMail = Nothing
Set objCDOSYSCon = Nothing
Set adoCon = Nothing

Response.Redirect "email_successfully_sent_message.asp"
%>

Please note that this is a very basic ASP Email Form and is only for tutorial purposes. If you were to use this code on your web site, you would want to do some form validation to make sure the email addresses are valid, compulsory field are filled in, allow for attachments, etc.

That’s just it. Your site are now ready to received email from your visitors!

Download The Full Code

Source: W3Schools Tizag

The Global.ASA file

In this quick little tutorial, we are going to take a look at building a routine that checks to see how many people are accessing your web site at any particular time. In order to achieve this, we are going to use something called the global.asa file.

What is the global.asa file?

As you all probably know, “ASP” stands for Active Server Pages. We use ASP pages to execute script on the server enabling us to interact with databases and create dynamic content for our web site. “ASA” on the other hand stands for “Active Server Application”.

The “global.asa” file is created in order to contain scripts that can be accessed “globally” by the entire web site.
The Global file is a file in which (amongst other things) you can specify event scripts and declare objects that have session or application wide scope. It is not a content file and nothing in it is displayed directly to the users; instead it stores event information and objects used globally by the application.

• The file must be named global.asa
• It must be stored in the root directory your application/website (/global.asa).
• Your application can only have one global.asa file.

What are Applications and Sessions?

Application:
As mentioned above, an application (in ASP terms) refers to your asp web site. An Application starts when the web server is switched on and ends when the web server stops.

Session:
A Session starts from the time a visitor starts looking at your site and ends (in theory) when the visitor leaves your site. In practice though, a session has a 20 minute default “timeout”. In order to keep track of the session a cookie is created for the visitor. This cookie is deleted when the user closes his browser. All session data is stored on the server.

Global.asa file content.

A typical gobal.asa file would contain the following events:

• Application_OnStart – Is executed when the server is switched on and before the first session is started.
• Application_OnEnd – Is executed when the application is finished (i.e. the server is switched off).
• Session_OnStart – Is executed when the server creates a new session (i.e. when a new client accesses your web site).
• Session_OnEnd – Is executed when a session is abandoned or after certain period of inactivity between the visitor and the server (by default after a lapse of 20 minutes from the last request from a visitor the server will consider he is not going to come back and will delete any information related to that session).

Script for the global.asa file:

<Script Language="VBScript" RUNAT="Server">
Sub Application_OnStart
    Application( "WhosOnline" ) = 0
End Sub
Sub Application_OnEnd
End Sub
Sub Session_OnStart
    Application.Lock
    Application( "WhosOnline" ) = Application( "WhosOnline" )+1
    Application.UnLock
End Sub
Sub Session_OnEnd
    Application.Lock
    Application( "WhosOnline" ) = Application( "WhosOnline" )-1
    Application.UnLock
End Sub
</Script>

What the script does…

Script for displaying the results on a web page…

Displaying the results on a page is simply a case of adding this 1 line of code to the area on your page where you want the number to be displayed.

There are currently <%=Application("WhosOnline")%> active visitors!

See how simple it is in retrieving the value of your active visitors counter stored in the application object. Now, every time a visitor comes to your .asp application / homepage you can see the actual number of visitors in your page. Also, you can extend the code above to use images of numbers as your counter display.

And that’s about it really. Just a few things to remember!

• You can only have one global.asp file for your web site but that file can contain more than one sub routine.
• The global.asp file must live in the root folder for your site.
• If you already have a global.asp for your site simply add the code we have been discussing to the file.
• If you are embarrassed by the lack of people on your site at any particular time you can cheat by changing the “0″ in line 3 to a higher starting number.

Have fun with ASP…!

Cache No More!

<% @LANGUAGE="VBSCRIPT" %>
<%
Option Explicit
Response.Buffer = True

'Make sure this page is not cached by the browser!
Response.Expires = -1
Response.ExpiresAbsolute = Now() - 1
Response.AddHeader "pragma","no-cache"
Response.AddHeader "cache-control","private"
Response.CacheControl = "No-Store"

'Description:
#07 That sets an immediate expiration on the file. Thus it dies the moment is it born.
#08 Says "Expire this page 24 hours ago", allowing for time differences, rather than specify a static date.
#09 Tell the browser not to cache the page.
#10 Better safe than sorry!
#11 Tell the browser not to store anything from this page.
%>