Comparison of Visual Basic and Visual Basic .NET

Obvious major differences

The new platform bore little resemblance to its predecessor. While programmers expected to be able to recompile their Visual Basic source to a .NET target, the reality of the situation was that Visual Basic .NET was a vastly different paradigm.

Obvious syntax differences aside, Visual Basic .NET provides much the same functionality as C# (since they both compile down to MSIL, with the most obvious difference being the case insensitivity of Visual Basic .NET, maintaining the original case-insensitivity of Visual Basic), which is more of a problem for C# programmers trying to inter-operate with Visual Basic .NET developers than anything else.

The basic syntax remains very similar: conditions, loops, procedures, sub-routines are declared and written in the same manner (see Visual Basic). Mobility from prior Visual Basic iterations to Visual Basic .NET really are parts of existing code: programmers with experience in both worlds are required to effectively target the new platform with older logic. The Visual Basic .NET developer will have to learn the use of the basic .NET types rather than what they have been used to in Visual Basic.

A programmer who has only worked with Visual Basic may encounter a steep learning curve to migrate to Visual Basic .NET. A programmer who is versed in another language or who has had exposure to the .NET runtime should be able to cope. It would be better to think of Visual Basic .NET as a new language inspired by the classic Visual Basic rather than as a continuation of Visual Basic 6.0, with the added difficulty for migrating programmers that VB.NET interfaces with the .NET Framework whereas VB6 was based on the Component Object Model (COM).

One more chapter is free with a Lably account.

More detailed comparison

There are some immediate changes that developers should take note of:

More C-like syntax

Visual Basic .NET allows for the +=, -=, *=, /=, \=, ^=, and &= compound operators so that longer lines like:

<span id="mwKg"></span><span class="n" id="mwKw">variable</span><span class="w" id="mwLA"> </span><span class="o" id="mwLQ">=</span><span class="w" id="mwLg"> </span><span class="n" id="mwLw">variable</span><span class="w" id="mwMA"> </span><span class="o" id="mwMQ">+</span><span class="w" id="mwMg"> </span><span class="mi" id="mwMw">1</span>

can now be written as:

<span id="mwNw"></span><span class="n" id="mwOA">variable</span><span class="w" id="mwOQ"> </span><span class="o" id="mwOg">+=</span><span class="w" id="mwOw"> </span><span class="mi" id="mwPA">1</span>

However, increment and decrement operators are not supported.

Short-circuited logic

In prior iterations of Visual Basic, all statements in a condition would have been evaluated even if the outcome of the condition could be determined before evaluating a condition. For example:

<span id="mwQw"></span><span class="k" id="mwRA">If</span><span class="w" id="mwRQ"> </span><span class="n" id="mwRg">foo</span><span class="p" id="mwRw">()</span><span class="w" id="mwSA"> </span><span class="ow" id="mwSQ">And</span><span class="w" id="mwSg"> </span><span class="n" id="mwSw">bar</span><span class="p" id="mwTA">()</span><span class="w" id="mwTQ"> </span><span class="k" id="mwTg">Then</span> <span class="w" id="mwTw"> </span><span class="c" id="mwUA">' code here is executed if foo() and bar() both return True, however, if foo() returns False, bar() is still evaluated</span> <span class="k" id="mwUQ">End</span><span class="w" id="mwUg"> </span><span class="k" id="mwUw">If</span>

This was not only inefficient, but could lead to unexpected results for any person used to another language. In Visual Basic .NET, the new AndAlso and OrElse operators have been added to provide short-circuit evaluation like many other languages.

Explicit pointer-like types are no more

Var* variable types are deprecated in Visual Basic .NET. The common runtime decides which types are reference types and which types are value types so this is no longer the domain of the programmer.

Properties: Let and Set

Class properties no longer require the Let and Set statements

Debug printing

Debug.Print is replaced with Debug.Write and Debug.WriteLine

Procedures

A procedure call must have parentheses in Visual Basic .NET.

Visual Basic .NET requires a ByVal or ByRef specification for parameters. In Visual Basic the specification could be omitted, implying ByRef by default. Most development environments, such as Visual Studio .NET, will automatically insert a ByVal, so in effect the default is ByVal, not ByRef. There are tools to convert Visual Basic code to VB.NET, such as the Visual Basic Upgrade Wizard that was included in Visual Studio .NET 2002 and 2003. Conversion tools automatically insert a ByRef if necessary, preserving the semantics of the Visual Basic application.

Zero-based arrays

Visual Basic 5.0 and 6.0 has traditionally employed zero-based arrays (the default lower bound), unless "Option Base 1" is declared. This was the source of many out-by-one errors in Visual Basic programs, especially when dealing with interoperability across program library boundaries. Although the .NET Common Language Runtime can support arrays with any base value, Visual Basic .NET and C# provide only zero-based arrays and lists, and the .NET Common Language Specification requires zero-based arrays for interoperability between .NET languages.

Jagged Arrays

Visual Basic .NET introduced the concept of a jagged array, whereby the rows can have unequal length as opposed to the uniform length of arrays imposed on Visual Basic programmers.

Variant data type is gone

In languages compiling down to .NET platform, types are strict. Whilst the runtime allows for anonymous object which don't have a pre-defined, named type, the type of a variable may not change over the course of its life-time, hence the need to drop the Variant data-type. However, type "Object" has somewhat similar behavior in practice.

True object-oriented programming

Visual Basic was an object-based language. It supported classes, but not other concepts that would make it an object-oriented language. Visual Basic .NET is a true object-oriented language with the following features:

inheritance
function overloading

Although no language targeting .NET allows for multiple inheritance for classes—multiple inheritance of interfaces is supported.

Change from COM to NET

Whilst the IDE does a reasonable job of hiding the fact, the dependence on ActiveX objects is dropped in Visual Basic .NET (although there are mechanisms for interfacing with COM in .NET ) in favour of .NET components offering similar functionality. This shift is good for the Visual Basic developer since much of the performance issues in Visual Basic arose around the cost of the COM interface.

Elementary geometry management via the Forms designer

One of the true banes of a Visual Basic developer's life has always been writing resize code. Whilst the WinForms paradigm leaves a lot to be desired in the geometry management department in the face of toolkits like Qt and GTK+, at least the developer can anchor widgets on forms instead of having to write reams of code in OnResize handlers.

Option Explicit by default

In Visual Basic .NET, Option Explicit is on by default.