Home > Articles > Programming > Visual Basic

  • Print
  • + Share This
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 If 

    There 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 If 
  • Use 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)) 
  • + Share This
  • 🔖 Save To Your Account