Working with VB .NET
In the previous chapter, we looked at the VB .NET IDE in some detail. We expand on what we learned in the previous chapter by detailing some of the differences between VB6 and Visual Basic .NET. The Windows XP Tablet PC Edition Platform Software Development Kit (SDK) can be used with VB6 or VB .NET, although this book uses .NET. This chapter helps VB6 users to get up to speed with VB .NET. First, we look at how you can use the Upgrade Wizard to move your products from VB6 to VB .NET, and then we look at the changes that have been made to the programming language.
Working with Both Visual Basic 6 0 and Visual Basic NET
The Visual Basic .NET and Visual Basic 6.0 IDEs can be used on the same computer and can even execute simultaneously. This is something very new as previous versions of Visual Basic caused considerable problems for one another if they were installed on the same machine. Additionally, applications written and compiled in Visual Basic .NET and Visual Basic 6.0 can be installed and executed on the same computer. Although the projects in this book have been written for Visual Basic .NET, they can be written so that they will work in VB6.
Upgrading Version 6 Projects to Visual Basic NET
Because of the new changes associated with Visual Basic .NET, VB6 code needs to be upgraded before it can be used. Fortunately, the vast majority of the time, this is very easy because it happens automatically when you open a Visual Basic 6 project in Visual Basic .NET. This is not a perfect upgrade, however, and you'll often be left with a list of tasks that the wizard could not handle on its own.
An Upgrade Wizard, which can be seen in Figure 3.1, steps you through the upgrade process and creates a new Visual Basic .NET project. The existing Visual Basic 6 project is left unchanged. If you have Visual Basic version 5 projects, it's best to upgrade them to 6 before moving on to .NET (or version 7 as it is sometimes called).
Figure 3.1: The Upgrade Wizard makes it easy to convert version 6 projects to Visual Basic .NET.
When your project is upgraded, the language is modified for any syntax changes and your Visual Basic 6.0 forms are converted to Windows Forms. Depending on your application, you may need to make minor changes to your code after it is upgraded. Many times, this can be necessary because certain features either are not available in Visual Basic .NET or the features have changed significantly enough to warrant manual changes.
After your project is upgraded, Visual Basic .NET provides an 'upgrade report' to help you make changes and review the status of your project. The items are displayed as tasks in the new Task List window, so you can easily see what changes are required, and navigate to the code statement simply by double-clicking the task. Many times, the document recommendations simply represent good programming practices, but they also identify the Visual Basic 6 objects and methods that are no longer supported.
Problems with Code Upgrades
When your VB6 code is upgraded to Visual Basic .NET, it follows a specific set of rules. The following rules list some basic information that you should keep in mind if you are currently planning to upgrade a VB6 project to .NET.
Variant to Object
Previous versions of Visual Basic supported the Variant data type, which could be assigned to any primitive type. In fact, it is the default data type if a variable wasn't declared in VB6. VB .NET converts variants to the Object data type.
Integer to Short
In Visual Basic .NET, the data type for 16-bit whole numbers is now Short. The data type for 32-bit whole numbers is now Integer, and Long is now 64 bits.
Table 3.1 shows a few examples.
|
VB6 |
VB .NET |
|---|---|
|
Dim A as Integer |
Dim A as Short |
|
Dim B as Long |
Dim B as Integer |
|
N/A |
Dim A as Long |
|
Variant |
N/A (Use new ‘Object') |
|
Currency |
N/A (Use Decimal or Long) |
|
N/A |
Decimal |
|
String |
String (doesn't support fixed-length strings) |
APIs
The vast majority of API calls expect 32-bit values if they take numeric arguments. With the previous section in mind, you can see that problems are sure to arise. For instance, in VB6, a 32-bit value is a Long data type, whereas in .NET, a Long is 64 bits. You'll have to use Integer as the data type in .NET to make the calls correctly. According to Microsoft documentation, many APIs will no longer be callable from VB or may have replacements.
The Upgrade Wizard tries to correct API calls by creating wrappers for them. This is not a good idea and you should look at every API call individually to make any changes you need.
The following code samples are an example of an API call under VB6 and under VB .NET.
Listing 3.1 Visual Basic 6.
Private Declare Function GetVersion Lib "kernel32" () As Long Function GetVer() Dim Ver As Long Ver = GetVersion() MsgBox ("System Version is " & Ver) End Function
Listing 3.2 Visual Basic .NET.
Private Declare Function GetVersion Lib "kernel32" () As Integer Function GetVer() Dim Ver As Integer Ver = GetVersion() MsgBox("System Version is " & Ver) End Function
Newly Introduced Keywords
VB .NET introduces several new keywords that have no counterpart in VB6. Table 3.2 details some of them:
|
Keyword |
Notes |
|---|---|
|
Catch |
New error handling; indicates code to use to process errors |
|
Char |
New character data type |
|
Finally |
New error handling; indicates code to use to run regardless of errors |
|
Imports |
Makes an object hierarchy (namespace) available in a module |
|
Inherits |
Points to a base class for inheritance |
|
MustOverride |
Indicates that any class that derives from this class must supply an override for this member |
|
MyBase |
References the base class for use by subclass code |
|
Namespace |
Specifies a namespace for a module |
|
Overloads |
Indicates there's more than one version of a function and the compiler can distinguish among them by the input parameters |
|
Overrides |
Indicates a member overrides the identically named member in the base class |
|
Overridable |
Allows a member to be overridden in any class derived from the base class |
|
Protected |
Is only available to classes derived from this class |
|
ReadOnly |
Is used in a property that contains only a 'Get' |
|
Shared |
Indicates all instances of a class should share a variable in a class |
|
Throw |
New error handling; allows you to raise an error |
|
Try |
New error handling; starts code with error handling enabled |
|
Webmethod |
Tags a method as part of a publicly available Web service |
|
WriteOnly |
Is used in a property that contains only a 'Set' |
Removed from NET
Like the additions from the previous section, there are also some items that have been removed in VB .NET. The following list details some of the removed keywords and statements:
- VarPtr
- ObjPtr
- StrPtr
- LSet
- GoSub
- Let
- Is Missing
- DefBool
- DefByte
- DefLng
- DefCur
- DefSng
- DefDbl
- DefDec
- DefDate
- DefStr
- DefObj
- DefVar
- On x Goto
Table 3.3 details some commands that have equivalents in VB .NET:
|
VB6 |
VB .NET Namespace |
Method/Property |
|---|---|---|
|
Circle |
System.Drawing.Graphics |
DrawEllipse |
|
Line |
System.Drawing.Graphics |
DrawLine |
|
Atn |
System.Math |
Atan |
|
Sgn |
System.Math |
Sign |
|
Sqr |
System.Math |
Sqrt |
|
Lset |
System.String |
PadRight |
|
Rset |
System.String |
PadLeft |
|
Rnd |
Microsoft.VisualBasic.Compatibility.VB6 |
Rnd |
|
Round |
Microsoft.VisualBasic.Compatibility.VB6 |
Round |
|
DoEvents |
System.Winform.Application |
DoEvents |
This is certainly not an exhaustive list as there are sure to be other items that have been added and removed. However, this list should serve as a good focal point for your work. There are a couple of additional commands that are no longer supported. One in particular is the Set command, which has been removed so that the following code in VB 6
Set objObject = objAnotherObject
will be changed to:
objObject = objAnotherObject
Another widely used command that has been changed is the Debug command, which was used as follows in VB6:
Debug.Print
In VB .NET, this is now:
Arrays
The use of arrays in VB .NET has also changed. In Visual Basic 6, if you declare an array like the following, you would get 11 items from 0 to 10:
Dim number(10) as Integer
Within VB .NET, the same array only gives you 10 items from 0 to 9.
Default Properties
In Visual Basic 6, a control or object had a default property that wouldn't need to be specified. For instance, if you wanted to set a TextBox equal to a string, you would simply use:
txtInformation = "This is a string"
Visual Basic .NET doesn't support default properties. So instead, you have to make sure to specify it as follows:
txtInformation.Text = "This is a string"
References to Form Controls
Controls in Visual Basic 6 were public. That is, you could simply reference a control on form 1 inside the Code Editor on form 2 by simply using form1.textbox1.text. In VB .NET, you'll have to create a public Let and Get property procedure for every control property you want to have access to.
Get and Let are now combined in VB .NET, so instead of being two separate property procedures, you create one.
Listing 3.3 Visual Basic 6 code.
Property Get PropertyA() As Integer m_PropertyA = PropertyA End Property Property Let PropertyA(NewValue As Integer) m_PropertyA = NewValue End Property
Listing 3.4 Visual Basic .NET code.
Property PropertyA() As Short Get m_PropertyA = MyPropertyA End Get Set m_PropertyA = Value End Set End Property
Forms and Controls
Visual Basic .NET forms are now called Windows Forms. The following list gives you an idea of the differences between version 6 and .NET forms:
- Windows Forms do not support the OLE container control.
- Windows Forms only support true-type and open-type fonts.
- There are no shape controls in Windows Forms. Shape controls have been upgraded to labels.
- Drag-and-drop properties of VB6 do not work on Windows Forms.
- Windows Forms have no support for Dynamic Data Exchange (DDE).
- There is no line control in Windows Forms.
- Windows Forms do not have access to form methods, such as Circle or Line.
- Windows Forms do not support the PrintForm method.
- Clipboards are different and cannot be upgraded from version 6 to .NET.
Summary
In this chapter, we looked at some of the changes that have been made to VB .NET. There are complete books written on this subject, so this chapter should not be considered an all-inclusive list of changes. However, it should serve its purpose of providing you with the ideas that have been altered and will help you in subsequent chapters. In Chapter 4, Basics of the .NET Framework, we spend a little time looking at the Visual Basic .NET Framework. After we have a little more background information, we move on to writing several complete applications in VB .NET.