This chapter is from the book
This chapter is from the book
This chapter is from the book
Steps for Pre-migration Changes
This section gives some coding recommendations for the Visual Basic 6.0 application. These pre-migration changes help smooth the upgrade of the Visual Basic 6.0 application to Visual Basic .NET.
Declare all variables on separate lines and ensure that all variables are assigned a data type wherever possible:
Dim FirstName, LastName As String
Table 3-1. Data Type Changes from Visual Basic 6.0 to Visual Basic .NET
| Visual Basic 6.0 Data Type |
Visual Basic 6.0 Data Type Size (Bits) |
Visual Basic .NET Data Type |
Visual Basic .NET Data Type Size (Bits) |
|---|---|---|---|
| Byte |
8 |
Byte |
8 |
| Short |
8 |
Int16 |
16 |
| Integer |
16 |
Int32 |
32 |
| Long |
32 |
Int64 |
64 |
| Single |
32 |
Single |
32 |
| Double |
64 |
Double |
64 |
| Boolean |
16 |
Boolean |
|
| Char |
Char |
16 |
|
| Decimal |
96 |
Decimal |
96 |
| Object |
32 |
Object |
|
| String |
String |
For example, when the preceding code is migrated to Visual Basic .NET using the upgrade wizard, the variable LastName is retained as String. However, because FirstName is a Variant in the Visual Basic 6.0 code, it is converted into an Object type and a warning will be issued by the upgrade wizard. To avoid that warning, declare the variable and assign the proper data types:
Dim FirstName As String Dim LastName As String
Declare all arrays to be zero-based arrays:
Dim Name (1 to 10) As String
In Visual Basic 6.0, arrays can be defined with lower and upper bounds of any integer number. One can also use ReDim to reassign a variant as an array. Arrays in Visual Basic .NET must have a lower bound of zero, and ReDim cannot be used unless the variable was previously declared with Dim As Array. The upgrade wizard will automatically convert the preceding array base to zero. However, the developer can do the same before migration as follows:
Dim Name (0 to 10) As String
Check for arrays and fixed-length strings in user-defined types and change them as recommended in the following code snippet.
When the following code is upgraded to Visual Basic .NET, it fails at runtime because the user-defined types are converted into structures and members of the structure that require parameterless constructors require initialization:
Private Type Customer Customer_ID (5) As Integer Customer_Name As String * 50 End Type Sub CustomerData() Dim CustomerA As Customer End Sub
This code needs to be corrected as shown in the following example. The type has to be defined without the size, and the fixed-length string has to be defined without the length. When a variable of the type Customer is defined as shown, the code can then ReDim the array size and fix the length of the string to the desired one. If the user-defined types are defined as shown, developers will not have to make changes to the upgraded code:
Private Type Customer Customer_ID () As Integer Customer_Name As String End Type Sub CustomerData () Dim CustomerA As Customer ReDim CustomerA.Customer_ID(5) As Integer CustomerA.Customer_Name = String$(50, " ") End Sub
Use intrinsic constants rather than relying on their underlying values. Intrinsic constants such as VbMaximized, VbMinimized, VbOK, and VbCancel should be used in place of their actual numerical values.
Boolean comparisons. AND and OR operators could be used in Boolean comparisons as shown in the following code snippet:
If intVariable1 and intVariable2 Then MsgBox "Condition passed" End If
If the variables intVariable1 and intVariable2 are defined as integer variables, a bitwise And operation is performed and wrong results can be obtained. The And operator works properly only on Boolean values, and hence the preceding code needs to be changed as follows:
If (intVariable1 <>0) and (intVariable1 <> 0) Then MsgBox("Condition passed") End IfThere are other operators such as Eqv and Imp that are supported in Visual Basic 6.0. Eqv performs logical equivalence on two expressions. The Imp operator performs a logical implication of two expressions. These operators are not supported in Visual Basic .NET. However, any Visual Basic 6.0 code that contains these operators gets upgraded with the help of the Microsoft.VisualBasic.Compatibility namespace.
Remove processing actions from If conditions:
If len(sCustomerName) = 0 And (isCustomer(CustId)) Then MsgBox "Customer Found" End If
In this example a processing condition has been added to the If condition. Even though it will be upgraded and work properly in Visual Basic .NET, it is recommended that the processing actions not be part of the If conditions. So the code can be changed as follows. Note that parentheses have been put around the message text in the MsgBox function.
Dim bValueFound As Boolean bValueFound = isCustomer(CustId) If len(sCustomerName) = 0 And (bValueFound) Then MsgBox ("Customer Found") End IfUse early binding wherever possible. In the following code sample, there is a label named lblCodeSnippet6 on the form. The code snippet creates an object and assigns the label on the form to that object. The caption property of the newly created object is set to some new value. These values get updated on the form.
Dim objName1 As Object Set objName1 = Me.lblCodeSnippet6 objName1.Caption = "Some New Value"
When this code gets migrated to Visual Basic .NET, the upgrade wizard cannot resolve the Caption property of the object because it is late bound to a label. This gives an error at runtime.
With the code changed as follows, the upgrade wizard knows that the object is a label and hence upgrades the Caption property to text property correctly and the code executes correctly in Visual Basic .NET.
Dim objName1 As Label Set objName1 = Me.lblCodeSnippet6 ObjName1.Caption = "Some New Value"
Use explicit type conversions wherever possible to make the code readable. This will also help reduce the number of warnings that get issued when the code gets migrated to Visual Basic .NET using the upgrade wizard:
Dim A As String Dim B As Integer Dim C As String A = "1" B = 2 C = "3" MsgBox (A + B) 'Result is 3 MsgBox (A + C) 'Result is 13 MsgBox (B + C) 'Result is 5
In this code snippet the addition is done in the context of the type of the variables being used as operands. For example, if the addition operation involves an integer, the addition operation is numeric and produces a numeric result. If the both the operands contain strings, the operation is string concatenation and results in a string. However, as a matter of good programming practice it is recommended to explicitly type the variables by using functions such as CInt or CStr:
Dim A As String Dim B As Integer Dim C As String A = "1" B = 2 C = "3" MsgBox (A + CStr(B)) 'Result is 12 MsgBox (A + C) 'Result is 13 MsgBox (CStr(B) + C) 'Result is 23
In this case, the function CStr is explicitly used to mark that the additions are supposed to be string additions.
Make parameters to functions and procedures ByRef or ByVal. Visual Basic 6.0 allows the parameters to be defined as ByRef or ByVal. If the parameter is not marked explicitly as ByVal or ByRef, the system determines whether it becomes ByRef or ByVal. If the parameter is of an intrinsic type (Integer, Long, Boolean, String, and so on), it is assumed to be the default ByRef; otherwise the parameter is assumed to be ByVal.
In Visual Basic .NET, all parameters are ByVal by default. So the subroutine or function has to be explicitly declared as ByRef to get it to change a parameter.
Default properties. In Visual Basic 6.0, we use the default properties of objects while programming. For example, a TextBox control has a default property called Text. The following code shows that the TextBox control can be used directly in the method call and its default property would be used. In the code, a TextBox named Text1 is already placed on a form. An instance of an object is created and the instance of Text1 is assigned to the object.
Dim objTextBox As Object Set objTextBox = Me.Text1 MsgBox objTextBox
Before migration this code should be changed as follows:
Dim objTextBox As TextBox Set objTextBox = Me.Text1 MsgBox objTextBox.Text
Database applications. ADO is still supported in Visual Basic .NET. However, RDO and DAO are not supported. So it is recommended to write database applications using ADO. If the Visual Basic 6.0 application has been written using DAO or RDO, these technologies will work well in Visual Basic .NET only if data binding has not been used. For data binding and data environment, it is recommended to use ADO in the Visual Basic 6.0 application. DAO and RDO data binding is not supported in Visual Basic .NET.
Add business logic to components and classes. It is possible that in a Visual Basic 6.0 application the business logic has been written along with the presentation logic. Because Visual Basic .NET has introduced new features such as Windows Forms and Web Forms, the Visual Basic 6.0 application creates problems during the migration to Visual Basic .NET. Because it is easier to migrate classes of Visual Basic 6.0 into Visual Basic .NET than the modules, it is recommended that all business logic be written in the form of components and classes.
Use Date data type instead of double for manipulating dates:
Dim dtTomorrow As Date Dim dtToday As Double dtTomorrow = Date dtToday = dtTomorrow dtTomorrow = #12/31/2002# MsgBox (DateDiff("d", dtToday, dtTomorrow))In Visual Basic, Date type variables could be used in the form of doubles. The upgraded code will work in Visual Basic .NET. However, functions for converting the double value into date values get called for converting double values into dates. This may add a bit of processing overhead. This can be avoided altogether by using a Date type variable in Visual Basic 6.0. In the preceding code, variable dtToday can be declared as Date as follows:
Dim dtTomorrow As Date Dim dtToday As Date dtTomorrow = Date dtToday = dtTomorrow dtTomorrow = #12/31/2002# MsgBox (DateDiff("d", dtToday, dtTomorrow))