VB.Net and ASP Classic Cross Reference Guide

VB.Net projects require the .Net framework and any additional dependencies you've added such as Crystal Reports.

In Visual Studio.Net, you can create a Setup and Deployment project by using any of the templates available on the New Project dialog (Other Project Types).

In addition, VB.Net projects also support ClickOnce which brings the ease of Web deployment to Windows Forms and console applications. To get started, right click on your solution in the Solution Explorer, click Properties then select the Security tab. 

In addition, you can use any of the many free and commercially available installation packages.

 VB.Net Deployment Overview  

With ASP Classic, you simply copy your files to a web server that is capable of running ASP pages. This includes your .ASP pages along with supporting files such as images, include files, and database files.

Optionally, you can also deploy a global.asa file which is used to code certain events like application start, application end, session start, and session end.

Microsoft Visual Basic Express Editions (as in Visual Basic 2008 Express Edition) and the full version of Microsoft Visual Studio.Net are the current primary tools. VB.Net is not compatible with VB Classic.

Microsoft Visual Interdev was popular for several  years but isn't used as much any more. Any good editor such as Microsoft Expression Web, etc. will work but debugging is left up to interactive skills.

Common source code file extensions include:

• .SLN - Solution File. Contains solution specific information such as links to the projects within this solution.
• .VBPROJ - VB.Net Project File. Contains project specific information in XML. When adding a file, it is added to the project file.
• .VB -VB.Net source file.
• .Designer.VB -VB.Net form file (a text resource file).

//Sample code snippet from the .vbproj project file:

<ItemGroup>
  <Compile Include="Cyborg.vb" />
  <Compile Include="Form1.vb">
    <SubType>Form</SubType>
  </Compile>

  //...

.asp is the default extension for Active Server Pages (ASP) although some developers will change the default extension in an effort to add an additional security level. Although there is no clear standard for include files, using .INC is common but you must make sure that .INC files are not executed nor displayed.

Language Overview: VB.Net is an OOP language (no global functions or variables). You code using a fully OOP approach (everything is in a class).

Target Platforms: VB.Net is most suitable for creating .Net Framework applications. This includes desktop business application using WinForms and websites using WebForms.

Language Overview: Class-based language. Although you can create classes, ASP is not fully OOP. It is a traditional language with a few OOP extensions. You code in a traditional approach using functions, procedures, and global data, and you can make use of simple classes to help organize your reusable code.

Target Platforms: ASP Classic is most suitable for creating websites targeting any browser (IIS Web Server with ASP Classic installed or equivalent).

Microsoft includes ReportViewer Starting with Visual Studio 2005. You can even surface this .Net solution in your VB Classic application if you wish.

For WebForm applications the client target is the browser (a document interfaced GUI), a common solution is to simply output an HTML formatted page with black text and a white background (not much control but it does work for some situations).

For WinForm applications, Crystal Reports is still very popular with VB.Net developers because it has been bundled with Visual Basic since VB 3, it's overall popularity, and compatibility with many different development tools.

 VB.Net Report Tools Overview

No built-in report writer but because ASP Classic targets a client browser (a document interfaced GUI), a common solution is to simply output an HTML formatted page with black text and a white background (not much control but it does work for some situations).

VB.Net is not case sensitive. If you type any other case for commands or variables, VB.Net will change it to the accepted or defined case. For example, if you type messagebox.show it is converted to MessageBox.Show.

Syntax Example:   The following code works: MessageBox.Show("hello")

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"

VB.Net, like VB Classic code blocks, are surrounded by statement ending keywords that all use End such as End Class, End Sub, End Function, and End If.

Public Class Dog

End Class

Protected Sub MySub

End Sub

Public Shared Function MySharedFunction() As Integer
 MySharedFunction = 12345
End Function 

If x Then

End If

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

%>

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

'Single line comment.
 

REM Old school single line comment.

 VB.Net Comments (' or REM)  

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)

In VB.Net, 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 Shared 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.

Public Class Convert
  Inherits System.Object

  Public Const kName As String = "Mike"

  Private Const kPI Double = 3.1459

  //Declare two or more on same line too:
  Const kFeetToMeter = 3.2808, kMeterToFeet = 0.3048
End Class

 VB.Net Constants (Const kPI Double = 3.1459)  

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)

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 " _".

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

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")

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, preceed the decimal with a 0. If you don't, the compiler will auto-correct your code and place a leading 0. It will change .1 to 0.1 automatically. Trailing decimals are not allowed.

Syntax Example:   Console.WriteLine("Hello") Console.WriteLine("Hello ""Mike"".") 'Does VB.Net evaluate this simple 'floating point math correctly? No!  If (.1 + .1 + .1) = 0.3 Then MsgBox "Correct" Else MsgBox "Not correct" End If

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

Variables are case sensitive but VS.Net will auto-fix your variable names to the defined case. You can declare variables in-line wherever you need them and declarative variable assignment is supported.

Syntax Example:   Dim FullName As String Dim Age As Integer Dim Weight As Double FullName = "Mike Prestwood" Age = 32 Weight = 154.4 'Declaritive variable assignment: Dim Married As String = "Y" MsgBox(Married)

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.

VB.Net is a fully OOP language so both Subs and Functions are methods of a class. A Sub does not return a value while a Function does.

Syntax Example:   Private Sub DoSomething(ByVal pMsg As String) '...some code. End Sub Private Function GetAge(ByVal x As String) As Integer GetAge = 7 End Function

ASP Classic is a non-OOP language with some OOP features. It offers both Subs and Functions. A Sub does not return a value while a Function does. When Subs and Functions are used in a defined class, they become the methods of the class.

Sub SayHello(ByVal pName)
  Response.Write "Hello " + pName + "!<br>"
End Sub
 
Function Add(ByRef pN1, ByRef pN2)
  Add = pN1 + pN2
End Function

 ASP Classic Custom Routines (Sub, Function)

Since all the .Net languages compile into intermediate language (IL), and not to a specific CPU, they do not provide support for inline assembler code.

In VB.Net, inlining is automatically done for you by the JIT compiler for all languages and in general leads to faster code for all programmers whether they are aware of inlining or not.

VB.Net supports both method and operator overloading.

For method overloading, you either use implicit overloading (no special syntax like C#) or use the Overloads keyword. If you use the Overloads keyword, all overloaded methods with the same name in the same class must include the Overloads keyword.

 VB.Net Overloading (Overloads, or implicit)  

ASP Classic does not support any type of overloading.

• Operator - No.
• Method - No.

Some developers like to pass in an array and then handle the array for a pseudo technique. Although not overloading, it's useful.

 ASP Classic Overloading (Not Supported)

By Reference or Value
For parameters, you can optionally specify ByVal or ByRef. ByVal is the default if you don't specify which is changed from VB Classic (in VB Classic, ByRef was the default).

Syntax Example:   Private Function Add(ByRef a As Integer, _ ByRef b As Integer) As Integer   Add = a + b End Function

By Reference or Value
For parameters, you can optionally specify ByVal or ByRef. ByRef is the default if you don't specify.

Syntax Example:   Function SomeRoutine(ByRef pPerson, ByVal pName, Age)

To refer to the current instance of a class or structure, use the Me keyword. Me provides a way to refer to the specific instance in which the code is currently executing. It is particularly useful for passing information about the currently executing instance.

The Me keyword is also used as a modifier of the first parameter of an extension method.

You cannot use Me with static method functions because static methods do not belong to an object instance. If you try, you'll get an error.

Syntax Example:   Sub SetBackgroundColor(FormName As Form)   //FormName.BackColor = ...some color End Sub   //Pass Me. SetBackgroundColor(Me)

Same as VB. The Me keyword is a built-in variable that refers to the class where the code is executing.

Class Cyborg
 Public CyborgName
 

 Public Function IntroduceYourself() 
  'Using Me. Prints Cameron.
  Response.Write("Hi, my name is " & Me.CyborgName & ".")

  'The above is just a demo. You could also not include "Me." 

  'in this case because we are in context of Me now. Using Me 

  'makes more sense when you start to pass Me as a parameter 

  'to a method.

 End Function 
End Class

Arrays in ASP Classic use a 0-based indice.

Use UBound to get the number of elements. UBound returns -1 if the array has no elements, 0 if it has 1, 1 if it has 2, etc.

Syntax Example:   Dim MyArray, i MyArray = Array("Mike", "Lisa", "Felicia", "Nathan") If UBound(MyArray) > -1 Then   For i = 0 to UBound(MyArray)     Response.Write MyArray(i)   Next End If

An associative array links a set of keys to a set of values. In Visual Basic, associative arrays are implemented as Dictionaries.

This code produces a message box saying "Nevada."

Syntax Example:   //Imports System.Collections.Generic � Dim States As New Dictionary(Of String, String) States.Add("CA", "California") States.Add("NV", "Nevada") MsgBox(States("NV"))

 Associative Arrays in Visual Basic (a Dictionary)

Use the scriptiing dictionary object which is available on later versions of ASP Classic (all still commonly in use).

Note: Both Access VBA and VB Classic use a collection for this but collections are not supported in ASP Classic.

Dim StateList

set StateList = Server.CreateObject("Scripting.Dictionary")
StateList.Add "CA", "California"
StateList.Add "NV", "Nevada"

Response.Write "I live in " & StateList.Item("CA")

 ASP Classic Associative Array (Scripting.Dictionary)

VB.Net doesn't support pointers. The closest it comes is IntPtr which you use to get pointer handles on windows, files, etc.

C# does have better support for pointers and C++/CLI has extensive support. One solution when it's really needed in VB.Net is to code in C# or C++/CLI and add it to your project.

However, VB.Net does support references.

ASP Classic does not offer developer defined pointers.

VB.Net uses a try...catch...finally statement to trap for errors.

Try
Catch
Finally
End Try

Try
  Dim y As Integer = 0
  y = 1 / y
Catch
  MessageBox.Show("you cannot divide by zero")

End Try

 VB.Net Exception Trapping (Try...Catch...Finally)  

Same as VB classic.

Syntax Example:   If x Then MessageBox.Show("hello") ElseIf Not x Then MessageBox.Show("goodbye") Else MessageBox.Show("what?") End If

The End If is optional if you put your code on a single line.

//Single line example.

If X = True Then Response.Write "hello" 

//Complete example.

If X = True Then
  '>>>do something.

ElseIf Y = "ABC" Then
  '>>>do something.
Else
  '>>>do something.

End If

 ASP Classic If Statement (If..ElseIf..Else..End If)

VB.Net uses = for it's assignment operator.

Syntax Example:   Dim Age As Integer Dim FullName As String FullName = "Randy Spitz" Age = 38

ASP Classic uses = for it's assignment operator.

FullName = "Randy Spitz"
Age = 38

Save as VB Classic. Common comparison operators:

Syntax Example:   //Does VB.Net evaluate the math correctly? No! If 0.1 + 0.1 + 0.1 = 0.3 Then MessageBox.Show("correct") Else MessageBox.Show("not correct") End If

Save as VB Classic. Common comparison operators:

//Does ASP evaluate the math correctly? No!

If .1 + .1 + .1 = .3 Then
  Response.Write "correct"
Else
  Response.Write "not correct"
End If

 ASP Classic Comparison Operators (=, <>)

In .Net, a string can be null or empty. The .Net framework offers a static method in the string class: String.IsNullOrEmpty to check if a string is null or empty.

Syntax Example:   Dim s As String 's = "" 'Uncomment to test 2nd case. If String.IsNullOrEmpty(s) Then   MessageBox.Show("hello") End If

In ASP Classic, you have to add an empty string to the value being compared in order to get consistent results. For example, add &"" to your string varilable or it's code equivalent &vbNullString. Then compare to an empty string or verify it's length to 0 with Len.

If s&"" = "" Then
  Response.Write("<br>Quotes with &'' say null is empty")
End If

 
If Len(s&"") = 0 Then
  Response.Write("<br>Len with &'' says null is empty")
End If

If Len(s&vbNullString) = 0 Then
  Response.Write("<br>Using vbNullString also works!")
End If

 ASP Classic Empty String Check (Len(s&vbNullString))  

VB.Net logical operators:

Syntax Example:   'Given expressions a, b, c, and d: If Not (a and b) and (c or d) Then   'Do something. End If

Same as VB. ASP Classic logical operators:

ASP Classic never short circuits. Given the expression this or that as well as this and that, if this evaluates to false, then that is still executed.

'Given expressions a, b, c, and d:

If Not (a and b) and (c or d) Then

  'Do something.

End If

 ASP Classic Logical Operators (and, or, not)  

To concatenate two strings, use either the + or & operators. The & operator implicitly converts numbers. If you use the + operator to concatenate a string and a number, you have to cast the number as a string with CStr.

Alternatively, you can use the System.Text.StringBuilder class which frequently but not always provides faster code.

Dim FullName

Dim Age

//You can use + for strings.

FullName = "Prestwood"
Console.WriteLine("Hello " + FullName)

//For implicit casting, use &

Age = 35

Console.WriteLine(FullName & " is " & Age & " years old.")

'Implicit casting of numbers.

'

'This works:
MessageBox.Show(3.3)

'This fails:

'MessageBox.Show("" + 3.3)

'This works:
MessageBox.Show("" + CStr(3.3))

'Implicit casting &. This also works:

MessageBox.Show("" & 3.3)

Although you can use either a & or a + to concatenate values, my preference is to use a + because more languages use it. However, if you use & then some type conversions are done for you. If you use + you will sometimes have to cast a value to concatenate it. For example, you will have to use CStr to cast a number to a string if you use the + operator as a concatenation operator.

Dim FirstName
Dim LastName

FirstName  = "Mike"
LastName  = "Prestwood"

Response.Write "Full name: " & FirstName & " " + LastName

Response.Write "2+2=" + CStr(2+2)

An operation with only one operand (a single input). A unary operator method can return any type but takes only one parameter, which must be the type of the containing class. In addition to the obvious +, -, and Not operators, VB.Net also offers:

 VB.Net Unary Operators

An operation with only one operand (a single input) such as +, -, and Not.

 ASP Classic Unary Operators

The above usage of Left and Substring are equivalent.

Left is a traditional VB approach popular with developers moving from VB Classic to VB.Net. Substring is considered the .Net way of doing string manipulation.

Dim FullName

FullName = "Prestwood"
Console.WriteLine("Hello " + Left(FullName, 4))
Console.WriteLine("Hello " + FullName.Substring(0, 4))

In ASP, using ADO, you use RecordSet.AddNew to add a new record, Recordset.Update to post the record, and RecordSet.Delete to delete it. To edit a record, you open the RecordSet using an editable cursor.

objRS.AddNew

objRS.Fields("FullName") = "Barack Obama"

objRS.Fields("Created")  = Now

objRS.Update

In ASP, using ADO, you filter a set of records using the Filter property.

objRecordSet.Filter = "ExtEmpType='P'"

In ASP, using ADO, you use Find and Seek to move a cursor of a RecordSet to a matching record.

TC.Find " UserID='mprestwood' "
Response.Write TC.Fields("Age")

ASP uses MoveFirst, MoveLast, MoveNext, and MovePrevious to move a database cursor (a RecordSet).

objRecordSet.MoveNext

objRecordSet.MoveLast

objRecordSet.MovePrevious

In ASP, using ADO, you sort a set of records using the Sort property.

objMembersRS.Sort = "FirstName"

In VB.Net, the Object keyword is an alias for the base System.Object class and is the single base class all classes ultimately inherit from. Use the Inherits keyword to indicate the parent class and Inherits must precede all declarations in a class.

Syntax Example:   'Specify both namespace and class: Public Class Cyborg Inherits System.Object End Class 'Use Object alias for System.Objct: Public Class Cyborg Inherits Object End Class 'Default when not specified is System.Object: Public Class Cyborg End Class

Declare and implement VB.Net classes after the form class or in their own .vb files. Unlike VB Classic, you can have more than one class in a .vb class file (VB classic uses .cls files for each class).

Public Class Cyborg

  Inherits Object

  Public Sub IntroduceYourself()

  MessageBox.Show("Hi, I do not have a name yet.")

 End Sub

End Class

Dim T1 As New Cyborg
T1.IntroduceYourself()

//No need to clean up with managed classes.

//The garbage collector will take care of it.

 VB.Net Class..Object (Class..End Class..New)

Ultra-primitive (no inheritance) but useful and encourages you to think and design using objects. Unlike VB, you can have more than one class per file.

Classes in ASP do support member fields, properties, and methods.

'Declare class.

Class Cyborg

  Public Function IntroduceYourself() 

    Response.Write("Hi, I do not have a name yet.") 

  End Function 

End Class

'Create object from class.

Set T1 = new Cyborg

T1.IntroduceYourself() 

Set T1 = Nothing      'Be sure to clean up!

 Creating a Class in ASP

VB.Net uses the Inherits keyword followed by the parent class name. If you do not include Inherits, your class inherits from System.Object.

Public Class Android

End Class

Public Class T-600

  Inherits Android

End Class

 VB.Net Inheritance (Inherits ParentClass)  

In VB.Net you can set the visibility of a member field to any visibility: private, protected, public, friend or protected friend.

You can intialize a member field with a default when declared. If you set the member field value in your constructor, it will override the default value.

Finally, you can use the Shared modifier (no instance required) and ReadOnly modifier (similar to a constant).

Public Class Cyborg
  Private FSerialNumber As String = "A100"

  Public CyborgName As String
  Public CyborgAge As Integer
 

  Public Shared ReadOnly SeriesID As Integer = 100
End Class

 VB.Net Member Field

ASP Classic does support member fields, but, as usual, you cannot initialize the type nor value of a member field. The type is implied by usage.

Class Cyborg

  Private FSerialNumber

  Public FCyborgName

  Public FCyborgAge 
  Public FSeriesID

End Class

VB.Net�uses the keywords sub and function. A sub does not return a value and a function does. Many programmers like to use the optional call keyword when calling a sub to indicate the call is to a procedure.

Public Class Cyborg

� Inherits Object

� Public Sub IntroduceYourself()

��� MessageBox.Show("Hi, I do not have a name yet.")

� End Sub

End Class

Dim T1 As New Cyborg
T1.IntroduceYourself()

ASP classic uses the keywords sub and function. A sub does not return a value and a function does. Many programmers like to use the optional call keyword when calling a sub to indicate the call is to a procedure.

'Declare class.

Class Cyborg

  Public Function IntroduceYourself() 

    Response.Write("Hi, I do not have a name yet.") 

  End Function 

End Class

'Create object from class.

Set T1 = new Cyborg

T1.IntroduceYourself() 

The method modifiers include�MustOverride,�NotOverridable, Overridable, Overrides. Specify�VB.Net member modifiers as follows:

Public Overrides Function SomeFunction() As Double

The field modifiers include ReadOnly and Shared. Specify field modifiers as follows:

Public ReadOnly SomeField As String

Other than visibility modifiers Public and Private, the only other member modifier available in ASP Classic is Default which is used only with the Public keyword in a class block. It indicates that the sub, function, or property is the default method for the class. You can have only one Default per class.

VB.Net uses a special property keyword along with special get and set methods to both get and set the values of properties. For a read-only property, leave out the set method. The value keyword is used to refer to the member field. Properties can make use of any of the access modifiers (private, protected, etc).

My preference for VB.Net code is to start member fields with "F" ("FName" in our example) and drop the "F" with properties that manage member fields ("Name" in our example).

Public Class Cyborg
  Private FCyborgName As String

  Public Property CyborgName()
    Get
      Return FCyborgName
    End Get

 
    Set(ByVal value)
      FCyborgName = value
    End Set
  End Property 

End Class

 VB.Net Member Property (property, get, set)

ASP classic uses the property keyword and special Get and Let methods to both get and set the values of properties.

Class Cyborg
 Private FCyborgName
 
 Public Property Get CyborgName()
  CyborgName = FCyborgName
 End Property

 Public Property Let CyborgName(pCyborgName)
  FCyborgName = pCyborgName
 End Property

End Class

 ASP Classic Member Property (Property..Get..Let)

In VB.Net, you specify each class and each class member's visibility with an access modifier preceding class or member. The VB.Net access modifiers are the traditional Public, Protected, and Private plus the two additional .Net modifiers Friend and Protected Friend.

Friend indicates members are accessible from types in the same assembly. Protected Friend indicates members are accessible from types in the same assembly as well as descendant classes. OO purist might object to Friend and Protected Friend and I suggest you avoid them until you both fully understand them and have a need that is best suited by them.

Public Class Cyborg
  Inherits Object

  Private FName As String

End Class

 VB.Net Access Modifiers

The member visibility modifiers are Private and Public. If not specified, the default is Public. Private and Public have the usual meaning. Private members are visible only within the class block. Public members are visible within the class and outside of the class.

Class Cyborg

  Private FSerialNumber  

  Public FCyborgName

  Public Function IntroduceYourself() 
    Response.Write("Hi, I do not have a name yet.") 
  End Function

End Class

 ASP Classic Member Visibility (Private, Public)

VB.Net supports abstract class members and abstract classes using the MustInherit and MustOverride modifiers.

An abstract class is indicated with a MustInherit modifier and is a class with one or more abstract members and you cannot instantiate an abstract class. However, you can have additional implemented methods and properties.

An abstract member is either a method (implicitly virtual), property, indexer, or event in an abstract class. You can add abstract members ONLY to abstract classes using the MustOverride keyword. Then you override it in a descendant class with Overrides.

Public MustInherit Class Cyborg

  Public MustOverride Sub Speak(ByVal pMessage As String)

End Class

Public Class Series600

  Inherits Cyborg

  Public Overrides Sub Speak(ByVal pMessage As String)

    MessageBox.Show(pMessage)

  End Sub

End Class

 VB.Net Abstraction (MustInherit, MustOverride, Overrides)

However, developers sometimes use the term "class helper" to refer to code that helps out a class. Not truly the meaning we are using here, but you should be aware of the term's general usage.

Although not currently supported, there are plans for the next version of VS.Net and .Net using Requires and Ensures keywords. Look for code contracts in VS.Net 2010 and .Net 4.

• Read About It: Introduction to Code Contracts

If you code with VS.Net 2008 Pro or above and wish to implement contracts now, checkout the following download:

• Managed Contract Tools

In VB.Net, a constructor is called whenever a class or struct is created. A constructor is a sub named New. You can overload the constructor simply by adding two or more New subs with various parameters (overloaded constructors).

If you do not create a constructor, VB.Net will create an implicit constructor that initializes all member fields to their default values.

Constructors can execute at two different times. Static constructors are executed by the CLR before any objects are instantiated. Regular constructors are executed when you create an object.

You can invoke the parent constructor with MyBase.New.

Public Class Cyborg
  Public CyborgName As String

  Public Sub New(ByVal pName As String)
    CyborgName = pName
  End Sub
End Class

 VB.Net Constructors (New)  

When an object instance is created from a class, ASP calls a special parameter-less sub named Class_Initialize. Since you cannot specify parameters for this sub, you also cannot overload it.

When a class is destroyed, ASP calls a special sub called Class_Terminate.

Class Cyborg
  Public CyborgName
 
  Public Sub Class_Initialize
   Response.Write "<br>Class created"
   CyborgName = "Cameron"
  End Sub 

End Class

 ASP Classic Constructors (Class_Initialize)  

In VB.Net you cannot explicitly destroy a managed�object. Instead, the .Net Framework's garbage collector (GC) takes care of destroying all objects. The GC destroys the objects only when necessary. Some situations of necessity are when memory is exhausted or you explicitly call the System.GC.Collect() method. In general, you never need to call System.GC.Collect().

In .Net, a finalizer is used to free non-managed objects such as a file or network resource. In VB.Net, a finalizer is an overridden sub called Finalize. Because you don't know when the garbage collector will call your finalizer, Microsoft recommends you implement the IDisposable interface for non-managed resources and call it's Dispose() method at the appropriate time.

Class Cyborg
� Protected Overrides Sub Finalize() 
��� 'Free non-managed resources here.
��� MyBase.Finalize() 
� End Sub
End Class

 VB.Net Finalizer (Finalize())  

When an object instance is destroyed, ASP calls a special parameter-less sub named Class_Terminate. For example, when the variable falls out of scope. Since you cannot specify parameters for this sub, you also cannot overload it.

To explicitly destroy an object, use Set YourClass = nothing. If the Class object is explicitly destroyed, the client returns with the script engine error details.

When an object instance is created from a class, ASP calls a special sub called Class_Initialize.

Class Cyborg

  Public Sub Class_Terminate

    Response.Write "<br>Class destroyed"
  End Sub
End Class

 ASP Classic Destructor (Class_Terminate)  

VB.Net does not support multiple implementation inheritance. Each class can have only one parent class (a single inheritance path). In VB.Net, you can use multiple interface usage to design in a multiple class way horizontally in a class hierarchy.

With VB.Net you define an interface with the Interface keyword and use it in a class with the Implements keyword. In the resulting class, you implement each property and method and add Implements Interface.Object to each as in:

Sub Speak(ByVal pSentence As String) Implements IHuman.Speak

  MessageBox.Show(pSentence)

End Sub

Public Interface IHuman
  'Specify interface methods and properties here.

End Interface
  

Public Class Cyborg
  Inherits System.Object

End Class
  

Public Class CyborgHuman
  Inherits Cyborg
  Implements IHuman
  'Implement interface methods and properties here.

End Class

 VB.Net Interfaces (Interface, Implements)

Although ASP Classic does support simple classes, it does not support interfaces.

 ASP Classic Interfaces (Not Supported)

In VB.Net, you specify a virtual method with the Overridable keyword in a parent class and extend (or replace) it in a descendant class using the Overrides keyword.

Use the base keyword in the descendant method to execute the code in the parent method, i.e. base.SomeMethod().

Public Class Robot
  Public Overridable Sub Speak()
    MessageBox.Show("Robot says hi")
  End Sub
End Class

Public Class Cyborg
  Inherits Robot

  Public Overrides Sub Speak()
    MessageBox.Show("hi")
  End Sub
End Class

 VB.Net Overriding (Overridable, Overrides)

Since ASP Classic does not support inheritance, there is no concept of a descendant class nor overriding.

VB.Net supports both partial classes and partial methods.

Partial Public Class Cyborg
  Inherits System.Object

End Class

 VB.Net Partial Classes (Partial)

VB.Net supports the following types of polymorphism:

• Parametric Polymorphism (Method Overloading)
• Inheritance-Based Polymorphism
• Interface-Based Polymorphism (interfaces) 
• Ad-Hoc Polymorphism (Operator Overloading)

With VB.Net, use the NotInheritable keyword to prevent a class from being inherited from and use the NotOverridable keyword to prevent a method from being overridden.

A method marked NotOverridable must override an ancestor method. If you mark a class NotInheritable, all members are implicitly not overridable so the NotOverridable keyword is not legal.

Public Class Machine

  Public Overridable Sub Speak(ByRef pSentence As String)
    MessageBox.Show(pSentence)
  End Sub
End Class

Public Class Robot
  Inherits Machine

  Public NotOverridable Overrides Sub Speak(ByRef pSentence As String)
    MessageBox.Show(pSentence)
  End Sub
End Class

Public NotInheritable Class Cyborg
  Inherits Robot
End Class

VB.Net supports both static members and static classes (use the keyword Shared). You can add a static method, field, property, or event to an existing class.

You can designate a class as static and the compiler will ensure all methods in that class are static. You can add a constructor to a static class to initialize values.

The CLR automatically loads static classes with the program or namespace.

Public Shared Function MySharedFunction() As Integer
  MySharedFunction = 12345
End Function 

 VB.Net Shared Members (Shared)  

Although ASP Classic supports the creation of simple classes, it does not support static methods.

 ASP Classic Static Members (Not Supported)