Array as an argument in a procedure vb6 vs vb.net

Question

Here it is a procedure in vb6 and it is working fine like the example included:

' Check_UnCheck

' check an array of some checkboxes, uncheck an array of another checkboxes

' Example of usage :

CheckBox.Check_UnCheck Array(chkCheck3, chkCheck5), Array(chkCheck1, chkCheck4)


Public Sub Check_UnCheck(ByRef CheckArray As Variant, ByRef UnCheckArray As Variant)

    Dim i As Integer
    Dim conControl As Control

    For i = LBound(CheckArray) To UBound(CheckArray)
        Set conControl = CheckArray(i)
        conControl.Value = 1
    Next

    For i = LBound(UnCheckArray) To UBound(UnCheckArray)
        Set conControl = UnCheckArray(i)
        conControl.Value = 0
    Next

End Sub

what is the equivalent in vb.net for the above procedure, the MSDN Documentation says :

• We cannot use more than one parameter array in a procedure, and it must be the last argument in the procedure definition.

Answer 1

Try below code.

Look into comments for detailed description.

'DECLARE YOUR ARRAYS.
Dim array1 = New CheckBox() {CheckBox3, CheckBox5}
Dim array2 = New CheckBox() {CheckBox1, CheckBox4}

'CALL CHECK AND UNCHECK FUNCTION.
Check_UnCheck(array1, array2)


'YOUR FUNCTION DEFINITION.
Public Sub Check_UnCheck(ByRef CheckArray As CheckBox(), ByRef UnCheckArray As CheckBox())

    'LOOP FIRST ARRAY AND CHECK THEM.
    For index = 0 To CheckArray.GetUpperBound(0)
        CheckArray(index).Checked = True
    Next

    'LOOP SECOND ARRAY AND UNCHECK THEM.
    For index = 0 To UnCheckArray.GetUpperBound(0)
        UnCheckArray(index).Checked = False
    Next

End Sub

Answer 2

First you are confusing "parameter array" with an array of controls, they are not the same thing. A parameter array is when a method takes a variable number of parameters (all of the same type), the compiler then bundles those up into an array and passes that to the method. In order for that to happen the method has to use the keyword ParamArray.

VB.net does not have conrtol arrays in the sense that vb6 did, but that isn't what you example is using. You example is using a simple array of controls. As an aside, your example is using ByRef which was the default in VB6, but it is unnecessary in this case for both VB6 and VB.net. Given that it's usage in VB.net is no longer the default, using it unnecessarily is misleading.

You are passing in two arrays, the second could be a ParamArray but there is little point in doing so.

The basic and minimum change to get your code to work is simple, change the "Variant" to "CheckBox()". But that is not what I would recommend. There are a couple of other minor changes that make it more flexible and more readable.

Public Sub Check_UnCheck(CheckArray As IEnumerable(Of CheckBox), 
                         UnCheckArray As IEnumerable(Of CheckBox)) 
    ' Here I have replaced the Variant, which is not supported in
    ' .net, with the generic IEnumerable of checkbox.  I used an
    ' Ienumerable, instead of an array because it will allow making 
    ' just a minor change to the call site.

    ' here I have eliminated the index variable, and moved the  
    ' declaration of the conControl variable into the for each.  
    ' Option Infer On statically types the variable as a checkbox
    For Each conControl In CheckArray
        ' Checkbox controls do not have a value property.
        ' 1 is not true, true is true.
        conControl.Checked = True
    Next

    For Each conControl in UnCheckArray
        conControl.Checked = False
    Next

End Sub

This would then be called like so: Check_UnCheck({chkCheck3, chkCheck}, {chkCheck1, chkCheck4})