Home > Articles > Programming > Windows Programming

  • Print
  • + Share This
Like this article? We recommend

Like this article? We recommend

New Items

In addition to changes to the core language and some of the tools, there are some completely new features to VB.NET. The major new items include such features as constructors and destructors, namespaces, inheritance, overloading, free treading, and garbage collection. This is not an exhaustive list, by any means, but these six features are worth discussing to one degree or another.

Constructors and Destructors

Constructors and destructors are new concepts for VB programmers. At their simplest level, constructors and destructors are procedures that control the initialization and destruction of objects, respectively. The procedures Sub New and Sub Destruct replace the VB6 Class_Initialize and Class_Terminate methods. Unlike Class_Initialize, Sub New runs only once, when the object is first created. Sub New cannot be called explicitly except in rare circumstances.

Sub Destruct is called by the system when the object is set to Nothing or all references to the object are dropped. However, you cannot ensure when Sub Destruct actually will be called, thanks to the way VB.NET does garbage collection, which is discussed at the end of this chapter.

One of the reasons for constructors is that you can create an object and pass in some initialization parameters. For example, assume that you want to create a class dealing with a training course, and you want to initialize the class with a course number so that it can retrieve certain information from a database. In your class, you create a Sub New method that accepts an argument for the course ID. The first line inside Sub New is a call to another constructor, usually the constructor of the base class on which this class is based. Fortunately, VB.NET gives you an easy way to call the constructor of the base class for your current class: MyBase.New.

If you want to create a class for a training course and initialize it with a course ID, your class would look something like this:

Class Course
  Sub New(ByVal CourseID As Integer)
  End Sub
End Class

To call this class from the client code, your call would look something like this:

Dim TrainingCourse as Course = New Course(5491)


Perhaps one of the most confusing aspects of VB.NET for VB developers is the concept of a namespace. A namespace is a simple way to organize the objects in an assembly. When you have many objects, such as in the System namespace provided by the runtime, a namespace can simplify access because it is organized in a hierarchical structure, and related objects appear grouped under the same node.

If you want to use the objects in an assembly without having to fully qualify them each time, use the Imports statement. Doing so allows you to use the names of the objects without fully qualifying their entire namespace hierarchy.

For example, when you created your first VB.NET project in a previous chapter you saw some Imports statements at the top of the form's code module. One of those was Imports System.WinForms. That statement made all the classes, interfaces, structures, delegates, and enumerations available to you without you having to qualify the full path. That means that the following code is legal:

Dim x as Button

Without the Imports System.WinForms statement, your line of code would have to look like this:

Dim x as System.WinForms.Button

In fact, the msgbox that you know and love is actually being replaced by the System.WinForms.MessageBox class. msgbox still works for compatibility, but if you do not import the System.WinForms namespace, msgbox is not natively supported.

If you're wondering why in the world Microsoft pulled out some language elements and made them part of the runtime, it should be fairly obvious: so that any language targeting the runtime, on any platform, would have access to common functionality. That means that you can go into C# and have a message box, just by importing System.WinForms and calling the MessageBox class.

Creating Your Own Namespaces

You are free to create your own namespaces inside your assemblies. You can do this simply by inserting your own Namespace...End namespace block. Inside the namespace block, you can have structures, classes, enums, interfaces, and other elements. You must name the namespace, and it becomes what someone would import. Your code might look like this:

Namespace VolantTraining
  Public Class Customer
    'code here
  End Class

  Public Class Student
    'code here
  End Class
End Namespace

Namespaces can be nested within other namespaces. For example, your namespace might look something like this:

Namespace VolantTraining
  Namespace Customer
    Class Training
    End Class
    Class Consulting
    End Class
  End Namespace
  Namespace Student
  End Namespace
End Namespace

Here you have one namespace, VolantTraining, that holds two other namespaces: Customer and Student. The VolantTraining.Customer namespace holds the Training and Consulting classes, so you could have customers who have used your training services and customers who have used your consulting services.

If you choose not to create explicit namespaces, all your classes and modules still belong to a namespace. This namespace is the default namespace and is the name of your project. You can see this namespace, and change it, if you want, by viewing the Project Properties dialog box for your project. The textbox labeled Root Namespace represents the root namespace for your project.


The most-requested feature in VB for years has been inheritance. Microsoft often countered that VB did inheritance; VB did interface inheritance, which meant that you could inherit (what VB called implement) an interface. However, the interface you implemented did not have any code in it—or, if it did, the code was just ignored. Therefore, the class implementing the interface had to provide methods for all the methods in the interface, and the code had to be rewritten in each class that implemented that interface. VB developers wanted to be able to write that code once, in a base class, and then to inherit that class in other classes, which would then be called derived classes. The derived classes should be able to use the existing code in the base class. With VB.NET, developers have their wish.

Not only does your derived class inherit the properties and methods of the base class, but it also can extend the methods and, of course, create new methods (in the derived class only). Derived classes can also override any existing method in the base class with a new method of the same name, in a process called overriding. Forms, which are really just classes, can be inherited to create new forms.

There are many concepts to inheritance, and seeing it in practice is important enough to make it a chapter unto itself.


Overloading is another feature that some VB developers have been requesting for a long time. In short, overloading allows you to define the same procedure multiple times. The procedure has the same name but a different set of arguments each time.

You could fake this in an ugly way in VB6. You could pass in an argument as a Variant and then use the VarType command to check the type of variable that was passed in. This was cumbersome, and the code could get nasty if your procedure had to accept an array or a collection.

VB.NET gives you a nice way to handle this issue. Imagine that you have a procedure that can accept a string or an integer. The functionality inside the procedure would be quite different depending on whether what is passed is a string or an integer. Your code might look something like this:

Overloads Function FindCust(ByVal psName As String) As String
  ' search name field for %psName%
End Function

Overloads Function FindCust(ByVal piCustNo As Integer) As String
  ' search CustID field
End Function

You now have a function called FindCust that can be passed either an integer or a string. Your calls to it could look like this:

Dim x As String
x = FindCust("Hello")
x = FindCust(1)

As long as Option Strict is turned on (which is the default, at least in Beta 1), you cannot compile an invalid call. For example, there is no overloaded FindCust that accepts a floating-point value of any kind. VB.NET would not let the following code compile:

x = FindCust(12.5)

Free Threading

For the first time, VB.NET has given VB developers the ability to write truly free-threaded applications. If your application is going to perform a task that could take a long time, such as parsing through a large recordset or performing a complex series of mathematical calculations, you can push that processing off to its own thread so that the rest of your application is still accessible. In VB6, the best you could do to keep the rest of the application from appearing to be locked was to use the DoEvents method.

Examine this code, which is written for VB.NET. Here you have some code for Button4. This code calls the BeBusy routine, which has a loop in it to just to take up time. However, while in this loop, you are consuming the thread for this application, and the UI will not respond while the loop is running.