As you may know, VB6 performs a copy of the array when assigning an array to another array variable. After the assignment, the source and destination arrays are distinct objects, as this code demonstrates:
Dim source(10) As Integer
source(1) = 111
Dim dest() As Integer
dest() = source()
Debug.Print source(1), dest(1) ' displays "111,111"
' changing an element in either array doesn’t affect the other
source(1) = 222
Debug.Print source(1), dest(1) ' displays "222,111"
Conversely, an array assignment under VB.NET just copies the array address:, the source and destination array variables point to the same set of elements. In other words, changing an element through either variable would affect the value seen by the other array variable.
For these reasons, both the Upgrade Wizard and earlier versions of VB Migration Partner automatically force a copy operation when converting an array assignment. This is how Upgrade Wizard converts the above VB6 code snippet:
Dim source(10) As Integer
source(1) = 111
Dim dest() As Integer
dest = source.Clone()
Debug.Print source(1), dest(1) ' displays "111,111"
' changing an element in either array doesn’t affect the other
source(1) = 222
Debug.Print source(1), dest(1) ' displays "222,111"
It seems that adding a call to the Clone method solves the problem once and for all, but unfortunately this isn’t the case. As a matter of fact, there are several cases when the Upgrade Wizard (and probably other VB6-to-VB.NET conversion tools) doesn’t preserve functional equivalence with the original VB6 code.
For startes, a plain Clone method doesn't work correctly if the array you
are assigning is an array of arrays (Under VB6, an array of arrays is
a Variant array whose individual elements are arrays.) The problem here is that the
Array.Clone method performs a shallow copy and doesn’t correctly
copy nested arrays and the converted VB.NET application doesn’t work as
it should. For this reason, starting with version 1.10, VB Migration
Partner supports the CloneArray6 helper method, which can perform both a shallow copy and a deep copy (if the second argument is True, also nested arrays are copied):
Dim arrayOfArrays() As Variant
' …
Dim dest() As Variant
dest() = CloneArray6(arrayOfArrays(), True)
The
CloneArray6 method is available both in VB6 and VB.NET, but the VB6
version is a do-nothing version and doesn't change the application behavior. The CloneArray6 method can correctly handle arrays of arrays
of any nesting level, arrays of structures, and more in general arrays
of any ICloneable object.
Another case when UpgradeWizard generates bugged VB.NET code is when assigning a structure that contain one or more arrays. Consider this VB.NET code, generated by Upgrade Wizard when converting an assignment between two structures:
Structure MyUDT
Public arr() As Integer
End Structure
Sub Test()
Dim udt As MyUDT
Dim udt2 As MyUDT
udt2 = udt
' udt and udt2 point to different structures, but
' they share the same set of array elements
' …
End Sub
It is obvious that the assignment between structures doesn’t work as in the original VB6 code, because the udt and udt2 structures are pointing to the same array: changing one element in the array in one structure affects the array pointed to by the other structure.Unlike Upgrade Wizard and other conversion tools, VB Migration Partner works around this issue by rendering the assignment as follows:
Structure MyUDT
Public arr() As Integer
Function Clone() As MyUDT
Dim copy As MyUDT = Me
copy.arr = CloneArray6(Me.arr)
Return copy
End Function
End Structure
Sub Test()
Dim udt As MyUDT
Dim udt2 As MyUDT
udt2 = udt.Clone()
' udt and udt2 are now completely disjoint objects, and share no arrays
' …
End Sub
You might bump into another elusive bug when invoking methods that store a reference to the array passed as an argument. The simplest example of this problem is when you store an array into multiple items of a Collection, as this VB6 code demonstrates:
Dim col As New Collection
Dim values(1) As String
values(0) = "Francesco": values(1) = "Balena"
col.Add(values)
' notice that here we reuse the same array…
values(0) = "Giuseppe": values(1) = "Dimauro"
col.Add(values)
Debug.Print col(1)(0) & "," & col(2)(0) ' => "Francesco,Giuseppe"
The Upgrade Wizard converts this code verbatim, but the resulting VB.NET code just doesn’t work as expected: both col(1) and col(2) elements actually point to the same array, therefore the text displayed in the Output window is not the one you hoped for:
Debug.WriteLine(col(1)(0) & "," & col(2)(0)) ' => "Giuseppe,Giuseppe"
A solution to this problem is to explicitly ReDim the array after each Add method, as follows:
Dim col As New Collection
Dim values(1) As String
values(0) = "Francesco": values(1) = "Balena"
col.Add(values)
' allocate a new memory block for array elements
ReDim values(1)
values(0) = "Giuseppe": values(1) = "Dimauro"
col.Add(values)
However, this workaround adds unnecessary overhead to the VB6 code. Starting with VB Migration Partner version 1.10 you can avoid this overhead and have the most efficient behavior in both VB6 and VB.NET by using the CloneArray6 method:
Dim col As New Collection
Dim values(1) As String
values(0) = "Francesco": values(1) = "Balena"
col.Add(CloneArray6(values))
values(0) = "Giuseppe": values(1) = "Dimauro"
col.Add(CloneArray6(values))
The bottom line: pay close attention to how arrays are assigned and copied in your VB.NET project and carefully scrutinize the code that your VB6-to-VB.NET migration tool generates in these cases. Else you might be spending hours trying to track down these elusive bugs.