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.
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 ModuleNamed 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.
Practice what you learned
1. What must an Optional parameter always have?
2. Where must a ParamArray parameter appear in a procedure's parameter list?
3. Why does modifying elements of a List(Of T) passed ByVal still affect the caller's original list?
4. What does the ByRef keyword allow a procedure to do?
5. Which syntax correctly calls a procedure using a named argument?
Was this page helpful?
You May Also Like
Subs and Functions in VB.NET
Understand how to organize reusable code in VB.NET using Sub and Function procedures, including parameters, return values, and overloading.
Conditionals in VB.NET
Learn how to control program flow in VB.NET using If...Then...Else, Select Case, and logical operators to make decisions based on data.
Error Handling with Try/Catch
Learn structured exception handling in VB.NET using Try, Catch, Finally, and Throw to write robust code that gracefully handles runtime errors.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics