Visual Basic

From Wikipedia, the free encyclopedia

Jump to: navigation, search
This article is about the Visual Basic language shipping with Microsoft Visual Studio 6.0 or
earlier. For the Visual Basic language shipping with Microsoft Visual Studio .NET or later, see
Visual Basic .NET.
Visual Basic

Screenshot of the Visual Basic 6 IDE running on

Windows Vista.
Paradigm(s)
Object-based and Event-driven
Appeared in
1991; 21 years ago
Developer
Microsoft
Stable release
6.0 (1998; 14 years ago)
Typing discipline Static, strong
Major
Microsoft Visual Studio
implementations
Influenced by
BASIC
Visual Basic .NET, Gambas,
Influenced
REALbasic and Basic4ppc
OS
Microsoft Windows and MS-DOS
Website
msdn.microsoft.com/vbasic/
Visual Basic is a third-generation event-driven programming language and integrated
development environment (IDE) from Microsoft for its COM programming model first released
in 1991. Visual Basic is designed to be relatively easy to learn and use.[1][2] Visual Basic was
derived from BASIC and enables the rapid application development (RAD) of graphical user
interface (GUI) applications, access to databases using Data Access Objects, Remote Data

Objects, or ActiveX Data Objects, and creation of ActiveX controls and objects. Scripting
languages such as VBA and VBScript are syntactically similar to Visual Basic, but perform
differently.
A programmer can put together an application using the components provided with Visual Basic
itself. Programs written in Visual Basic can also use the Windows API, but doing so requires
external function declarations. Though the program has received criticism for its perceived
faults,[3] from version 3 Visual Basic was a runaway commercial success,[4] and many companies
offered third party controls greatly extending its functionality.
The final release was version 6 in 1998. Microsoft's extended support ended in March 2008 and
the designated successor was Visual Basic .NET (now known simply as Visual Basic).

Contents

1 Language features

2 Characteristics

3 History
o 3.1 Timeline

4 Derivative languages

5 Performance and other issues

6 Legacy development and support

7 Example code

8 See also

9 References

10 External links

Language features

\
Icons for the main controls in Visual Basic 6.
Like the BASIC programming language, Visual Basic was designed to be easily learned and used
by beginner programmers. The language not only allows programmers to create simple GUI
applications, but to also develop complex applications. Programming in VB is a combination of
visually arranging components or controls on a form, specifying attributes and actions of those
components, and writing additional lines of code for more functionality. Since default attributes
and actions are defined for the components, a simple program can be created without the
programmer having to write many lines of code. Performance problems were experienced by
earlier versions, but with faster computers and native code compilation this has become less of
an issue.
Although VB programs can be compiled into native code executables from version 5 onwards,
they still require the presence of runtime libraries of approximately 1 MB in size. Runtime
libraries are included by default in Windows 2000 and later, however for earlier versions of
Windows, i.e. 95/98/NT, runtime libraries must be distributed together with the executable.

An empty form in Visual Basic 6.

Forms are created using drag-and-drop techniques. A tool is used to place controls (e.g., text
boxes, buttons, etc.) on the form (window). Controls have attributes and event handlers
associated with them. Default values are provided when the control is created, but may be
changed by the programmer. Many attribute values can be modified during run time based on
user actions or changes in the environment, providing a dynamic application. For example, code
can be inserted into the form resize event handler to reposition a control so that it remains

centered on the form, expands to fill up the form, etc. By inserting code into the event handler
for a keypress in a text box, the program can automatically translate the case of the text being
entered, or even prevent certain characters from being inserted.
Visual Basic can create executables (EXE files), ActiveX controls, or DLL files, but is primarily
used to develop Windows applications and to interface database systems. Dialog boxes with less
functionality can be used to provide pop-up capabilities. Controls provide the basic functionality
of the application, while programmers can insert additional logic within the appropriate event
handlers. For example, a drop-down combination box will automatically display its list and allow
the user to select any element. An event handler is called when an item is selected, which can
then execute additional code created by the programmer to perform some action based on which
element was selected, such as populating a related list.
Alternatively, a Visual Basic component can have no user interface, and instead provide ActiveX
objects to other programs via Component Object Model (COM). This allows for server-side
processing or an add-in module.
The runtime recovers unused memory using reference counting which depends on variables
passing out of scope or being set to "Nothing", resulting in the very common problem of memory
leaks. There is a large library of utility objects, and the language provides basic object oriented
support. Unlike many other programming languages, Visual Basic is generally not case sensitive,
although it will transform keywords into a standard case configuration and force the case of
variable names to conform to the case of the entry within the symbol table. String comparisons
are case sensitive by default.
The Visual Basic compiler is shared with other Visual Studio languages (C, C++), but restrictions
in the IDE do not allow the creation of some targets (Windows model DLLs) and threading
models.

Characteristics
The code windows in Visual Basic, showing a Function using the If, Then, Else and Dim
statements.
Visual Basic has the following traits which differ from C-derived languages:

Statements tend to be terminated with keywords such as "End If", instead of using "{}"s
to group statements.

Multiple variable assignment is not possible. A = B = C does not imply that the values of
A, B and C are equal. The boolean result of "Is B = C?" is stored in A. The result stored
in A would therefore be either false or true.

Boolean constant True has numeric value 1.[5] This is because the Boolean data type is
stored as a 16-bit signed integer. In this construct 1 evaluates to 16 binary 1s (the
Boolean value True), and 0 as 16 0s (the Boolean value False). This is apparent when
performing a Not operation on a 16 bit signed integer value 0 which will return the
integer value 1, in other words True = Not False. This inherent functionality becomes
especially useful when performing logical operations on the individual bits of an integer
such as And, Or, Xor and Not.[6] This definition of True is also consistent with BASIC
since the early 1970s Microsoft BASIC implementation and is also related to the
characteristics of CPU instructions at the time.

Logical and bitwise operators are unified. This is unlike some C-derived languages (such
as Perl), which have separate logical and bitwise operators. This again is a traditional
feature of BASIC.

Variable array base. Arrays are declared by specifying the upper and lower bounds in a
way similar to Pascal and Fortran. It is also possible to use the Option Base statement to
set the default lower bound. Use of the Option Base statement can lead to confusion when
reading Visual Basic code and is best avoided by always explicitly specifying the lower
bound of the array. This lower bound is not limited to 0 or 1, because it can also be set by
declaration. In this way, both the lower and upper bounds are programmable. In more
subscript-limited languages, the lower bound of the array is not variable. This uncommon
trait does exist in Visual Basic .NET but not in VBScript.
was introduced by ANSI, with the standard for ANSI Minimal BASIC in
the late 1970s.
OPTION BASE

Relatively strong integration with the Windows operating system and the Component
Object Model. The native types for strings and arrays are the dedicated COM types,
BSTR and SAFEARRAY.

Banker's rounding as the default behavior when converting real numbers to integers with
the Round function.[7] ? Round(2.5, 0) gives 2, ? Round(3.5, 0) gives 4.

Integers are automatically promoted to reals in expressions involving the normal division
operator (/) so that division of one integer by another produces the intuitively correct
result. There is a specific integer divide operator (\) which does truncate.

By default, if a variable has not been declared or if no type declaration character is

specified, the variable is of type Variant. However this can be changed with Deftype
statements such as DefInt, DefBool, DefVar, DefObj, DefStr. There are 12 Deftype
statements in total offered by Visual Basic 6.0. The default type may be overridden for a
specific declaration by using a special suffix character on the variable name (# for
Double, ! for Single, & for Long, % for Integer, $ for String, and @ for Currency) or using
the key phrase As (type). VB can also be set in a mode that only explicitly declared
variables can be used with the command Option Explicit.

History
Alan Cooper created the drag and drop design for the user interface of Visual Basic.
VB 1.0 was introduced in 1991. The drag and drop design for creating the user interface is
derived from a prototype form generator developed by Alan Cooper and his company called
Tripod. Microsoft contracted with Cooper and his associates to develop Tripod into a
programmable form system for Windows 3.0, under the code name Ruby (no relation to the Ruby
programming language).
Tripod did not include a programming language at all. Microsoft decided to combine Ruby with
the Basic language to create Visual Basic.
The Ruby interface generator provided the "visual" part of Visual Basic and this was combined
with the "EB" Embedded BASIC engine designed for Microsoft's abandoned "Omega" database
system. Ruby also provided the ability to load dynamic link libraries containing additional
controls (then called "gizmos"), which later became the VBX interface.[8]

Timeline

Project 'Thunder' was initiated in 1990.[citation needed]

Visual Basic 1.0 (May 1991) was released for Windows at the Comdex/Windows World
trade show in Atlanta, Georgia.

Visual Basic 1.0 for DOS was released in September 1992. The language itself was not
quite compatible with Visual Basic for Windows, as it was actually the next version of
Microsoft's DOS-based BASIC compilers, QuickBASIC and BASIC Professional
Development System. The interface used a Text user interface, using extended ASCII
characters to simulate the appearance of a GUI.

Visual Basic for MS-DOS

VB DOS icon

Visual Basic 2.0 was released in November 1992. The programming environment was
easier to use, and its speed was improved. Notably, forms became instantiable objects,
thus laying the foundational concepts of class modules as were later offered in VB4.

Visual Basic 3.0 was released in the summer of 1993 and came in Standard and
Professional versions. VB3 included version 1.1 of the Microsoft Jet Database Engine
that could read and write Jet (or Access) 1.x databases.

Visual Basic 4.0 (August 1995) was the first version that could create 32-bit as well as
16-bit Windows programs. It has three editions; Standard, Professional, and Enterprise. It
also introduced the ability to write non-GUI classes in Visual Basic. Incompatibilities
between different releases of VB4 caused installation and operation problems. While
previous versions of Visual Basic had used VBX controls, Visual Basic now used OLE
controls (with files names ending in .OCX) instead. These were later to be named
ActiveX controls.

With version 5.0 (February 1997), Microsoft released Visual Basic exclusively for 32-bit
versions of Windows. Programmers who preferred to write 16-bit programs were able to
import programs written in Visual Basic 4.0 to Visual Basic 5.0, and Visual Basic 5.0
programs can easily be converted with Visual Basic 4.0. Visual Basic 5.0 also introduced
the ability to create custom user controls, as well as the ability to compile to native
Windows executable code, speeding up calculation-intensive code execution. A free,
downloadable Control Creation Edition was also released for creation of ActiveX
controls. It was also used as an introductory form of Visual Basic: a regular .exe project
could be created and run in the IDE, but not compiled.

Visual Basic 6.0 (Mid 1998) improved in a number of areas[9] including the ability to
create web-based applications. VB6 has entered Microsoft's "non-supported phase" as of
March 2008. Although the Visual Basic 6.0 development environment is no longer
supported, the runtime is supported on Windows Vista, Windows Server 2008 and
Windows 7.[10]

Mainstream Support for Microsoft Visual Basic 6.0 ended on March 31, 2005. Extended
support ended in March 2008.[11] In response, the Visual Basic user community expressed
its grave concern and lobbied users to sign a petition to keep the product alive.[12]
Microsoft has so far refused to change their position on the matter. (but see [13]) Ironically,
around this time (2005), it was exposed that Microsoft's new anti-spyware offering,
Microsoft AntiSpyware (part of the GIANT Company Software purchase), was coded in
Visual Basic 6.0.[14] Its replacement, Windows Defender, was rewritten as C++ code.[15]

Derivative languages
Microsoft has developed derivatives of Visual Basic for use in scripting. Visual Basic itself is
derived heavily from BASIC, and subsequently has been replaced with a .NET platform version.
Some of the derived languages are:

Visual Basic for Applications (VBA) is included in many Microsoft applications

(Microsoft Office), and also in many third-party products like SolidWorks, AutoCAD,
WordPerfect Office 2002, ArcGIS, Sage 300 ERP, and Business Objects Desktop
Intelligence. There are small inconsistencies in the way VBA is implemented in different
applications, but it is largely the same language as VB6 and uses the same runtime
library. Although Visual Basic development ended with 6.0, in 2010 Microsoft introduced
VBA 7 to provide extended features and 64-bit support for VBA. [16]

VBScript is the default language for Active Server Pages. It can be used in Windows
scripting and client-side web page scripting. Although it resembles VB in syntax, it is a
separate language and it is executed by vbscript.dll as opposed to the VB runtime. ASP
and VBScript should not be confused with ASP.NET which uses the .NET Framework for
compiled web pages.

Visual Basic .NET is Microsoft's designated successor to Visual Basic 6.0, and is part of
Microsoft's .NET platform. Visual Basic.Net compiles and runs using the .NET
Framework. It is not backwards compatible with VB6. An automated conversion tool
exists, but fully automated conversion for most projects is impossible.[17]

StarOffice Basic is a Visual Basic compatible interpreter included in StarOffice suite,

developed by Sun Microsystems.

Gambas is a Visual Basic inspired free software programming language. It is not a clone
of Visual Basic, but it does have the ability to convert Visual Basic programs to Gambas.

Performance and other issues

Earlier versions of Visual Basic (prior to version 5) compiled the code to P-Code only. The PCode is interpreted by the language runtime. The benefits of P-Code include portability and
smaller binary file sizes, but it usually slows down the execution, since having a runtime adds an
additional layer of interpretation. However, small amounts of code and algorithms can be
constructed to run faster than compiled native code.
Visual Basic applications require Microsoft Visual Basic runtime MSVBVMxx.DLL, where xx is
the relevant version number, either 50 or 60. MSVBVM60.dll comes as standard with Windows
in all editions after Windows 98 while MSVBVM50.dll comes with all editions after Windows
95. A Windows 95 machine would however require inclusion with the installer of whichever dll
was needed by the program.

Visual Basic 5 and 6 can compile code to either native or P-Code but in either case the runtime is
still required for built in functions and forms management.
Criticisms levelled at Visual Basic editions prior to VB.NET include:[18]

Versioning problems associated with various runtime DLLs, known as DLL hell

Poor support for object-oriented programming[19]

Inability to create multi-threaded applications, without resorting to Windows API calls

Inability to create Windows services

Variant types have a greater performance and storage overhead than strongly typed
programming languages

Dependency on complex and fragile COM Registry entries[20]

The development environment is no longer supported by Microsoft.

Legacy development and support

All versions of the Visual Basic development environment from 1.0 to 6.0 have been retired and
are now unsupported by Microsoft. The associated runtime environments are unsupported too,
with the exception of the Visual Basic 6 core runtime environment, which will be officially
supported by Microsoft for the lifetime of Windows 8.[21] Third party components that shipped
with Visual Studio 6.0 are not included in this support statement. Some legacy Visual Basic
components may still work on newer platforms, despite being unsupported by Microsoft and
other vendors.
Development and maintenance development for Visual Basic 6 is possible on legacy Windows
XP, Windows Vista and Windows 2003 using Visual Studio 6.0 platforms, but is unsupported.
Documentation for Visual Basic 6.0, its application programming interface and tools is best
covered in the last MSDN release before Visual Studio.NET 2002. Later releases of MSDN
focused on .NET development and had significant parts of the Visual Basic 6.0 programming
documentation removed. The Visual Basic IDE can be installed and used on Windows Vista,
where it exhibits some minor incompatibilities which do not hinder normal software
development and maintenance. As of August 2008, both Visual Studio 6.0 and the MSDN
documentation mentioned above are available for download by MSDN subscribers.

Example code
The following code snippet displays a message box saying "Hello, World!" as the window loads:

Private Sub Form_Load()

' Execute a simple message box that will say "Hello, World!"
MsgBox "Hello, World!"End Sub

This snippet makes a counter that moves up 1 every second (a label and a timer control need to
be added to the form for this to work):
Option Explicit
Dim Count As Integer
Private Sub Form_Load()
Count = 0
Timer1.Interval = 1000 ' units of milliseconds
End Sub
Private Sub Timer1_Timer()
Count = Count + 1
Label1.Caption = Count
End Sub

Visual Basic .NET

From Wikipedia, the free encyclopedia

Jump to: navigation, search
This article may be in need of reorganization to comply with
Wikipedia's layout guidelines. Please help by editing the article to make
improvements to the overall structure. (March 2012)
This article is outdated. Please update this article to reflect recent events or
newly available information. (October 2012)
Visual Basic .NET

Paradigm(s)

Structured, imperative, objectoriented and declarative

Appeared in

2001

Designed by

Microsoft

Developer

Microsoft

Stable
release

2012 (11.0.0.0)
(15 August 2012; 4 months
ago)

Typing

Static, strong, both safe and

discipline

unsafe,[1] nominative

Microsoft Visual Studio,

Major
Microsoft Visual Studio
implementati
Express, SharpDevelop, .NET
ons
Framework SDK and Mono
Dialects

Microsoft Visual Basic

Influenced by .NET Framework

Platform

CLR

OS

Chiefly Microsoft Windows

Also on Android, BSD, iOS,
Linux, Mac OS X, Solaris and
Unix

License

Proprietary software
(Commercial software or
freeware)

Usual
filename
extensions

.vb and .vbs

Website

msdn.microsoft.com/enus/vstudio/hh388573

Microsoft Visual Basic 2010 Express, an

integrated development environment that
implements Visual Basic .NET.

Visual Basic .NET (VB.NET) is an object-oriented computer programming language that can be
viewed as an evolution of the classic Visual Basic (VB), implemented on the .NET Framework.
Microsoft currently supplies two main editions of IDEs for developing in Visual Basic: Microsoft
Visual Studio 2012, which is commercial software and Visual Basic Express Edition 2012, which
is free of charge. The command-line compiler, VBC.EXE, is installed as part of the freeware
.NET Framework SDK. Mono also includes a command-line VB.NET compiler. The most recent
version is VB 2012, which was released on August 15, 2012.
Contents

1 Versions
o

1.1 Visual Basic .NET (2002) (VB 7.0)

1.2 Visual Basic .NET 2003 (VB 7.1)

1.3 Visual Basic 2005 (VB 8.0)

1.3.1 'IsNot' Operator Patent Application

1.4 Visual Basic 2008 (VB 9.0)

1.5 Visual Basic 2010 (VB 10.0)

1.6 Visual Basic 2012 (VB 11.0)

2 Relation to older versions of Visual Basic (VB6 and previous)

o

2.1 Comparative samples

3 Criticism

4 Cross-platform and open-source development

5 Examples

6 See also

7 References

8 Further reading

9 External links

Versions

There are 6 versions of Visual Basic .NET implemented by the Visual Basic team.
Visual Basic .NET (2002) (VB 7.0)

The first version of Visual Basic .NET, which runs on .NET framework 1.0. The most important
feature is Managed code, which contrasts with Visual Basic 6.0 and before.
Visual Basic .NET 2003 (VB 7.1)

Visual Basic .NET 2003 was released with version 1.1 of the .NET Framework. New features
included support for the .NET Compact Framework and a better VB upgrade wizard.
Improvements were also made to the performance and reliability of the .NET IDE (particularly
the background compiler) and runtime. In addition, Visual Basic .NET 2003 was available in the
Visual Studio.NET Academic Edition (VS03AE). VS03AE is distributed to a certain number of
scholars from each country without cost.
Visual Basic 2005 (VB 8.0)

Visual Basic 2005 was the name used to refer to Visual Basic .NET, as Microsoft decided to drop
the .NET portion of the title.
For this release, Microsoft added many features, including:

Edit and Continue

Design-time expression evaluation.

The My pseudo-namespace (overview, details), which provides:sindhu

o

easy access to certain areas of the .NET Framework that otherwise

require significant code to access

dynamically generated classes (notably My.Forms)

Improvements to the VB-to-VB.NET converter[2]

The Using keyword, simplifying the use of objects that require the Dispose
pattern to free resources

Just My Code, which when debugging hides (steps over) boilerplate code
written by the Visual Studio .NET IDE and system library code

Data Source binding, easing database client/server development

The above functions (particularly My) are intended to reinforce Visual Basic .NET's focus as a
rapid application development platform and further differentiate it from C#.

Visual Basic 2005 introduced features meant to bridge the gaps between itself and other "more
powerful" .NET languages, adding:

Features of other .NET 2.0 languages such as:

o

Generics[3]

Partial classes, a method of defining some parts of a class in one file

and then adding more definitions later; particularly useful for
integrating user code with auto-generated code

Nullable Types[4]

Support for unsigned integer data types commonly used in other languages

'IsNot' Operator Patent Application

One other feature of Visual Basic 2005 is the IsNot operator that makes 'If X IsNot Y'
equivalent to 'If Not X Is Y', which gained notoriety[5] when it was found to be the subject of
a Microsoft patent application.[6][7]
Visual Basic 2008 (VB 9.0)

Visual Basic 9.0 was released together with the Microsoft .NET Framework 3.5 on 19 November
2007.
For this release, Microsoft added many features, including:

A true conditional operator, "If(condition as boolean, truepart, falsepart)", to

replace the "IIf" function.

Anonymous types

Support for LINQ

Lambda expressions

XML Literals

Type Inference

Extension methods

Visual Basic 2010 (VB 10.0)

In April 2010, Microsoft released Visual Basic 2010. Microsoft had planned to use the Dynamic
Language Runtime (DLR) for that release[8] but shifted to a co-evolution strategy between Visual

Basic and sister language C# to bring both languages into closer parity with one another. Visual
Basic's innate ability to interact dynamically with CLR and COM objects has been enhanced to
work with dynamic languages built on the DLR such as IronPython and IronRuby.[9] The Visual
Basic compiler was improved to infer line continuation in a set of common contexts, in many
cases removing the need for the "_" line continuation character. Also, existing support of inline
Functions was complemented with support for inline Subs as well as multi-line versions of both
Sub and Function lambdas.[10]
Visual Basic 2012 (VB 11.0)

The latest version of Visual Basic .NET, which runs on .NET framework 4.5. Async Feature,
Iterators, Call Hierarchy, Caller Information and Global Keyword in Namespace Statements are
some of the major features introduced in this version of VB.
Relation to older versions of Visual Basic (VB6 and previous)

Whether Visual Basic .NET should be considered as just another version of Visual Basic or a
completely different language is a topic of debate. This is not obvious, as once the methods that
have been moved around and that can be automatically converted are accounted for, the basic
syntax of the language has not seen many "breaking" changes, just additions to support new
features like structured exception handling and short-circuited expressions. Two important data
type changes occurred with the move to VB.NET. Compared to VB6, the Integer data type has
been doubled in length from 16 bits to 32 bits, and the Long data type has been doubled in length
from 32 bits to 64 bits. This is true for all versions of VB.NET. A 16-bit integer in all versions of
VB.NET is now known as a Short. Similarly, the Windows Forms GUI editor is very similar in
style and function to the Visual Basic form editor.
The version numbers used for the new Visual Basic (7, 7.1, 8, 9, ...) clearly imply that it is
viewed by Microsoft as still essentially the same product as the old Visual Basic.
The things that have changed significantly are the semanticsfrom those of an object-based
programming language running on a deterministic, reference-counted engine based on COM to a
fully object-oriented language backed by the .NET Framework, which consists of a combination
of the Common Language Runtime (a virtual machine using generational garbage collection and
a just-in-time compilation engine) and a far larger class library. The increased breadth of the
latter is also a problem that VB developers have to deal with when coming to the language,
although this is somewhat addressed by the My feature in Visual Studio 2005.
The changes have altered many underlying assumptions about the "right" thing to do with respect
to performance and maintainability. Some functions and libraries no longer exist; others are
available, but not as efficient as the "native" .NET alternatives. Even if they compile, most
converted VB6 applications will require some level of refactoring to take full advantage of the

new language. Documentation is available to cover changes in the syntax, debugging

applications, deployment and terminology.[11]
Comparative samples

The following simple example demonstrates similarity in syntax between VB and VB.NET. Both
examples pop up a message box saying "Hello, World" with an OK button.
Private Sub Command1_Click()
MsgBox "Hello, World"
End Sub

A VB.NET example, MsgBox or the MessageBox class can be used:

Public Class Form1
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles
Button1.Click
MessageBox.Show("Hello, World")
End Sub
End Class

Both Visual Basic 6 and Visual Basic .NET will automatically generate the Sub
and End Sub statements when the corresponding button is clicked in design
view. Visual Basic .NET will also generate the necessary Class and End Class
statements. The developer need only add the statement to display the "Hello,
World" message box.

All procedure calls must be made with parentheses in VB.NET, whereas in

VB6 there were different conventions for functions (parentheses required)
and subs (no parentheses allowed, unless called using the keyword Call).

The names Command1 and Button1 are not obligatory. However, these are
default names for a command button in VB6 and VB.NET respectively.

In VB.NET, the Handles keyword is used to make the sub Button1_Click a

handler for the Click event of the object Button1. In VB6, event handler subs
must have a specific name consisting of the object's name ("Command1"), an
underscore ("_"), and the event's name ("Click", hence "Command1_Click").

There is a function called MsgBox in the Microsoft.VisualBasic namespace

which can be used similarly to the corresponding function in VB6. There is a
controversy about which function to use as a best practice (not only
restricted to showing message boxes but also regarding other features of the
Microsoft.VisualBasic namespace). Some programmers prefer to do things
"the .NET way", since the Framework classes have more features and are less
language-specific. Others argue that using language-specific features makes
code more readable (for example, using int (C#) or Integer (VB.NET) instead
of System.Int32).

In VB 2008, the inclusion of ByVal sender as Object, ByVal e as EventArgs

has become optional.

The following example demonstrates a difference between VB6 and VB.NET. Both examples
close the active window.
Classic VB Example:
Sub cmdClose_Click()
Unload Me
End Sub

A VB.NET example:
Sub btnClose_Click(ByVal sender As Object, ByVal e As EventArgs) Handles
btnClose.Click
Me.Close()
End Sub

The 'cmd' prefix is replaced by the 'btn' prefix, conforming to the new convention previously
mentioned.
Visual Basic 6 did not provide common operator shortcuts. The following are equivalent:
VB6 Example:
Sub Timer1_Timer()
Me.Height = Me.Height - 1
End Sub

VB.NET example:
Sub Timer1_Tick(ByVal sender As Object, ByVal e As EventArgs) Handles
Timer1.Tick
Me.Height -= 1
End Sub

Criticism

This section needs additional citations for verification. (April 2011)

When first introduced, many long-time Visual Basic users complained about Visual Basic .NET
because initial versions dropped a large number of language constructs and user interface
features that were part of VB6 (which is no longer sold by Microsoft), and changed the semantics
of those that remained; for example, in VB.NET parameters are (by default) passed by value, not
by reference. Detractors refer pejoratively to VB.NET as Visual Fred or DOTNOT.[12] One major
complaint was that "edit-and-continue", the ability to fix bugs by changing source code in a
running program when it is paused at a breakpoint and continue running the code, had been
eliminated: this feature was a major productivity aid that had attracted many developers to VB6.

Many of the changes were necessary because they needed to reflect differences between
Windows Foundation Classes and equivalent classes in the .NET framework (e.g., for userinterface controls): in addition, certain changed features, such as restricting the scope of local
variables to the block where they were declared, and passing parameters by value (which is the
only means permitted in Java) make code less error-prone. Reduced risk of error was also the
justification for removing features such as computed gosub/goto and the elimination of line
numbers (both a legacy of the BASIC language's FORTRAN heritage.) In general, the idea was
to make the .NET libraries, rather than language-specific libraries, perform most of the work, so
that code written either in VB.NET or C Sharp would compile to almost identical intermediatecode.
However, many of these semantic changes were not backward-compatible with much existing
code, and existing code required rewriting and testing, a significant expense when the body of
code was non-trivial in size. As author Joel Spolsky noted, "It was the first time a Microsoft
upgrade did not respect the work that users did using the previous version of a product." [13]
To Microsoft's credit, Visual Studio supported some degree of automatic translation to VB.NET
when VB6 code was pasted into Visual Studio. Also, the VB.NET compiler reported multiple
errors (up to a user-specified threshold - e.g., 100 errors) all at once instead of one at a time, with
fixes to the source reducing the error list through a process of background compilation. Despite
this, adoption of VB.NET was still delayed until 2005, when Microsoft finally reintroduced editand-continue: this feature was also made available to C sharp developers.
It is simpler to decompile languages that target Common Intermediate Language (CIL), including
VB.NET, compared to languages that compile to machine code. Tools such as .NET Reflector
can provide a close approximation to the original code due to the large amount of metadata
provided in CIL.[citation needed] This is also true of early versions of Visual Basic (prior to VB5),
which could not compile to native code.
Visual Basic 6.0 programs that are mainly algorithmic in nature can be migrated with few
difficulties, but certain types of code are more troublesome, namely :

Database support: .NET's framework for database access, ADO.NET,

emphasizes disconnected operations, which use database-server resources
as economically as possible by releasing them when not in use. This results in
more scalable code than if the older Data Access Objects or ActiveX Data
Objects were used, but the code is also more complex.

Graphics: .NET has new (and more powerful) libraries for graphics.

Unmanaged operations: .NET, like Java, emphasizes security, so unmanaged

code is used only as a last resort.

Other syntactical differences relate to changes made to bring VB.Net into alignment with
other .Net languages, such as zero-based arrays (all .Net arrays are 0 to n-1 subscript, whereas
classic VB arrays were one-based by default, 1 to n subscript), and structured exception handling
(classic VB used a proprietary ON ERROR mechanism); such changes can be difficult or
impossible to convert automatically, and converters typically flag such problem areas for manual
conversion.
In addition, the required runtime libraries for VB6 programs are provided with Windows 98 SE
and above, while VB.NET programs require the installation of the significantly larger .NET
Framework. The framework is included with Windows 7, Windows Vista, Windows XP Media
Center Edition, Windows XP Tablet PC Edition, Windows Server 2008 and Windows Server
2003. For other supported operating systems such as Windows 2000 or Windows XP (Home or
Professional Editions), it must be separately installed.
Microsoft's response to developer dissatisfaction focused around making it easier to move new
development and shift existing codebases from VB6 to VB.NET. An offering in 2005 was the
VBRun website, offering code samples and articles for:

Using VB.NET to complete tasks that were common in VB6, like creating a
print preview

Integrating VB6 and VB.NET solutions (dubbed VB Fusion)

Cross-platform and open-source development

The creation of open-source tools for VB.NET development have been slow compared to C#,
although the Mono development platform provides an implementation of VB.NET-specific
libraries and a VB.NET 8.0 compatible compiler written in VB.NET,[14] as well as standard
framework libraries such as Windows Forms GUI library.
SharpDevelop and MonoDevelop are open-source alternative IDEs.
Examples

The following is a very simple VB.NET program, a version of the classic "Hello world" example
created as a console application:
Module Module1
Sub Main()
Console.WriteLine("Hello, world!")
End Sub
End Module

The effect is to write the text Hello, world! to the command line. Each line serves a specific
purpose, as follows:
Module Module1

This is a module definition, a division of code similar to a class, although modules can contain
classes. Modules serve as containers of code that can be referenced from other parts of a
program.[15]
It is common practice for a module and the code file, which contains it, to have the same name;
however, this is not required, as a single code file may contain more than one module and/or
class definition.
Sub Main()

This is the entry point where the program begins execution.[16] Sub is an abbreviation of
"subroutine."
Console.WriteLine("Hello, world!")

This line performs the actual task of writing the output. Console is a system object, representing
a command-line interface and granting programmatic access to the operating system's standard
streams. The program calls the Console method WriteLine, which causes the string passed to it to
be displayed on the console. Another common method is using MsgBox (a Message Box).[17]
This piece of code is a solution to Floyd's Triangle:
Imports System.Console
Module Program
Sub Main()
Dim rows As Integer
' Input validation.
Do Until Integer.TryParse(ReadLine("Enter a value for how many rows to
be displayed: "),
rows) AndAlso rows >= 1
WriteLine("Allowed range is 1 and {0}", Integer.MaxValue)
Loop
' Output of Floyd's Triangle
Dim current = 1
For row = 1 To rows
For column = 1 To row
Write("{0,-2} ", current)
current += 1
Next
WriteLine()
Next
End Sub

''' <summary>
''' Shadows Console.ReadLine with a version which takes a prompt string.
''' </summary>
Function ReadLine(Optional prompt As String = Nothing) As String
If prompt IsNot Nothing Then
Write(prompt)
End If
Return Console.ReadLine()
End Function
End Module

See also

Microsoft Visual Studio Express

Comparison of C# and Visual Basic .NET

Visual Basic for Applications

Comparison of programming languages

References
1.

^ Option Strict can be used to switch between safe and unsafe type
checking.

2.

^ What's New with the Visual Basic Upgrade Wizard in Visual Basic
2005

3.

^ Defining and Using Generics in Visual Basic 2005

4.

^ Operator Overloading in Visual Basic 2005

5.

^ Sherriff, Lucy (22 February 2005). "Real Software slams MS IsNot

patent application". The Register. Retrieved 6 April 2009.

6.

^ Taft, Darryl K. (21 February 2005). "Real Software Slams Microsofts

Patent Effort". eWeek. Retrieved 6 April 2009.

7.

^ Vick, Paul A. Jr.; Barsan, Costica Corneliu; Silver, Amanda K. (14 May
2003). "United States Patent Application: 20040230959". IS NOT OPERATOR.
US Patent & Trademark Office. Retrieved 6 April 2009.

8.

^ "What the heck is "VBx"?". 1 May 2007. Retrieved 12 August 2009.

"With the new DLR, we have support for IronPython, IronRuby, Javascript, and
the new dynamic VBx compile"

9.

^ "What's New in Visual Basic 2010". Microsoft. 2009. Retrieved 12

August 2009. "Visual Basic binds to objects from dynamic languages such as
IronPython and IronRuby"

10.

^ "What's New in Visual Basic 2010". Microsoft. 2010. Retrieved 1

August 2010.

11.

^ Migration - Upgrading from Visual Basic 6.0 MSDN Developer

Center Visual Basic 6.0 Resource Center Migration

12.

^ Karl E. Peterson. "Microsoft Basic: 19762001,R.I.P.".

http://vb.mvps.org. Retrieved 7 March 2009.

13.

^ Joel Spolsky, How Microsoft Lost the API War, Joel on Software, 13
June 2004, URL: http://www.joelonsoftware.com/articles/APIWar.html

14.

^ Mono Project: VisualBasic.NET support

15.

^ "Module Statement". MSDN - Developer Center. Retrieved 20 January

2010.

16.

^ "Main Procedure in Visual Basic". MSDN - Developer Center.

Retrieved 20 January 2010.

17.

^ "Visual Basic Version of Hello, World". MSDN - Developer Center.

Retrieved 20 January 2010.

Further reading
1. "Visual Basic Language Specification 8.0". Microsoft Corporation. 15
November 2005. Retrieved 10 December 2010.
2. "Visual Basic Language Specification 9.0". Microsoft Corporation. 19
December 2007. Retrieved 28 September 2011.
3. "Visual Basic Language Specification 10.0". Microsoft Corporation. 19 April
2010. Retrieved 28 September 2011.
External links
Wikibooks has a book on the topic of: Visual Basic .NET

Visual Basic Developer Center

Microsoft Visual Basic Express

The Visual Basic Team Blog

[show]

BASIC programming language

[hide]

.NET Framework

Architecture

Common Language
Infrastructure (CLI)

History

Base Class Library

Common Language Runtime

Code Access Security

Assembly

Manifest

Metadata

COM Interop

Common Language Infrastructure

Common Type System

Common Intermediate Language

Virtual Execution System

C#

Visual Basic .NET

C++/CLI
o

Common1

Managed

F#

J#

JScript .NET

Windows PowerShell

Axum

A#

Boo

Cobra

Oxygene

IronScheme (IronLisp)

IronPython

IronRuby

CLI Languages

Other2

Components

Nemerle

Phalanger

P#

Scala

ADO.NET
o

Entity Framework

Data Services

ASP.NET
o

AJAX

MVC

Dynamic Data

CardSpace

ClickOnce

CLR Profiler

Communication Foundation

Dynamic Language Runtime

Forms

LINQ

Managed Extensibility Framework

Parallel Extensions

Presentation Foundation

Other implementations

Comparisons

Remoting

"Roslyn"

Workflow Foundation

XAML

Mono

Compact Framework

XNA Framework

Micro Framework

Portable.NET

Silverlight

SSCLI

Java and C#

C# and Visual Basic .NET

Java and .NET platforms

Visual Basic and Visual Basic .NET

Languages that had been supported, are supported, or will be supported, in

Visual Studio or .NET Framework.

Non-academic or research languages with relatively large user-bases.

[show]

Microsoft development tools