Is this right? Sub with Byref can do the same thing a Function does?

[SandiegoSSD]

Newbie vb.net learner here. seeking some clarification on this question.
I think this Sub below

Sub(ByVal y as integer, Byref X As integer)
..
End sub


And this function


Function X (Byval y as integer) as integer
return x
end function

do the same thing in terms of changing the value of X upon completing the sub/function.
So are these always interchangeable?

[DataMiser]

Passing byRef will change the value of the Passed Variable
A function returns whatever you tell it to and if you assign the result to the original variable then it will change the original variable. Each has it's uses and they are not really interchangable though could be made to do a similar thing.

Your code above would not work Your function is passing y and your are returning X which is not the variable passed but the name of the function. I am not sure if this would fail to compile or run in an endless loop but it certianly will not do the same thing as the sub you gave.

Your Sub has no name so that would not compile either

[Shaggy Hiker]

The former is generally frowned upon, though it is occasionally essential. The reason is more about philosophy than anything else, though. The philosophy is that changing the arguments to a method is a side effect of the method, and side effects make code harder to understand, harder to reuse, and harder to work with. For that reason they are not equivalent in design.

In the specific case you showed, the Sub may be slower than the Function, simply because it seems like the reference to the integer will mean that the integer has to be boxed and unboxed. However, when I tested the two like so:

Private Sub test1(ByVal arg As Object)
        Dim x As Integer
        Dim st1 As String = ""
        Dim n As Integer


        For x = 0 To 10000000
            TestVal(x)
        Next

    End Sub

    Private Sub test2(ByVal arg As Object)
         Dim x As Integer
        Dim st1 As String = ""
        Dim n As Integer


        For x = 0 To 10000000
            TestRef(x, n)
        Next

    End Sub

    Private Function TestVal(incoming As Integer) As Integer
        Return incoming + 1
    End Function

    Private Sub TestRef(incoming As Integer, ByRef ret As Integer)
        ret += 1
    End Sub

It turned out that the ByRef version was very slightly faster than the ByVal version. This difference is only about 5% over a million iterations, so it is a vanishingly small amount, but there you have it.

[DataMiser]

The byRef will make a larger difference on larger variables most noticable on large strings or at least that used to be the case.

I remember doing some testing on this back in VB5 and values under 10-20 bytes the difference was very small but when those values where several hundred or thousand bytes it became quite noticable at runtime, especially if it was being done often.

[Shaggy Hiker]

That should only hold true for Value types, if I understand you correctly....but I think I might not be understanding you correctly. Are you saying that the benefit of using a ByRef will get larger, or that ByRef will get slower, as the size of the item being moved increases?

[DataMiser]

The benefit will increase as the value type gets larger.

I once took over a project written by someone else where it was parsing a file and it was basically passing the entire file [about 500k] in a string byval to a function. It was doing this in a loop, I forget the details but at any rate when passed byval the routine took about 16 minutes to complete. When changed to byRef it took roughly 16 seconds. So in that case the difference was huge.

[David Anton]

I once took over a project written by someone else where it was parsing a file and it was basically passing the entire file [about 500k] in a string byval to a function. It was doing this in a loop, I forget the details but at any rate when passed byval the routine took about 16 minutes to complete. When changed to byRef it took roughly 16 seconds. So in that case the difference was huge.

Passing a string by value does not cause the string to be copied - it's a reference type - there is no copying when passed by value (except the reference itself). Perhaps this was VB6 - can't remember what happened with VB6.

[Shaggy Hiker]

Strings are weird.

[techgnome]

If you think about it, it makes sense that performance slows as the byVal object gets bigger... it's more data that has to be copied to the stack - which means a stack allocation has to occur - as opposed to grabbing a pointer and leaving the item on the heap.

That strings are weird is true indeed.

-tg

[DataMiser]

The instance I refered to was actually VB5, I am pretty sure that 6 behaves the same but I have no idea about .Net versions. They may be quite different.

[Shaggy Hiker]

Strings are semi-reference types. Technically, they are reference types, but they are handled in a special way, so you can cause them to act like value types. Somebody expained that on here once...and I promptly forgot it. The only real key is that you can't be certain that a string will act like other reference types just because it is a reference type.