Optional and ByRef Parameters

Analogy categoryAnalogies

ByVal vs. ByRef: How Arguments Are Passed

ByVal, the default, passes a copy of the argument's value into a procedure, so changes to the parameter inside the procedure do not affect the caller's original variable (for value types like Integer or Double). ByRef instead passes a reference to the caller's actual variable, so any change made to the parameter inside the procedure is reflected back in the caller after the procedure returns, which is essential for procedures designed to output multiple results.

🏏

Cricket analogy: Handing a scorer a photocopy of the scoresheet is like ByVal — they can scribble on it freely without affecting the official book — while handing them the actual official scorebook is like ByRef, where their edits directly update the real record everyone else sees.

Optional Parameters and Default Values

Optional parameters, marked with the Optional keyword, must specify a default value and must appear after all required parameters in the parameter list, e.g., Sub Greet(name As String, Optional greeting As String = "Hello"). Callers can omit the optional argument entirely to accept the default, or supply their own value; VB.NET also supports named arguments, letting callers specify Greet(name:="Ana", greeting:="Hi") in any order for extra clarity, especially useful when a procedure has several optional parameters.

🏏

Cricket analogy: A coach's drill function RunFieldingDrill(playerName As String, Optional durationMinutes As Integer = 20) lets most players default to a 20-minute session while a call like RunFieldingDrill("Kohli", durationMinutes:=45) extends it for someone needing extra reps.

ParamArray for Variable-Length Argument Lists

ParamArray lets a procedure accept an arbitrary number of trailing arguments of the same type, collected into an array inside the procedure body; it must be the last parameter and is declared with ParamArray, e.g., Sub PrintAll(ParamArray items() As String). Callers can then pass any number of comma-separated arguments — including zero — without wrapping them in an explicit array literal, though passing an actual array directly also works.

🏏

Cricket analogy: A stats function CalculateTotal(ParamArray scores() As Integer) lets a scorer call CalculateTotal(45, 12, 89, 3, 67) for as many innings scores as needed in a series, without pre-building an array first.

Common Gotchas and Practical Guidelines

A frequent mistake is expecting ByVal to protect a mutable reference type's contents — passing a List(Of T) or array ByVal still lets the procedure modify the elements inside it, since only the reference itself is copied, not the underlying object. Another common issue is over-using Optional parameters instead of overloading, which can make call sites ambiguous or hide required business logic behind silently-applied defaults; a good rule of thumb is to use Optional only for genuinely optional settings, and use ByRef sparingly, since it can make data flow harder to trace compared to returning a value from a Function.

🏏

Cricket analogy: A team manager mistakenly assumes lending out a copy of the kit list (ByVal) protects the actual equipment room, but since the list still references the real bags, marking an item as 'used' still updates the shared inventory everyone relies on.

vbnet

Module ParameterDemo
    Sub Main()
        ' Optional parameter with named argument
        Greet("Ana")
        Greet("Diego", greeting:="Hola")

        ' ByRef swaps the caller's actual variables
        Dim x As Integer = 5
        Dim y As Integer = 10
        SwapValues(x, y)
        Console.WriteLine($"x={x}, y={y}")  ' x=10, y=5

        ' ParamArray accepts any number of arguments
        Console.WriteLine($"Sum: {SumAll(4, 8, 15, 16, 23, 42)}")
    End Sub

    Sub Greet(name As String, Optional greeting As String = "Hello")
        Console.WriteLine($"{greeting}, {name}!")
    End Sub

    Sub SwapValues(ByRef a As Integer, ByRef b As Integer)
        Dim temp As Integer = a
        a = b
        b = temp
    End Sub

    Function SumAll(ParamArray numbers() As Integer) As Integer
        Dim total As Integer = 0
        For Each n As Integer In numbers
            total += n
        Next
        Return total
    End Function
End Module

Named arguments (paramName:=value) work with any parameter, not just Optional ones, and are especially valuable when a procedure has several Optional parameters — they make the call site self-documenting and let you skip earlier optional arguments while still supplying a later one.

Optional parameters must have a compile-time constant default value and must be declared after all required parameters. You cannot write Sub Foo(Optional a As Integer = 1, b As String) — the required parameter b would need to come before the Optional one.

ByVal (the default) passes a copy of the value or reference; ByRef passes the actual variable, allowing the procedure to change the caller's original value.
Optional parameters require a default value and must be listed after all required parameters in the declaration.
Named arguments (name:=value) let callers pass arguments in any order and make optional-heavy call sites clearer.
ParamArray collects any number of trailing same-type arguments into an array and must be the last parameter.
ByVal does not protect a mutable reference type's internal data — only the reference itself is copied, not the object.
Overloading is often clearer than stacking many Optional parameters when the different call patterns represent genuinely distinct use cases.
Use ByRef sparingly; returning a value from a Function is usually easier to trace than mutating a ByRef parameter.