What is the difference between VB and VB.NET?

Now VB.NET is object-oriented language. The following are some of the differences:
Data Type Changes
The .NET platform provides Common Type System to all the supported languages. This means that all the languages must support the same data types as enforced by common language runtime. This eliminates data type incompatibilities between various languages. For example on the 32-bit Windows platform, the integer data type takes 4 bytes in languages like C++ whereas in VB it takes 2 bytes. Following are the main changes related to data types in VB.NET:
• Under .NET the integer data type in VB.NET is also 4 bytes in size.
• VB.NET has no currency data type. Instead it provides decimal as a replacement.
• VB.NET introduces a new data type called Char. The char data type takes 2 bytes and can store Unicode characters.
• VB.NET do not have Variant data type. To achieve a result similar to variant type you can use Object data type. (Since every thing in .NET – including primitive data types – is an object, a variable of object type can point to any data type).
• In VB.NET there is no concept of fixed length strings.
• In VB6 we used the Type keyword to declare our user-defined structures. VB.NET introduces the structure keyword for the same purpose.
Declaring Variables
Consider this simple example in VB6:
Dim x,y as integer
In this example VB6 will consider x as variant and y as integer, which is somewhat odd behavior. VB.NET corrects this problem, creating both x and y as integers. Furthermore, VB.NET allows you to assign initial values to the variables in the declaration statement itself:
Dim str1 as string = “Hello”
VB.NET also introduces Read-Only variables. Unlike constants Read-Only variables can be declared without initialization but once you assign a value to it, it cannot be changes.
Initialization here
Dim readonly x as integer
In later code
Now x can’t be changed
X=200 *********** Error **********
Property Syntax
In VB.NET, we anymore don't have separate declarations for Get and Set/Let. Now, everything is done in a single property declaration. This can be better explained by the following example.
Public [ReadOnly | WriteOnly] Property PropertyName as Datatype
Return m_var
End Get

M_var = value
End Set
End Property
Private _message as String
Public Property Message As String
Return _message
End Get
_message = Value
End Set
End Property
ByVal is the default - This is a crucial difference betwen VB 6.0 and VB.NET, where the default in VB 6.0 was by reference. But objects are still passed by reference.
Invoking Subroutines
In previous versions of VB, only functions required the use of parentheses around the parameter list. But in VB.NET all function or subroutine calls require parentheses around the parameter list. This also applies, even though the parameter list is empty.
User-Defined Types - VB.NET does away with the keyword Type and replaces it with the keyword Structure
Public Structure Student
Dim strName as String
Dim strAge as Short
End Structure
Procedures and Functions
In VB6 all the procedure parameters are passed by reference (ByRef) by default. In VB.NET they are passed by value (ByVal) by default. Parantheses are required for calling procedures and functions whether they accept any parameters or not.
In VB6 functions returned values using syntax like: FuntionName = return_value. In VB.NET you can use the Return keyword (Return return_value) to return values or you can continue to use the older syntax, which is still valid.
VB.NET now supports block-level scoping of variables. If your programs declare all of the variables at the beginning of the function or subroutine, this will not be a problem. However, the following VB 6.0 will cause an issue while upgrading to VB .NET
Do While objRs.Eof
Dim J as Integer
If objRs("flag")="Y" then
End If
If J Then
Msgbox "Flag is Y"
End If
In the above example the variable J will become out of scope just after the loop, since J was declared inside the While loop.
Exception Handling
The most wanted feature in earlier versions of VB was its error handling mechanism. The older versions relied on error handlers such as "On Error GoTo and On Error Resume Next. VB.NET provides us with a more stuructured approach. The new block structure allows us to track the exact error at the right time. The new error handling mechanism is refered to as Try...Throw...Catch...Finally. The following example will explain this new feature.
Sub myOpenFile()
Open "myFile" For Output As #1
Write #1, myOutput
Kill "myFile"
Close #1
End try
End Sub
The keyword SET is gone - Since everything in VB.NET is an object. So the keyword SET is not at all used to differentiate between a simple variable assignment and an object assignment. So, if you have the following statement in VB 6.0
Set ObjConn = Nothing
Should be replaced as
ObjConn = Nothing.
Constructor and Destructor
The constructor procedure is one of the many new object-oriented features of VB.NET. The constructor in VB.NET replaces the Class_Initialize in VB 6.0. All occurance of Class_Initialize in previous versions of VB should now be placed in a class constructor. In VB.NET, a constructor is added to a class by adding a procedure called New. We can also create a class destructor, which is equivalent to Class_Terminate event in VB 6.0, by adding a sub-procedure called Finalize to our class.
Usage of Return
In VB.NET, we can use the keyword return to return a value from any function. In previous versions, we used to assign the value back with the help of the function name itself. The following example explains this:
Public Function Sum (intNum1 as Integer, intNum2 as Integer) as Integer
Dim intSum as Integer
intSum = intNum1 + intNum2
Return intSum
End Function
Static Methods
VB.NET now allows you to create static methods in your classes. Static methods are methods that can be called without requiring the developer to create instance of the class. For example, if you had a class named Foo with the non-static method NonStatic() and the static method Static(), you could call the Static() method like so:
However, non-static methods require than an instance of the class be created, like so:
Create an instance of the Foo class
Dim objFoo as New Foo()
Execute the NonStatic() method
To create a static method in a VB.NET, simply prefix the method definition with the keyword Shared.

Showing Answers 1 - 2 of 2 Answers


  • Jan 16th, 2006

To summarize points of difference are as follows:

  1. VB.Net is object oriented, while VB is procedural
  2. VB.Net enjoys benefits of .net memory management and CTS
  3. VB.Net supports advanced features like exception handling.
  4. VB.Net uses ADO.Net which supports XML representation of objects. These objects are lightweight and travel through firewalls. VB uses ADO recordsets which are binary COM objects.

  Was this answer useful?  Yes

John B

  • Dec 20th, 2008

The big one is that VB (we are talking VB through VB6) is entirely in the COM world not the .Net world of managed code. VB generates either threaded P-code or native EXE, processed by the VB runtime,  but does not have concept of Release vs Debug. VB.Net generates IL that is processed on a just-in-time-compile basis by the CLR, and offers Release and Debug options. 
VB had "some" object-oriented features- interfaces, classes, instantiation - but lacked inheritance and other things, VB.Net is full OO. VB had deterministic object release: set an object to Nothing and it was gone: .Net releases the memory during system-determined passes of the general Garbage Collector.
There are lots of other differences, many listed in the very long answer to the question! Many people feel that much of the ease and speed of use of VB was sacrificed in making VB.Net more of a "geeky" language, and that some of these aspects could have been retained - for instance, surely there was a way to generate IL for control arrays?

  Was this answer useful?  Yes


  • Jun 13th, 2016

Discuss about member of derived controls?

  Was this answer useful?  Yes

Give your answer:

If you think the above answer is not correct, Please select a reason and add your answer below.


Related Answered Questions


Related Open Questions