Declares the name, parameters, and code that define a
[ <attributelist> ] [ accessmodifier ] [ proceduremodifiers ] [ Shared ] [ Shadows ] [ Async | Iterator ] Function name [ (Of typeparamlist) ] [ (parameterlist) ] [ As returntype ] [ Implements implementslist | Handles eventlist ] [ statements ] [ Exit Function ] [ statements ] End Function
Optional. See Attribute List.
Optional. Can be one of the following:
Optional. Can be one of the following:
Optional. See Shared.
Optional. See Shadows.
Optional. See Async.
Optional. See Iterator.
Required. Name of the procedure. See Declared Element Names.
Optional. List of type parameters for a generic procedure. See Type List.
Optional. List of local variable names representing the parameters of this procedure. See Parameter List.
On. Data type of the value returned by this procedure.
Optional. Indicates that this procedure implements one or more
Functionprocedures, each one defined in an interface implemented by this procedure's containing class or structure. See Implements Statement.
Implementsis supplied. List of
Functionprocedures being implemented.
implementedprocedure [ , implementedprocedure ... ]
implementedprocedurehas the following syntax and parts:
Required. Name of an interface implemented by this procedure's containing class or structure.
Required. Name by which the procedure is defined in
Optional. Indicates that this procedure can handle one or more specific events. See Handles.
Handlesis supplied. List of events this procedure handles.
eventspecifier [ , eventspecifier ... ]
eventspecifierhas the following syntax and parts:
Required. Object variable declared with the data type of the class or structure that raises the event.
Required. Name of the event this procedure handles.
Optional. Block of statements to be executed within this procedure.
Terminates the definition of this procedure.
All executable code must be inside a procedure. Each procedure, in turn, is declared within a class, a structure, or a module that is referred to as the containing class, structure, or module.
To return a value to the calling code, use a
Function procedure; otherwise, use a
Defining a Function
You can define a
Function procedure only at the module level. Therefore, the declaration context for a function must be a class, a structure, a module, or an interface and can't be a source file, a namespace, a procedure, or a block. For more information, see Declaration Contexts and Default Access Levels.
Function procedures default to public access. You can adjust their access levels with the access modifiers.
Function procedure can declare the data type of the value that the procedure returns. You can specify any data type or the name of an enumeration, a structure, a class, or an interface. If you don't specify the
returntype parameter, the procedure returns
If this procedure uses the
Implements keyword, the containing class or structure must also have an
Implements statement that immediately follows its
Structure statement. The
Implements statement must include each interface that's specified in
implementslist. However, the name by which an interface defines the
definedname) doesn't need to match the name of this procedure (in
Returning from a Function
Function procedure returns to the calling code, execution continues with the statement that follows the statement that called the procedure.
To return a value from a function, you can either assign the value to the function name or include it in a
Return statement simultaneously assigns the return value and exits the function, as the following example shows.
Function myFunction(ByVal j As Integer) As Double Return 3.87 * j End Function
The following example assigns the return value to the function name
myFunction and then uses the
Exit Function statement to return.
Function myFunction(ByVal j As Integer) As Double myFunction = 3.87 * j Exit Function End Function
Exit Function and
Return statements cause an immediate exit from a
Function procedure. Any number of
Exit Function and
Return statements can appear anywhere in the procedure, and you can mix
Exit Function and
If you use
Exit Function without assigning a value to
name, the procedure returns the default value for the data type that's specified in
returntype isn't specified, the procedure returns
Nothing, which is the default value for
Calling a Function
You call a
Function procedure by using the procedure name, followed by the argument list in parentheses, in an expression. You can omit the parentheses only if you aren't supplying any arguments. However, your code is more readable if you always include the parentheses.
You call a
Function procedure the same way that you call any library function such as
You can also call a function by using the
Call keyword. In that case, the return value is ignored. Use of the
Call keyword isn't recommended in most cases. For more information, see Call Statement.
Visual Basic sometimes rearranges arithmetic expressions to increase internal efficiency. For that reason, you shouldn't use a
Function procedure in an arithmetic expression when the function changes the value of variables in the same expression.
The Async feature allows you to invoke asynchronous functions without using explicit callbacks or manually splitting your code across multiple functions or lambda expressions.
If you mark a function with the Async modifier, you can use the Await operator in the function. When control reaches an
Await expression in the
Async function, control returns to the caller, and progress in the function is suspended until the awaited task completes. When the task is complete, execution can resume in the function.
Async procedure returns to the caller when either it encounters the first awaited object that’s not yet complete, or it gets to the end of the
Async procedure, whichever occurs first.
Async function cannot declare any ByRef parameters.
A Sub Statement can also be marked with the
Async modifier. This is primarily used for event handlers, where a value cannot be returned. An
Async``Sub procedure can't be awaited, and the caller of an
Async``Sub procedure can't catch exceptions that are thrown by the
An iterator function performs a custom iteration over a collection, such as a list or array. An iterator function uses the Yield statement to return each element one at a time. When a Yield statement is reached, the current location in code is remembered. Execution is restarted from that location the next time the iterator function is called.
You call an iterator from client code by using a For Each…Next statement.
For more information, see Iterators.
The following example uses the
Function statement to declare the name, parameters, and code that form the body of a
Function procedure. The
ParamArray modifier enables the function to accept a variable number of arguments.
Public Function calcSum(ByVal ParamArray args() As Double) As Double calcSum = 0 If args.Length <= 0 Then Exit Function For i As Integer = 0 To UBound(args, 1) calcSum += args(i) Next i End Function
The following example invokes the function declared in the preceding example.
Module Module1 Sub Main() ' In the following function call, calcSum's local variables ' are assigned the following values: args(0) = 4, args(1) = 3, ' and so on. The displayed sum is 10. Dim returnedValue As Double = calcSum(4, 3, 2, 1) Console.WriteLine("Sum: " & returnedValue) ' Parameter args accepts zero or more arguments. The sum ' displayed by the following statements is 0. returnedValue = calcSum() Console.WriteLine("Sum: " & returnedValue) End Sub Public Function calcSum(ByVal ParamArray args() As Double) As Double calcSum = 0 If args.Length <= 0 Then Exit Function For i As Integer = 0 To UBound(args, 1) calcSum += args(i) Next i End Function End Module
In the following example,
DelayAsync is an
Async``Function that has a return type of Task<TResult>.
DelayAsync has a
Return statement that returns an integer. Therefore the function declaration of
DelayAsync needs to have a return type of
Task(Of Integer). Because the return type is
Task(Of Integer), the evaluation of the
Await expression in
DoSomethingAsync produces an integer. This is demonstrated in this statement:
Dim result As Integer = Await delayTask.
startButton_Click procedure is an example of an
Async Sub procedure. Because
DoSomethingAsync is an
Async function, the task for the call to
DoSomethingAsync must be awaited, as the following statement demonstrates:
Await DoSomethingAsync(). The
startButton_Click``Sub procedure must be defined with the
Async modifier because it has an
' Imports System.Diagnostics ' Imports System.Threading.Tasks ' This Click event is marked with the Async modifier. Private Async Sub startButton_Click(sender As Object, e As RoutedEventArgs) Handles startButton.Click Await DoSomethingAsync() End Sub Private Async Function DoSomethingAsync() As Task Dim delayTask As Task(Of Integer) = DelayAsync() Dim result As Integer = Await delayTask ' The previous two statements may be combined into ' the following statement. ' Dim result As Integer = Await DelayAsync() Debug.WriteLine("Result: " & result) End Function Private Async Function DelayAsync() As Task(Of Integer) Await Task.Delay(100) Return 5 End Function ' Output: ' Result: 5