0672322641

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)
        MyBase.New()
        FindCourseInfo(CourseID)
        ...
    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.

Namespaces

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.

Inheritance

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

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)

Multithreading

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.

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
   Next
   Beep()
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)
   busyThread.Start()
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()
   Beep()
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
   GC.Collect()
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+.