Home > Articles


  • Print
  • + Share This

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 threading, and garbage collection. This is not an exhaustive list by any means, but these six features are worth discussing to one degree or another. One feature that should be mentioned as well is something you've been seeing all along: auto-indention. As soon as you create a block, such as a Sub or If block, the IDE indents the next line of code automatically.

Constructors and Destructors

Constructors and destructors are potentially new concepts for VB programmers. They are similar to the Class Initialize and Class Terminate events you have in VB classes. At their simplest level, constructors and destructors are procedures that control the initialization and destruction of objects, respectively. The procedures Sub New and Sub Finalize 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 Finalize is called by the system when the object is set to Nothing or all references to the object are dropped. However, you cannot ensure exactly when Sub Finalize actually will be called, thanks to the way VB .NET does garbage collection, which is discussed in the next few sections.

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 the 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)

How Sub Finalize works will be covered in the section on garbage collection, where you will also see Sub Dispose.


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.

For example, say you wanted to model the objects, properties, and methods for a pet store. You might create the PetStore namespace. You could then create some subnamespaces. For example, you might sell live animals and supplies as two major categories. Within the live animals category, you might sell dogs, cats, and fish. If this sounds like an object model, it can be thought of as similar. However, none of these are actual objects. You could have a namespace called PetStore.Animals.Dogs, and in this namespace you'd find the classes and methods necessary for dealing with dogs. If you wanted to handle the inventory, you might find that in PetStore.Supplies. If you wanted to look at the kinds of dog food you have in stock, you might look in PetStore.Supplies.Dogs. Where the physical classes exist is up to you; they all can be in one big assembly, but logically separated into these various namespaces.

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 Chapter 2, "Your First VB .NET Application," you saw some Imports statements at the top of the form's code module. One of those statements 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 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 can be replaced by the System.WinForms.MessageBox class. MsgBox still works for compatibility, but it is actually part of the Microsoft.VisualBasic.Interaction namespace, which contains a number of methods that approximate functions in previous versions of VB.

If you're wondering why 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. MessageBox is quite powerful-the Show method has twelve variations made available thanks to overloading. You'll learn about overloading in a moment.

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 one namespace, VolantTraining, 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 text box labeled Root Namespace represents the root namespace for your project. If you declare a namespace within your project, it is subordinate to this root namespace. Therefore, if the root namespace of your application is Project1, the full namespace for VolantTraining is Project1.VolantTraining.


The most-requested feature to have added to VB for years has been inheritance. Microsoft often countered that VB already supported inheritance; VB supported interface inheritance, which meant that you could inherit (what VB called implement) an interface. However, the interfaces you implemented in VB did not have any code in them, or if they did, the code was ignored. Therefore, the class implementing the interface had to provide methods for all the methods in the interface. If you had more than one class that implemented the same interface, you had to rewrite the code in each class that implemented the interface. VB developers wanted to be able to write that implementation code once, in a base class, and then to inherit that class (instead of an interface) in other classes, which would then be called derived classes. The derived classes would 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, it 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. Chapter 5, "Inheritance with VB .NET," is all about inheritance and how to use it in VB .NET.


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("Smith")
x = FindCust(1)

As long as Option Strict is turned on (which is not the default, at least in Beta 2), 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)


For the first time, VB .NET has given VB developers the ability to write truly multithreaded 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.


This takes about eight seconds to run on my machine. It might run a significantly longer or shorter time on your machine. The good news is the VB .NET IDE runs on a separate thread, so if you find yourself waiting forever, just click on the IDE and choose Stop Debugging from the Debug menu.

Private Sub Button4_Click(ByVal sender As System.Object, _
  ByVal e As System.EventArgs) Handles Button4.Click   BeBusy()
End Sub

Sub BeBusy()
   Dim i As Decimal
   For i = 1 To 10000000
      `do nothing but tie up app
End Sub

If you run this code and try to click on the form before BeBusy is done running, you'll find that the form doesn't respond to any events. For example, other buttons can't be clicked while BeBusy is running. For the form to continue to respond while BeBusy is running, you can run BeBusy on a separate thread.

To create a new thread, you must use the System.Threading.Thread class. In the creation of the class, you pass in the name of the procedure or method you want to run on that thread. You preface the procedure or method name with the AddressOf operator. Your code would look like this:

Dim busyThread As New System.Threading.Thread(AddressOf BeBusy)

To fix the code and keep BeBusy from consuming the main program thread, you have now created a new thread and will run BeBusy on that thread. However, that line of code isn't enough. Next, you must call the Start method on that new thread. With VB .NET, calling BeBusy on its own thread would look like this:

Private Sub Button4_Click(ByVal sender As System.Object, _
  ByVal e As System.EventArgs) Handles Button4.Click   Dim busyThread As New 
System.Threading.Thread(AddressOf BeBusy)
End Sub

No changes are required to the BeBusy procedure. If you now run this code, the interface will remain active while BeBusy is running. The Beep in BeBusy will let you know when the procedure has finished running.

There are some caveats to using free threading. They seem significant, but each one has a fairly reasonable workaround. Some of those caveats and workarounds are as follows:

  • The procedure or method you run on a new thread cannot accept any arguments. To get around this problem, you have a couple of choices. You could use global variables, but that is not an elegant solution. Instead, create properties or fields in the class whose method you are calling, and set those properties after the object is created. Obviously, that wouldn't help you in the earlier example because the call was simply to a sub in the same program.

  • The procedure or method you run on a new thread cannot return a value. To get around that issue, you could use global variables, but again, this is not an elegant solution. One major problem is that your application would have to keep checking the thread to see when it was done, before you would be safe in using that global variable. Instead, you should consider raising an event with the return value as a parameter in the event.

Synchronization is also an issue with multithreaded applications. If you are performing a complex series of calculations on one thread, other parts of your application must wait until that thread is finished before they can use the results. You can monitor threads to see when they are finished or you can have the methods on those threads raise events to notify you when they are done. VB .NET provides an IsAlive property for each thread, so you can check to see when the thread is running.

There is much more to multithreading, and it will be covered in detail in Chapter 11, "Multithreading in VB .NET."

Garbage Collection

Garbage collection is now being handled by the runtime. In VB6, if you set an object to Nothing, it was destroyed immediately. This is no longer true in VB .NET. Instead, when you set an object to Nothing or it loses all its references, it is marked for garbage collection. It's still in memory, taking up resources. The garbage collector runs on a separate thread, and it passes by occasionally looking for objects to clean up (destroy). The garbage collector comes by only when you start running low on resources and need to clean up objects. However, if the system is under a heavy load, the time it takes the garbage collector to come by and clean up objects could be many seconds-an eternity in CPU terms.

Because objects do not get destroyed when you set them to Nothing, Microsoft calls this "no deterministic finalization" because the developer is no longer truly in control of when the object will be destroyed. The Sub Finalize method is called when the object is truly destroyed by the garbage collector.

It is important to understand that even though an object has been marked for garbage collection, any resources it has opened are still open, including any data or file locks that it might have obtained. Because the object is still in memory, holding open references, you might want to explicitly call the garbage collector by using the Collect method of the GC class in the System namespace. A simple call to GC.Collect forces the garbage collector to come by and clean up any objects that have been marked for collection.

When an object is cleaned up, Sub Finalize is called automatically. However, a convention being used by .NET developers is to have a Sub Dispose in a class. The Sub Dispose is called specifically, and it frees up any resources. As long as the code in Sub Dispose properly closes all the open resources, it acts similarly to deterministic finalization in VB6. Following this convention, your Sub Dispose would specifically close all open resources, such as files, database connections, and other objects. Then, you don't have to specifically call the garbage collector because all the object's resources have been closed.

To see garbage collection in action, create a new Windows Application and name it GCtest. On the form, add two buttons. Add a component to the project and name it Garbage. Inside the Garbage component, add the following code:

Protected Overrides Sub Finalize()
End Sub

This just adds a beep sound when the object is finally taken out of memory by the garbage collector.

Back in the form, add the following code:

Dim oGarbage As New Garbage()

Private Sub Button1_Click(ByVal sender As System.Object, _
 ByVal e As System.EventArgs) Handles Button1.Click
   oGarbage = Nothing
End Sub

Private Sub Button2_Click(ByVal sender As Object, _
 ByVal e As System.EventArgs) Handles Button2.Click
End Sub

Now, run the project. When you click on Button1, you set the object to Nothing. However, you don't hear a beep because the object hasn't actually been taken out of memory. Now, click Button2, and you'll hear the beep. You have forced the garbage collector to come by and clean up the object, which causes the Sub Finalize code to run.

IDE Changes

There are numerous IDE changes. Several of those were addressed in Chapter 2: the lack of the Line and Shape controls, the new menu builder, the new way of setting the tab order, and the Dynamic Help window.

One area that is interesting is the changes available thanks to the GDI+ library. As mentioned earlier, the Line and Shape controls are gone. You can replace the lines with a label with a height of one and borders turned on. Or, you can use the System.Drawing namespace. For example, System.Drawing has a Graphics class that contains such methods as DrawCurve, DrawEllipse, DrawLine, and DrawRectangle. There is actually quite a bit of code required to draw a line. You need to place code in the OnPaint sub to have the code called automatically. Just create a new form and add the following code, but don't forget to add an Imports System.Drawing to the top of the form:

Protected Overrides Sub OnPaint(ByVal e As PaintEventArgs)
   Dim LineMaker As Graphics
   LineMaker = e.Graphics
   Dim RedPen As New Pen(Color.Red, 3)
   Dim Point1 As New Point(30, 30)
   Dim Point2 As New Point(Me.Size.Width - 30, 30)
   LineMaker.DrawLine(RedPen, Point1, Point2)
End Sub

You can see the results of this code in Figure 3.1.

Figure 3.1 A form with a line drawn, thanks to GDI+.

Just drawing lines in GDI+ isn't that exciting. With VB .NET, you can actually create forms that are not rectangular. To create a circular form, create a form and add one button to it. Type Imports System.Drawing.Drawing2D at the top, and add the following code to the form:

Private Sub Button1_Click_1(ByVal sender As System.Object, _
 ByVal e As System.EventArgs) Handles Button1.Click
   Dim graPath As GraphicsPath = New GraphicsPath()
   graPath.AddEllipse(New Rectangle(0, 0, 200, 200))
   Me.Region = New [Region](graPath)
End Sub

Run the project and click on the button. The form turns into a circle, as shown in Figure 3.2.

Figure 3.2 A circular form, also thanks to GDI+.

  • + Share This
  • 🔖 Save To Your Account

InformIT Promotional Mailings & Special Offers

I would like to receive exclusive offers and hear about products from InformIT and its family of brands. I can unsubscribe at any time.


Pearson Education, Inc., 221 River Street, Hoboken, New Jersey 07030, (Pearson) presents this site to provide information about products and services that can be purchased through this site.

This privacy notice provides an overview of our commitment to privacy and describes how we collect, protect, use and share personal information collected through this site. Please note that other Pearson websites and online products and services have their own separate privacy policies.

Collection and Use of Information

To conduct business and deliver products and services, Pearson collects and uses personal information in several ways in connection with this site, including:

Questions and Inquiries

For inquiries and questions, we collect the inquiry or question, together with name, contact details (email address, phone number and mailing address) and any other additional information voluntarily submitted to us through a Contact Us form or an email. We use this information to address the inquiry and respond to the question.

Online Store

For orders and purchases placed through our online store on this site, we collect order details, name, institution name and address (if applicable), email address, phone number, shipping and billing addresses, credit/debit card information, shipping options and any instructions. We use this information to complete transactions, fulfill orders, communicate with individuals placing orders or visiting the online store, and for related purposes.


Pearson may offer opportunities to provide feedback or participate in surveys, including surveys evaluating Pearson products, services or sites. Participation is voluntary. Pearson collects information requested in the survey questions and uses the information to evaluate, support, maintain and improve products, services or sites, develop new products and services, conduct educational research and for other purposes specified in the survey.

Contests and Drawings

Occasionally, we may sponsor a contest or drawing. Participation is optional. Pearson collects name, contact information and other information specified on the entry form for the contest or drawing to conduct the contest or drawing. Pearson may collect additional personal information from the winners of a contest or drawing in order to award the prize and for tax reporting purposes, as required by law.


If you have elected to receive email newsletters or promotional mailings and special offers but want to unsubscribe, simply email information@informit.com.

Service Announcements

On rare occasions it is necessary to send out a strictly service related announcement. For instance, if our service is temporarily suspended for maintenance we might send users an email. Generally, users may not opt-out of these communications, though they can deactivate their account information. However, these communications are not promotional in nature.

Customer Service

We communicate with users on a regular basis to provide requested services and in regard to issues relating to their account we reply via email or phone in accordance with the users' wishes when a user submits their information through our Contact Us form.

Other Collection and Use of Information

Application and System Logs

Pearson automatically collects log data to help ensure the delivery, availability and security of this site. Log data may include technical information about how a user or visitor connected to this site, such as browser type, type of computer/device, operating system, internet service provider and IP address. We use this information for support purposes and to monitor the health of the site, identify problems, improve service, detect unauthorized access and fraudulent activity, prevent and respond to security incidents and appropriately scale computing resources.

Web Analytics

Pearson may use third party web trend analytical services, including Google Analytics, to collect visitor information, such as IP addresses, browser types, referring pages, pages visited and time spent on a particular site. While these analytical services collect and report information on an anonymous basis, they may use cookies to gather web trend information. The information gathered may enable Pearson (but not the third party web trend services) to link information with application and system log data. Pearson uses this information for system administration and to identify problems, improve service, detect unauthorized access and fraudulent activity, prevent and respond to security incidents, appropriately scale computing resources and otherwise support and deliver this site and its services.

Cookies and Related Technologies

This site uses cookies and similar technologies to personalize content, measure traffic patterns, control security, track use and access of information on this site, and provide interest-based messages and advertising. Users can manage and block the use of cookies through their browser. Disabling or blocking certain cookies may limit the functionality of this site.

Do Not Track

This site currently does not respond to Do Not Track signals.


Pearson uses appropriate physical, administrative and technical security measures to protect personal information from unauthorized access, use and disclosure.


This site is not directed to children under the age of 13.


Pearson may send or direct marketing communications to users, provided that

  • Pearson will not use personal information collected or processed as a K-12 school service provider for the purpose of directed or targeted advertising.
  • Such marketing is consistent with applicable law and Pearson's legal obligations.
  • Pearson will not knowingly direct or send marketing communications to an individual who has expressed a preference not to receive marketing.
  • Where required by applicable law, express or implied consent to marketing exists and has not been withdrawn.

Pearson may provide personal information to a third party service provider on a restricted basis to provide marketing solely on behalf of Pearson or an affiliate or customer for whom Pearson is a service provider. Marketing preferences may be changed at any time.

Correcting/Updating Personal Information

If a user's personally identifiable information changes (such as your postal address or email address), we provide a way to correct or update that user's personal data provided to us. This can be done on the Account page. If a user no longer desires our service and desires to delete his or her account, please contact us at customer-service@informit.com and we will process the deletion of a user's account.


Users can always make an informed choice as to whether they should proceed with certain services offered by InformIT. If you choose to remove yourself from our mailing list(s) simply visit the following page and uncheck any communication you no longer want to receive: www.informit.com/u.aspx.

Sale of Personal Information

Pearson does not rent or sell personal information in exchange for any payment of money.

While Pearson does not sell personal information, as defined in Nevada law, Nevada residents may email a request for no sale of their personal information to NevadaDesignatedRequest@pearson.com.

Supplemental Privacy Statement for California Residents

California residents should read our Supplemental privacy statement for California residents in conjunction with this Privacy Notice. The Supplemental privacy statement for California residents explains Pearson's commitment to comply with California law and applies to personal information of California residents collected in connection with this site and the Services.

Sharing and Disclosure

Pearson may disclose personal information, as follows:

  • As required by law.
  • With the consent of the individual (or their parent, if the individual is a minor)
  • In response to a subpoena, court order or legal process, to the extent permitted or required by law
  • To protect the security and safety of individuals, data, assets and systems, consistent with applicable law
  • In connection the sale, joint venture or other transfer of some or all of its company or assets, subject to the provisions of this Privacy Notice
  • To investigate or address actual or suspected fraud or other illegal activities
  • To exercise its legal rights, including enforcement of the Terms of Use for this site or another contract
  • To affiliated Pearson companies and other companies and organizations who perform work for Pearson and are obligated to protect the privacy of personal information consistent with this Privacy Notice
  • To a school, organization, company or government agency, where Pearson collects or processes the personal information in a school setting or on behalf of such organization, company or government agency.


This web site contains links to other sites. Please be aware that we are not responsible for the privacy practices of such other sites. We encourage our users to be aware when they leave our site and to read the privacy statements of each and every web site that collects Personal Information. This privacy statement applies solely to information collected by this web site.

Requests and Contact

Please contact us about this Privacy Notice or if you have any requests or questions relating to the privacy of your personal information.

Changes to this Privacy Notice

We may revise this Privacy Notice through an updated posting. We will identify the effective date of the revision in the posting. Often, updates are made to provide greater clarity or to comply with changes in regulatory requirements. If the updates involve material changes to the collection, protection, use or disclosure of Personal Information, Pearson will provide notice of the change through a conspicuous notice on this site or other appropriate way. Continued use of the site after the effective date of a posted revision evidences acceptance. Please contact us if you have questions or concerns about the Privacy Notice or any objection to any revisions.

Last Update: November 17, 2020