Cross Ref > Language Basics

ASP Classic is not case sensitive. My preference for all languages where case sensitivity does not matter is to use camel caps as in the first example above. Many developers coming from a case sensitive language prefer to use all lowercase.

Syntax Example:   You can use any of the following: Response.Write "Hello" response.write "Hello" RESPONSE.WRITE "Hello" REsponse.WritE "Hello"

In C# commands and variable names are case sensitive. The following does NOT:

messagebox.Show("hello");  //Does not compile!

The first time you type any other case for commands or variables, VS.Net will change it to the accepted or defined case. For example, if you type messagebox.show it is converted to MessageBox.Show. Once corrected, you can break it again by editing MessageBox to messagebox and the compiler will give you an error.

MessageBox.Show("hello");

 C# Case Sensitivity (Yes)  

In .ASP html pages, you embed ASP code between <% and %>.

ASP Classic code blocks are surrounded by statement ending keywords that all use End such as End Sub, End If, and WEnd.

<%

Sub x

End Sub

If x Then

End If

While x

WEnd

%>

C# uses braces {} to indicate a code block of more than one line. For one line of code, the braces are optional.

I prefer to put the opening { and the closing } on their own line only because most of the examples I see do this. As opposed to C++, Java, and JavaScript where I put the opening bracket at the end of the first line (which I actually prefer).

int DoSomething()

{

 int a = 1;

 int b = 2;

 return a + b;

}

Commenting Code
ASP Classic, like all the VB-based languages, uses a single quote (') or the original class-style basic "REM" (most developers just use a quote). ASP Classic does NOT have a multiple line comment.

Preprocessor Directives - @ and #
An @ is used for preprocessor directives within ASP code (within <% %>) and a # is used for HTML-style preprocessor directives.

Note: ASP Classic does not support VB Classic's #If directive.

'Single line comment.

REM Old school single line comment.

<%@LANGUAGE=VBScript%>

<!-- #Include File="includes.inc" -->

 ASP Classic Comments (' or REM)

Commenting Code
C# uses "//" for a single line comment and /* */ for a multiple line comment.

//Single line comment.

/*
Multiple line
comment.

*/

Scope can be Public or Private. Public Const is the same as just specifying Const. As with variables, all constants are variants. You do not specify the type, it's implied.

Const kPI = 3.1459

Const kName = "Mike"

//Public variable:

Public Const kFeetToMeter=3.28, kMeterToFeet=.3

 ASP Classic Constants (Const kPI = 3.1459)

In C#, you define constants with the const keyword.

All constants are part of a class (no global constants) but you can make a constant public and have access to it using ClassName.ConstantName so long as you have added the class to the project. This works even without creating the class as if the public constants were static, but you cannot use the static keyword.

Constants must be of an integral type (sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool, or string), an enumeration, or a reference to null.

Syntax Example:   public class Convert : Object {   public const string kName = "Mike";   //You can declare multiple of the same type too: const Double kFeetToMeter = 3.2808, kMeterToFeet = .3048; }

A return marks the end of a statement and you cannot combine statements on a single line of code. You can break a single statement into two or more code lines by using a space and underscore " _".

Response.Write("Hello1")
Response.Write("Hello2")
Response.Write("Hello3")
 
'The following commented code on a single line does not work...
' Response.Write("Hello4")  Response.Write("Hello5")
 
'Two or more lines works too with a space+underscore:
Response.Write _
  ("Hello6")

C# uses a semicolon ";" as an end of statement specifier and you can put multiple statements on a single line of code if you wish as well as split a single statement into two or more code lines.

Syntax Example:   Console.WriteLine("Hello1"); Console.WriteLine("Hello2"); Console.WriteLine("Hello3"); //Same line works too: Console.WriteLine("Hello4"); Console.WriteLine("Hello5"); //Two or more lines works too: Console. WriteLine ("Hello6");

String literals are quoted as in "Prestwood". If you need to embed a quote use two quotes in a row.

To specify a floating point literal between 1 and -1, you can preceed the decimal with a 0 or not (both work). In other words, preceding and following decimals are allowed (both .1 and 0.1). Trailing decimals are also allowed (1, 1., and 1.0 are all equivalent and allowed).

Response.Write "Hello"

Response.Write "Hello ""Mike""."

'Does ASP evaluate this simple

'floating point math correctly? No! 

If (.1 + .1 + .1) = .3 Then
 Response.Write "Correct"
Else
 Response.Write "Not correct"
End If

String literals are quoted as in "Prestwood". If you need to embed a quote use a slash in front of the quote as in \".

To specify a floating point literal between 1 and -1, you can preceed the decimal with a 0 or not (both work). In other words, preceding decimals are allowed (both .1 and 0.1). Trailing decimals are not allowed.

Console.WriteLine("Hello");
Console.WriteLine("Hello \"Mike\".");

//Does C# evaluate this simple

//floating point math correctly? No! 

if ((0.1 + 0.1 + 0.1) == 0.3)
{
  MessageBox.Show("Correct");
}
else
{
  MessageBox.Show("Not correct");
}

ASP Classic is a loosely typed language. No variable types in ASP (all variables are variants). Declaring variables is even optional unless you use the Option Explicit statement to force explicit declaration of all variables with Dim in that script. Using Option Explicit is strongly recommended to avoid incorrectly typing an existing variable and to avoid any confusion about variable scope.

For example, at the top of my common include file, I have the following:

<%@LANGUAGE=VBScript%>
<%
Option Explicit
'...more code here.

%>

Dim Fullname
Dim Age

Dim Weight

FullName = "Mike Prestwood"

Age = 32

Weight = 154.4

'Declaritive assignment not supported:

''Dim Married = "Y"   '>>>Not supported.

C++, Java, and C# all use C-like variable declaration.

C# has C-like variable declaration and although variables are case sensitive, VS.Net will auto-fix your variable names to the defined case.

C# offers many variable types. Some common types used include short, int, long, float, double, decimal, Int16, UInt16, Int32, Int64, string, and bool.

You can also specify the value when you declare a variable as in:

String FirstName = "Mike";

String LastName = "Prestwood";

Int16 Age = 42;

string FullName;

int16 Age;

double Weight;

FullName = "Mike Prestwood";

Age = 32;

Weight = 154.4;