ASP - ASP.Net - Active Server Pages Tutorial

ASP.NET with Visual Studio.NET Setup

2009-02-05T21:03:00.000-08:00

Demo Requirements

This session requires 1 machine (called Server1 in this document).

Minimum Hardware Requirements: Server1

Processor	400Mhz
Memory	256mb
Disk Space	6GB

Software required before demo installation: Server1

Required Operating Systems	Windows 2000 Professional, Server, or Advanced Server, or Windows XP
Applications	SQL 2000 Developer or Enterprise
	Visual Studio.NET

Manual installation instructions:

Demo Machine Setup

To set up the hardware

Set up the hardware according to the manufacturer’s instructions. (Refer to the Minimum Hardware Requirements section in this document.)

Create a basic install of Windows 2000 Advanced Server or XP

Select to create or convert to a NTFS partition during setup.
Reboot the PC once installation is completed

To configure FrontPage 2000 Server Extensions

Open Control Panel.
Click Add/Remove Windows Components.
Double-click on Internet Information Services (IIS).
Select FrontPage 2000 Server Extensions.
Click OK.
Click Next.
Click Finish.
Click Close.

Install SQL Server 2000 Enterprise Edition

Walk through the SQL setup accepting all defaults EXCEPT for the Authentication Mode page, which should be changed to Mixed Mode. Use a blank password for the sa login.

Install VS.NET

Launch setup.exe from the VS.NET installation CD.
Select Windows Component Update.
Click Browse and select VS.NET\WCU subdirectory.
Click OK twice.
From here, proceed with default installation options (the machine will reboot a number of times).
When Windows Component Update installation is completed, proceed with installation of Visual Studio.NET and continue with default installation options.

Configure ASP.NET Permissions

Navigate to C:\[Windows]\Microsoft.NET\Framework\[Version]\Config.
Open machine.config in a text editor.
Find the tag.
Change the userName attribute to SYSTEM.
Save machine.config.
Navigate to Start | Run.
Enter IISReset, and click Ok.

To install and configure the demo files

Install DEVT1-25.MSI.

Setup demos

1. Navigate to C:\FieldContent\DEVT1-25\Demos\Demo setup.

2. Right-click on Setup.vbs, and select Open with Command Prompt.

3. Wait for the setup to complete.

A Beginner's Guide to Sending Email from an ASP Page

2009-02-05T20:59:00.000-08:00

In this tutorial, we will learn how to send email from an Active Server Page using CDONTS (Microsoft Collaboration Data Objects for Windows NT Server). Although there are other CDONTS objects, we will focus solely on the NewMail object in this tutorial. We will cover most of the properties and methods of the NewMail object, and will develop, step by step, a complete and thorough example.

It is assumed that the reader has some familiarity with creating ASP pages using VBScript. (Note: If you are viewing this tutorial from a downloaded zip file, the links will not work.)

We begin by declaring an object of type NewMail.

<%
Dim MyMail
Set MyMail = Server.CreateObject("CDONTS.NewMail")
%>

We then use the From property of the NewMail object to indicate the sender of the message. The From property is required, and multiple senders are not permitted. The type of this property is String.

<%
Dim MyMail
Set MyMail = Server.CreateObject("CDONTS.NewMail")
MyMail.From = "justme@myaddress.com"
%>

Analogously, we use the To property of the NewMail object to identify the recipients of the message. This property is also of type String. At least one of the To, Cc or Bcc properties (Cc and Bcc properties discussed subsequently) must be nonempty. Each recipient must be addressed in full, with multiple recipients separated by semicolons.

<%
Dim MyMail
Set MyMail = Server.CreateObject("CDONTS.NewMail")
MyMail.From = "justme@myaddress.com"
MyMail.To = "friend1@address1.com;friend2@address2.com"
%>

The Cc property (for indicating recipients of copies of the message) and Bcc property (for indicating recipients of blind copies) work exactly like the To property. Neither of these properties is required, however, and both are of String type.

It is important to include a subject line in our email messages, so we do that next using the Subject property, which is of type String. This property is not required, however, and could be set to an empty string.

The BodyFormat property sets the text format of the NewMail object. It is of type Long, and has two possible values: 0, which indicates that the body of the message includes Hypertext Markup Language (HTML); or 1, which indicates that the body of the message is exclusively plain text. The default value for the BodyFormat property is 1, so this property does not need to be set for plain text messages. Our example message will be in plain text, but, for demonstration purposes, we will explicitly set the BodyFormat property.

The MailFormat property sets the encoding for the NewMail object. It is of type Long, and has two possible values: 0, which indicates that the object is to be in MIME (Multipurpose Internet Mail Extension) format; or 1, which indicates that the object is to be in uninterrupted plain text. This property is optional, and its default value is 1. This property determines the default value for the EncodingMethod parameter in the AttachFile method (to be discussed later). Since we will be including an image attachment (later), we will set the MailFormat property to 0 now.

The Importance property (optional) allows us to set the importance associated with the NewMail object. Its type is Long, and the possible values are: 0, indicating low importance; 1, indicating normal importance (default); and 2, indicating high importance. Our message is very important, so we will set the Importance property accordingly.

To set the text of the NewMail object, we use the Body property, which can consist of plain text only, or can contain HTML (as described in the discussion of the BodyFormat property). The Body property is either of type String or Istream object (C/C++/Java only). The Body property is not required, so it is possible to send a message with no body text at all. In fact, if you really want to be mysterious, you can send a message with no subject and no body! We, however, have an important message to send, so we will provide text for the Body property.

<%
Dim MyMail
Set MyMail = Server.CreateObject("CDONTS.NewMail")
MyMail.From = "justme@myaddress.com"
MyMail.To = "friend1@address1.com;friend2@address2.com"
MyMail.Cc = "friend3@address3.com;friend4@address4.com"
MyMail.Bcc = "friend5@address5.com;friend6@address6.com"
MyMail.Subject = "sending email via CDONTS NewMail"
MyMail.BodyFormat = 1
MyMail.MailFormat = 0
MyMail.Importance = 2
MyMail.Body = "Sending email with CDONTS NewMail" &_
"objects is easy! Try it!"
%>

If we wish to include an attachment with our mail message, we use the AttachFile method of the NewMail object. This method has three parameters.

The first parameter is Source, of type String or Istream object. This parameter is required, and must contain the full path and file name of the attachment. Only C/C++ and Java programs can use an Istream object.

The second (optional) parameter is FileName, of type String. This provides a file name to appear in the attachment's placeholder in the message. If not specified, the file name from the Source parameter is used.

The third (optional) parameter is EncodingMethod, of type Long, which indicates the encoding of the attachment. There are two possible values: 0, meaning the attachment is in UUEncode format; and 1, indicating the attachment is in Base64 format. (Base64 is the encoding scheme defined by MIME; UUEncode is an older format that you should use if you suspect your recipient(s) may not have a MIME-compliant system.) The default value of this parameter depends upon the MailFormat property. If the MailFormat property is set to 1, the default value of EncodingMethod is 0. If the MailFormat property is set to 0, the default value of EncodingMethod is 1.

In our example, we have already set the MailFormat property to 0, but we will still explicitly assign a value of 1 to the EncodingMethod parameter, for demonstration purposes.

At last, we are ready to use the NewMail object's Send method to send our email. After the Send method executes, the NewMail object becomes invalid and cannot be used for another message. Therefore, being conscientious programmers, we set that object to Nothing to release the memory. (We also do this because an accidental access of any kind to the NewMail object after Send executes will raise an embarrassing error!)

That should do it!

We conclude by mentioning that the Send method has optional parameters for From, To, Subject, Body and Importance (in that order). Therefore, we can include values for these properties when calling the Send method, rather than explicitly assigning values to the corresponding properties of the NewMail object. If the To property has already been given a value, and is also supplied as a parameter to the Send method, the message is sent to all recipients in both lists. If the other properties have been given values previously, and specified again in the Send parameters, the prior values are overwritten.

In our example code segment, if we reached the point of calling the Send method and decided to add a recipient to our mailing list, and also change the text of the subject line, this could be done as shown below. The original recipients specified in the To property would receive the message, in addition to the new recipient. The Subject property would be changed, but the From, Body, and Importance properties would retain their earlier values, as would the other NewMail properties. Note that a comma appears after the call to Send, but before the string intended for the To property. This is because we are not modifying the From property, which is the first parameter to the Send method. Without the comma, "youtoo@youraddress.com" would become the From property value, and "new subject" would be appended to the To property value. Delineating commas are not required after the last explicitly-provided parameter.

Now that you know all about the CDONTS NewMail object, let's look at how to put this all together in a working user interface. We offer two ways to do this. (Note: If you are viewing this tutorial from a downloaded zip file, the links will not work.)

You can see an example of an cdonts email submission form.

Or you can download a zip copy of this tutorial and its supporting form-handling pages to see how they work. Further you can easily customize these email forms for your own needs.

Note, however, that our sample user interface does not provide a means for the client to specify an attachment. This is because the Request.Form method used to process the form is limited in that it only allows plain text upload, and users often wish to include attachments in alternative formats. If you wish to add attachment capability and support it fully, the Request.Form method must be augmented with additional software, e.g. dgFileUpload.

[NOTE]
If you are using CDOSYS for Windows 2000 or Windows XP, the code will be be slightly different, as shown below:

<%
Dim MyMail
Set MyMail = Server.CreateObject("CDO.Message")
MyMail.From = "justme@myaddress.com"
MyMail.To = "friend1@address1.com;friend2@address2.com"
MyMail.Cc = "friend3@address3.com;friend4@address4.com"
MyMail.Bcc = "friend5@address5.com;friend6@address6.com"
MyMail.Subject = "Sending Mail via CDOSYS for Windows 2000/XP"
MyMail.TextBody = "Sending email with CDOSYS Message " &_
"objects is easy! Try it!"
MyMail.AddAttachment "c:\path\smiley.gif"
MyMail.Fields("urn:schemas:httpmail:importance").Value = 2;
MyMail.Fields.Update()
MyMail.Send()
Set MyMail = Nothing
%>

[END NOTE]

Session management in ASP.NET

2008-11-20T01:45:00.000-08:00

Session Management

Importance

HTTP is stateless, means that the web pages don’t know if the requests are from the same client and pages are recreated and destroyed every trip to the server. Therefore, state management is important for web applications.

Methods

All data that needs to be available to the application across different requests within the same session is called session state or session state data. For storing such data between requests, there are in general two possibilities:

· Sending the state information back to the client. With the next request the current state is transmitted to the server again.

· Keeping the necessary data structures on the server. No session data (except the referencing identifier) is transmitted to the client.

1.1.1 Drawbacks of managing state information in client

· Sending the session state data back to the client is generally not recommended. From a security perspective, the main problem is that the session state can easily be manipulated on the client side if it is not protected appropriately.

· In scenarios where session state information must be transmitted back to the client, it is generally possible to sign all transmitted session state information in order to prevent changes on the client side. When the server receives session state information within requests from the client, it can check the signature in order to verify that the data was not altered.

· A functional drawback is that the size of the information that can be stored by round-tripping it to the client side is limited through the available bandwidth. For session state data that consists of only a few bytes this does not matter. However, in scenarios with larger session state data structures, re-transmitting them with each request becomes impractical.

1.1.2 State management in server

Keeping the session state strictly on the server is the recommended solution.

· Session state is stored in the server RAM.

· Session state is serialized and written to a persistent storage.

· Storing mechanism for session is irrelevant from a session management security point of view.

· Ensure that the session state information is sufficiently protected against illegal access on the server side.

1.1.3 Session IDs

Typically, the process of managing the state of a web-based client is through the use of session IDs. Session IDs are used by the application to uniquely identify a client browser, while background (server-side) processes are used to associate the session ID with the existing state of the user. Session state management is a key element of Web application design. ASP.NET contains a session state support service that is flexible and scalable.

1.2 Methods of implementing Session States in ASP .NET

There are three session state modes for ASP.NET Applications. Each mode offers varying degrees of performance and scalability as described in the following list:

1.2.1 InProc

The in-process store provides the fastest access to session state. There is no serialization or marshaling costs involved because state is maintained within the managed memory of the ASP.NET process. When the process recycles, the state data is lost, although we can disable process recycling in IIS if process recycling affects the application.

Drawbacks:

· Limits application scalability

· Cannot use it in conjunction with multiple worker processes.

· Also, high numbers of large or concurrent sessions can cause application to run out of memory.

1.2.2 State Server

The session state service, a Microsoft Win32® service, can be installed on local Web server or on a remote server that is accessible by all Web servers in a Web farm.

Advantage:

· High Scalability.

Limitation:

· Performance is reduced in comparison to the in-process provider because of the additional serialization and marshaling that is required to transfer the state to and from the state store.

1.2.3 SQL Server:

Microsoft SQL Server provides a highly scalable and easily available solution. SQL Server is a solution that is well-suited to large amounts of session state.

The serialization and marshalling costs are the same as the costs for the session state service, although overall performance is slightly lower.

SQL Server provides clustering for failover, although this is not supported in the default configuration for session state. To enable clustering for failover, we have to apply configuration changes, and the session data must be stored in a non temporary table.

1.3 Administering Session states in server

Developers can use Session state in applications and leave the implementation up to the administrators. When developer creates an ASP.NET application on his development machine, he can use in-process session state. Then when the application is deployed to a production server Web farm, an administrator can change session state to use either the ASP.NET State service or to host the session data in SQL Server. All of these options are transparent to the application. A simple setting in Web.Config makes the change in session state.

If your application does not require the ASP.NET session state services, turn it off. You can do this on a single page or for an entire application. You can disable session state in a page by adding EnableSessionState="false" in the Page directive like this:

<%@ Page Language="C#" EnableSessionState="false" AutoEventWireup="false" Codebehind="WebForm1.aspx.cs" Inherits="WebApplication2.WebForm1"%>

You can also totally disable session state for an application by setting mode=”Off” in Web.Config like this:

mode="Off" stateConnectionString="tcpip=127.0.0.1:42424"

sqlConnectionString="data source=127.0.0.1;user id=sa;password="

cookieless="false"

timeout="20" />

1.4 Why web farms?

Scalability and high availability is the answer.

Once a web application has gained enough business traction to be handling thousands of concurrent users and hundreds of requests per second, it inevitably bumps up against the performance limits imposed by running on a single server.

1.4.1 Performance limits of a single server:

· Even we do caching, session state accumulate to the point where they tax available memory, causing frequent processor-intensive garbage collection events and even recycling of worker processes, with loss of in-memory data.

· The available ASP.NET threads become exhausted and requests start to queue, eventually leading to error conditions.

· The server may not be available to fulfill the request all time.

The solution is to spread the load across clustered application servers, usually referred to as a “web farm.”

The move from a single server to a web farm often causes significant disruptions, unless the application has been architected from the beginning to support load-balanced clustered request processing. Without explicit planning, many applications end up with hidden dependencies on resource affinity.

1.4.2 Resource affinity is ASP.NET Applications in web farms:-

“Resource affinity” refers to a requirement for code to run on a particular thread, CPU, component instance or server. The Session is a resource. The most common affinity problem in ASP.NET applications is the use of in-process session state, which assumes that all requests from a single user session will be processed on the same web server.

1.4.3 Resolving session affinity in ASP.NET Applications in web farms:

· Route all requests to the server where the session originated. This significantly reduces load balancing efficiency, and it impairs the ability of the ASP.NET application to tolerate failures such as recycling the worker-thread process under extreme load.

· Storing session state in a shared location, this can be accessed by any of the web servers in the farm.

1.4.4 Session sharing in web farms:

ASP.NET has built-in support for storing session state out-of-process, either in a database or in the memory space of a designated state server.

Advantage:-

· By moving session state out-of-process, the dependency of a given user on a given web server is reduced: if that web server fails or recycles, the user’s current session data is not lost.

1.5 Implementing out-of-process session state storage

For out-of-process state storage to be possible, all .NET objects stored in session state must be serializable. Because .NET classes are not serializable by default, this often means recoding, either to add attributes to user-defined classes or to use serializable built-in classes instead of ones that are not serializable.

1.5.1 State Server

State Server is simple, free software available with ASP.NET for storing session state data. It can be run directly on the web server, at least providing protecting from worker-thread recycling, or it can be run in a central location to get the full benefits of non-affinity.

Limitations of State Server:

· When using State Server remotely—every request/response pair involves two trips to the State Server, one to retrieve the session state data at the beginning of the generation of the response and another to return the modified session state data when the response is completed.

· When it fails or restarted all the session data is lost

1.5.2 SQL Server

SQL Server is a popular choice for out-of-process session state storage.

Advantages:-

· The application is already using SQL Server for retrieval and storage of data related to the application.

· High availability features such as clustering to protect session state data in case of failure.

Limitations:

· The performance of SQL Server is even slower than that of State Server.

· SQL Server is designed to be a highly reliable and secure transactional database, so the processing of session data takes significantly longer.

· SQL Server also requires the same extra pair of network trips that State Server does: at the beginning and end-of-page processing.

Beginners IV

2008-11-20T01:42:00.002-08:00

ASP Response Object

The ASP Response object is used to send output to the user from the server.

Response Object

The ASP Response object is used to send output to the user from the server. Its collections, properties, and methods are described below:

Collections

Collection	Description
Cookies	Sets a cookie value. If the cookie does not exist, it will be created, and take the value that is specified

Properties

Property	Description
Buffer	Specifies whether to buffer the page output or not
CacheControl	Sets whether a proxy server can cache the output generated by ASP or not
Charset	Appends the name of a character-set to the content-type header in the Response object
ContentType	Sets the HTTP content type for the Response object
Expires	Sets how long (in minutes) a page will be cached on a browser before it expires
ExpiresAbsolute	Sets a date and time when a page cached on a browser will expire
IsClientConnected	Indicates if the client has disconnected from the server
Pics	Appends a value to the PICS label response header
Status	Specifies the value of the status line returned by the server

Methods

Method	Description
AddHeader	Adds a new HTTP header and a value to the HTTP response
AppendToLog	Adds a string to the end of the server log entry
BinaryWrite	Writes data directly to the output without any character conversion
Clear	Clears any buffered HTML output
End	Stops processing a script, and returns the current result
Flush	Sends buffered HTML output immediately
Redirect	Redirects the user to a different URL
Write	Writes a specified string to the output

ASP Request Object

The ASP Request object is used to get information from the user.

QueryString Collection Examples

Send query information when a user clicks on a link
This example demonstrates how to send some extra query information to a page within a link, and retrieve that information on the destination page (which is, in this example, the same page).

A QueryString collection in its simplest use
This example demonstrates how the QueryString collection retrieves the values from a form. The form uses the GET method, which means that the information sent is visible to everybody (in the address field). The GET method also limits the amount of information that can be sent.

How to use information from forms
This example demonstrates how to use the values retrieved from a form. We use the QueryString collection. The form uses the get method.

More information from a form
This example demonstrates what the QueryString contains if several input fields have the same name. It shows how to separate input fields with equal names from each other. It also shows how to use the Count keyword to count the "name" property. The form uses the get method.

Form Collection Examples

A form collection in its simplest use
This example demonstrates how the Form collection retrieves the values from a form. The form uses the POST method, which means that the information sent is invisible to others, and it has no limits (you can send a large amount of information).

How to use information from forms
This example demonstrates how to use the values retrieved from a form. We use the Form collection. The form uses the post method.

More information from a form
This example demonstrates what the Form collection contains if several input fields have the same name. It shows how to separate input fields with equal names from each other. It also shows how to use the Count keyword to count the "name" property. The form uses the post method.

A form with radio buttons
This example demonstrates how to interact with the user through radio buttons, with the Form collection. The form uses the post method.

A form with checkboxes
This example demonstrates how to interact with the user through checkboxes, with the Form collection. The form uses the post method.

Other Examples

Get the server variables
This example demonstrates how to find out the visitors (yours) browser type, IP address, and more with the ServerVariables collection.

Create a welcome cookie
This example demonstrates how to create a Welcome Cookie with the Cookies Collection.

Find the total number of bytes the user sent
This example demonstrates how to use the TotalBytes property to find out the total number of bytes the user sent in the Request object.

Request Object

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. Its collections, properties, and methods are described below:

Collections

Collection	Description
ClientCertificate	Contains all the field values stored in the client certificate
Cookies	Contains all the cookie values sent in a HTTP request
Form	Contains all the form (input) values from a form that uses the post method
QueryString	Contains all the variable values in a HTTP query string
ServerVariables	Contains all the server variable values

Properties

Property	Description
TotalBytes	Returns the total number of bytes the client sent in the body of the request

Methods

Method	Description
BinaryRead	Retrieves the data sent to the server from the client as part of a post request and stores it in a safe array

<%
dim fname
fname=Request.QueryString("fname")
If fname<>"" Then
Response.Write("Hello " & fname & "!
")
Response.Write("How are you today?")
End If
%>

<%
If Response.IsClientConnected=true then
Response.Write("The user is still connected!")
else
Response.Write("The user is not connected!")
end if
%>

ASP Quick Reference

ASP Quick Reference from W3Schools. Print it, and fold it in your pocket.

Basic Syntax

ASP scripts are surrounded by <% and %>. To write some output to a browser:

<% response.write("Hello World!") %>

The default language in ASP is VBScript. To use another scripting language, insert a language specification at the top of the ASP page:

<%@ language="javascript" %>

<%
....
%>

Forms and User Input

Request.QueryString is used to collect values in a form with method="get". Information sent from a form with the GET method is visible to everyone (it will be displayed in the browser's address bar) and has limits on the amount of information to send.

Request.Form is used to collect values in a form with method="post". Information sent from a form with the POST method is invisible to others and has no limits on the amount of information to send.

ASP Cookies

A cookie is often used to identify a user. A cookie is a small file that the server embeds on the user's computer. Each time the same computer requests for a page with a browser, it will send the cookie too.

The Response.Cookies command is used to create cookies:

<%
Response.Cookies("firstname")="Alex"
Response.Cookies("firstname").Expires="May 10,2002"
%>

Note: The Response.Cookies command must appear BEFORE the tag!

The "Request.Cookies" command is used to retrieve a cookie value:

<%
fname=Request.Cookies("firstname")
response.write("Firstname=" & fname)
%>

Including Files

You can insert the content of one ASP file into another ASP file before the server executes it, with the #include directive. The #include directive is used to create functions, headers, footers, or elements that will be reused on multiple pages

Syntax:

Use the virtual keyword to indicate a path beginning with a virtual directory. If a file named "header.inc" resides in a virtual directory named /html, the following line would insert the contents of "header.inc":

Use the file keyword to indicate a relative path. A relative path begins with the directory that contains the including file. If you have a file in the html directory, and the file "header.inc" resides in html\headers, the following line would insert "header.inc" in your file:

Use the file keyword with the syntax (..\) to include a file from a higher-level directory.

Global.asa

The Global.asa file is an optional file that can contain declarations of objects, variables, and methods that can be accessed by every page in an ASP application.

Note: The Global.asa file must be stored in the root directory of the ASP application, and each application can only have one Global.asa file.

The Global.asa file can contain only the following:

Application events

Session events

declarations

TypeLibrary declarations

the #include directive

Application and Session Events

In Global.asa you can tell the application and session objects what to do when the application/session starts and what to do when the application/session ends. The code for this is placed in event handlers. Note: We do not use <% and %>, to insert scripts in the Global.asa file, we have to put the subroutines inside the HTML

Declarations

It is also possible to create objects with session or application scope in Global.asa by using the tag. Note: The tag should be outside the

Note: Because we cannot use the ASP script delimiters (<% and %>) to insert scripts in the Global.asa file, we put subroutines inside an HTML

Global.asa can also be used to control page access.

The example below shows how to redirect every new visitor to another page, in this case to a page called "newpage.asp":

And you can include functions in the Global.asa file.

In the example below the Application_OnStart subroutine occurs when the Web server starts. Then the Application_OnStart subroutine calls another subroutine named "getcustomers". The "getcustomers" subroutine opens a database and retrieves a record set from the "customers" table. The record set is assigned to an array, where it can be accessed from any ASP page without querying the database:

Global.asa Example

In this example we will create a Global.asa file that counts the number of current visitors.

The Application_OnStart sets the Application variable "visitors" to 0 when the server starts

The Session_OnStart subroutine adds one to the variable "visitors" every time a new visitor arrives

The Session_OnEnd subroutine subtracts one from "visitors" each time this subroutine is triggered

The Global.asa file:

To display the number of current visitors in an ASP file:

There are <%response.write(Application("visitors"))%>

This is a message.

myMail.Send

set myMail=nothing

Sending an HTML e-mail that sends a webpage from a website:

Set myMail=CreateObject("CDO.Message")

myMail.Subject="Sending email with CDO"

myMail.From="mymail@mydomain.com"

myMail.To="someone@somedomain.com"

myMail.CreateMHTMLBody "http://www.w3schools.com/asp/"

myMail.Send

set myMail=nothing

Sending an HTML e-mail that sends a webpage from a file on your computer:

Set myMail=CreateObject("CDO.Message")

myMail.Subject="Sending email with CDO"

myMail.From="mymail@mydomain.com"

myMail.To="someone@somedomain.com"

myMail.CreateMHTMLBody "file://c:/mydocuments/test.htm"

myMail.Send

set myMail=nothing

Sending a text e-mail with an Attachment:

Set myMail=CreateObject("CDO.Message")

myMail.Subject="Sending email with CDO"

myMail.From="mymail@mydomain.com"

myMail.To="someone@somedomain.com"

myMail.TextBody="This is a message."

myMail.AddAttachment "c:\mydocuments\test.txt"

myMail.Send

set myMail=nothing

Sending a text e-mail using a remote server:

Set myMail=CreateObject("CDO.Message")

myMail.Subject="Sending email with CDO"

myMail.From="mymail@mydomain.com"

myMail.To="someone@somedomain.com"

myMail.TextBody="This is a message."

myMail.Configuration.Fields.Item _

("http://schemas.microsoft.com/cdo/configuration/sendusing")=2

'Name or IP of remote SMTP server

myMail.Configuration.Fields.Item _

("http://schemas.microsoft.com/cdo/configuration/smtpserver") _

="smtp.server.com"

'Server port

myMail.Configuration.Fields.Item _

("http://schemas.microsoft.com/cdo/configuration/smtpserverport") _

=25

myMail.Configuration.Fields.Update

myMail.Send

set myMail=nothing

ASP Application Object

2008-11-20T01:40:00.000-08:00

A group of ASP files that work together to perform some purpose is called an application. The Application object in ASP is used to tie these files together.

Application Object

An application on the Web may be a group of ASP files. The ASP files work together to perform some purpose. The Application object in ASP is used to tie these files together.

The Application object is used to store and access variables from any page, just like the Session object. The difference is that ALL users share one Application object, while with Sessions there is one Session object for EACH user.

The Application object should hold information that will be used by many pages in the application (like database connection information). This means that you can access the information from any page. It also means that you can change the information in one place and the changes will automatically be reflected on all pages.

Store and Retrieve Application Variables

Application variables can be accessed and changed by any page in the application.

You can create Application variables in "Global.asa" like this:

In the example above we have created two Application variables: "vartime" and "users".

You can access the value of an Application variable like this:

There are

Response.Write(Application("users"))

active connections.

Loop Through the Contents Collection

The Contents collection contains all application variables. You can loop through the Contents collection, to see what's stored in it:

dim i

For Each i in Application.Contents

Response.Write(i & "
")

If you do not know the number of items in the Contents collection, you can use the Count property:

dim i

dim j

j=Application.Contents.Count

For i=1 to j

Response.Write(Application.Contents(i) & "
")

Loop Through the StaticObjects Collection

You can loop through the StaticObjects collection, to see the values of all objects stored in the Application object:

dim i

For Each i in Application.StaticObjects

Response.Write(i & "
")

Lock and Unlock

You can lock an application with the "Lock" method. When an application is locked, the users cannot change the Application variables (other than the one currently accessing it). You can unlock an application with the "Unlock" method. This method removes the lock from the Application variable:

Application.Lock

'do some application object operations

Application.Unlock

ASP Session Object & Cookies

2008-11-20T01:39:00.000-08:00

The Session object

When you are working with an application, you open it, do some changes and then you close it. This is much like a Session. The computer knows who you are. It knows when you start the application and when you end. But on the internet there is one problem: the web server does not know who you are and what you do because the HTTP address doesn't maintain state.

ASP solves this problem by creating a unique cookie for each user. The cookie is sent to the client and it contains information that identifies the user. This interface is called the Session object.

The Session object is used to store information about, or change settings for a user session. Variables stored in the Session object hold information about one single user, and are available to all pages in one application. Common information stored in session variables are name, id, and preferences. The server creates a new Session object for each new user, and destroys the Session object when the session expires.

When does a Session Start?

A session starts when:

A new user requests an ASP file, and the Global.asa file includes a Session_OnStart procedure

A value is stored in a Session variable

A user requests an ASP file, and the Global.asa file uses the tag to instantiate an object with session scope

When does a Session End?

A session ends if a user has not requested or refreshed a page in the application for a specified period. By default, this is 20 minutes.

If you want to set a timeout interval that is shorter or longer than the default, you can set the Timeout property.

The example below sets a timeout interval of 5 minutes:

Session.Timeout=5

To end a session immediately, you may use the Abandon method:

Session.Abandon

Note: The main problem with sessions is WHEN they should end. We do not know if the user's last request was the final one or not. So we do not know how long we should keep the session "alive". Waiting too long for an idle session uses up resources on the server, but if the session is deleted too soon the user has to start all over again because the server has deleted all the information. Finding the right timeout interval can be difficult!

Tip: If you are using session variables, store SMALL amounts of data in them.

Store and Retrieve Session Variables

The most important thing about the Session object is that you can store variables in it.

The example below will set the Session variable username to "Donald Duck" and the Session variable age to "50":

Session("username")="Donald Duck"

Session("age")=50

When the value is stored in a session variable it can be reached from ANY page in the ASP application:

Welcome <%Response.Write(Session("username"))%>

The line above returns: "Welcome Donald Duck".

You can also store user preferences in the Session object, and then access that preference to choose what page to return to the user.

The example below specifies a text-only version of the page if the user has a low screen resolution:

<%If Session("screenres")="low" Then%>

This is the text version of the page

<%Else%>

This is the multimedia version of the page

<%End If%>

Remove Session Variables

The Contents collection contains all session variables.

It is possible to remove a session variable with the Remove method.

The example below removes the session variable "sale" if the value of the session variable "age" is lower than 18:

If Session.Contents("age")<18>

Session.Contents.Remove("sale")

End If

To remove all variables in a session, use the RemoveAll method:

Session.Contents.RemoveAll()

Loop Through the Contents Collection

The Contents collection contains all session variables. You can loop through the Contents collection, to see what's stored in it:

Session("username")="Donald Duck"

Session("age")=50

dim i

For Each i in Session.Contents

Response.Write(i & "
")

Result:

username

age

If you do not know the number of items in the Contents collection, you can use the Count property:

dim i

dim j

j=Session.Contents.Count

Response.Write("Session variables: " & j)

For i=1 to j

Response.Write(Session.Contents(i) & "
")

Result:

Session variables: 2

Donald Duck

Loop Through the StaticObjects Collection

You can loop through the StaticObjects collection, to see the values of all objects stored in the Session object:

dim i

For Each i in Session.StaticObjects

Response.Write(i & "
")