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:
1. Under .NET the integer data type in VB.NET is also 4 bytes
in size.
2 . VB.NET has no currency data type. Instead it provides
decimal as a replacement.
3. VB.NET introduces a new data type called Char. The char
data type takes 2 bytes and can store Unicode characters.
4. 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).
5. In VB.NET there is no concept of fixed length strings.
6. 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:
br> 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
X=100
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
Get
Return m_var
End Get
Set
M_var = value
End Set
End Property
Example:
Private _message as String
Public Property Message As String
Get
Return _message
End Get
Set
_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.
Scoping 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
J=0
If objRs("flag")="Y" then
J=1
End If
objRs.MoveNext
Wend
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()
Try
Open "myFile" For Output As #1
Write #1, myOutput
Catch
Kill "myFile"
Finally
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:
Foo.Static()
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
ObjFoo.NonStatic()
To create a static method in a VB.NET, simply prefix the
method definition with the keyword Shared.
PREVIOUS NEXT
