Partager via

Function, instruction (Visual Basic)

Déclare le nom, les paramètres et le code qui définissent une procédure Function.

Syntaxe

[ <attributelist> ] [ accessmodifier ] [ proceduremodifiers ] [ Shared ] [ Shadows ] [ Async | Iterator ]
Function name [ (Of typeparamlist) ] [ (parameterlist) ] [ As returntype ] [ Implements implementslist | Handles eventlist ]
    [ statements ]
    [ Exit Function ]
    [ statements ]
End Function

Éléments

  • attributelist

    Optionnel. Consultez la Liste des attributs.

  • accessmodifier

    Optionnel. Il peut s'agir d'une des méthodes suivantes :

    Consultez Access levels in Visual Basic.

  • proceduremodifiers

    Optionnel. Il peut s'agir d'une des méthodes suivantes :

  • Shared

    Optionnel. Consultez Partagé.

  • Shadows

    Optionnel. Consultez Shadows.

  • Async

    Optionnel. Voir Async.

  • Iterator

    Optionnel. Consultez Iterator.

  • name

    Obligatoire. Nom de la procédure. Consultez Declared Element Names.

  • typeparamlist

    Optionnel. Liste des paramètres de type pour une procédure générique. Consultez Liste de types.

  • parameterlist

    Optionnel. Liste des noms de variables locales représentant les paramètres de cette procédure. Consultez la Liste des paramètres.

  • returntype

    Obligatoire si Option Strict est On. Le type de données de la valeur renvoyée par cette procédure.

  • Implements

    Optionnel. Indique que cette procédure implémente une ou plusieurs procédures Function, chacune définie dans une interface implémentée par la classe ou la structure contenant cette procédure. Consultez Instruction Implements.

  • implementslist

    Obligatoire si Implements est utilisé. Liste des procédures Function en cours d'implémentation.

    implementedprocedure [ , implementedprocedure ... ]

    Chaque implementedprocedure emploie la syntaxe et les éléments suivants :

    interface.definedname

    Élément Description
    interface Obligatoire. Nom d’une interface implémentée par la classe ou la structure contenant cette procédure.
    definedname Obligatoire. Nom par lequel la procédure est définie dans interface.

  • Handles

    Optionnel. Indique que cette procédure peut gérer un ou plusieurs événements spécifiques. Voir Handles.

  • eventlist

    Obligatoire si Handles est utilisé. Liste des événements gérés par cette procédure.

    eventspecifier [ , eventspecifier ... ]

    Chaque eventspecifier emploie la syntaxe et les éléments suivants :

    eventvariable.event

    Élément Description
    eventvariable Obligatoire. Variable objet déclarée avec le type de données de la classe ou de la structure qui déclenche l’événement.
    event Obligatoire. Nom de l’événement géré par cette procédure.

  • statements

    Optionnel. Bloc d’instructions à exécuter dans cette procédure.

  • End Function

    Met fin à la définition de cette procédure.

Notes

Tout le code exécutable doit se trouver à l’intérieur d’une procédure. Chaque procédure, à son tour, est déclarée au sein d’une classe, d’une structure ou d’un module appelé classe, structure ou module conteneur.

Pour retourner une valeur au code appelant, utilisez une procédure Function ; sinon, utilisez une procédure Sub.

Définir une fonction

Vous ne pouvez définir une procédure Function qu'au niveau du module. Par conséquent, le contexte de déclaration d’une fonction doit être une classe, une structure, un module ou une interface et ne peut pas être un fichier source, un espace de noms, une procédure ou un bloc. Pour plus d’informations, consultez Contextes de déclaration et niveaux d’accès par défaut.

Procédures Function par défaut pour l’accès public. Vous pouvez ajuster leurs niveaux d’accès avec les modificateurs d’accès.

Une procédure Function peut déclarer le type de données de la valeur retournée par la procédure. Vous pouvez spécifier le type de données de votre choix ou le nom d’une énumération, d’une structure, d’une classe ou d’une interface. Si vous ne spécifiez pas le paramètre returntype, la procédure renvoie Object.

Si cette procédure utilise le mot clé Implements, la classe ou la structure qui la contient doit également comporter une instruction Implements qui suit immédiatement son instruction Class ou Structure. L’instruction Implements doit inclure chaque interface spécifiée dans implementslist. Toutefois, le nom par lequel une interface définit le Function (en definedname) n’a pas besoin de correspondre au nom de cette procédure (en name).

Notes

Vous pouvez utiliser des expressions lambda pour définir des expressions de fonction Inline. Pour plus d’informations, consultez Expression de fonction et Expressions lambda.

Retourner à partir d’une fonction

Lorsque la procédure Function retourne au code appelant, l’exécution continue avec l’instruction qui suit l’instruction qui a appelé la procédure.

Pour renvoyer une valeur d’une fonction, vous pouvez attribuer la valeur au nom de la fonction ou l’inclure dans une instruction Return.

L’instruction Return attribue simultanément la valeur de retour et quitte la fonction, comme l’illustre l’exemple suivant.

Function MyFunction(ByVal j As Integer) As Double
    Return 3.87 * j
End Function

L’exemple suivant attribue la valeur de retour au nom de la fonction myFunction, puis utilise l’instruction Exit Function pour renvoyer.

Function MyFunction(ByVal j As Integer) As Double
    MyFunction = 3.87 * j
    Exit Function
End Function

Les instructions Exit Function et Return provoquent une sortie immédiate d’une procédure Function. Tout nombre d’instructions Exit Function et Return peut apparaître où que ce soit dans la procédure, et vous pouvez associer des instructions Exit Function et Return.

Si vous utilisez Exit Function sans attribuer de valeur à name, la procédure retourne la valeur par défaut pour le type de données spécifié dans returntype. Si returntype n’est pas spécifié, la procédure renvoie Nothing, qui est la valeur par défaut pour Object.

Appel d’une fonction

Vous appelez une procédure Function à l’aide du nom de la procédure, suivie de la liste d’arguments entre parenthèses, dans une expression. Vous ne pouvez omettre les parenthèses que si vous ne fournissez aucun argument. Toutefois, votre code est plus lisible si vous incluez toujours les parenthèses.

Vous appelez une procédure Function de la même façon que vous appelez n’importe quelle fonction de bibliothèque telle que Sqrt, Cosou ChrW.

Vous pouvez également appeler une fonction à l’aide du mot clé Call. Dans ce cas, la valeur de retour est ignorée. L’utilisation du mot clé Call n’est pas recommandée dans la plupart des cas. Pour plus d’informations, consultez Instruction Call.

Visual Basic réorganise parfois les expressions arithmétiques pour augmenter l’efficacité interne. Pour cette raison, vous ne devez pas utiliser de procédure Function dans une expression arithmétique lorsque la fonction modifie la valeur des variables dans la même expression.

Fonctions asynchrones

La fonctionnalité Async vous permet d'appeler des fonctions asynchrones sans utiliser de rappels explicites ni fractionner manuellement votre code entre plusieurs fonctions ou expressions lambda.

Si vous marquez une fonction avec le modificateur Async, vous pouvez utiliser l’opérateur Await dans la fonction. Quand le contrôle atteint une expression Await dans la fonction Async, il retourne à l’appelant, et la progression dans la fonction est interrompue jusqu’à ce que la tâche attendue soit terminée. Quand la tâche est terminée, l'exécution peut reprendre dans la fonction.

Notes

Une procédure Async retourne à l'appelant quand elle rencontre le premier objet attendu qui n'est pas encore terminé, ou quand elle atteint la fin de la procédure Async, selon la première éventualité.

Une fonction Async peut avoir un type de retour Task<TResult> ou Task. Un exemple de fonction Async ayant un type de retour Task<TResult> est fourni ci-dessous.

Une fonction Async ne peut pas déclarer de paramètres ByRef.

Une instruction Sub peut également être marquée avec le modificateur Async. Ceci est principalement utilisé pour les gestionnaires d’événements, où une valeur ne peut pas être retournée. Une procédure AsyncSub ne peut pas être attendue, et l’appelant d’une procédure AsyncSub ne peut pas intercepter les exceptions levées par la procédure Sub.

Pour plus d’informations sur les fonctions Async, consultez Programmation asynchrone avec Async et Await, Flux de contrôle dans les programmes Async et Types de retour Async.

Fonctions d’itérateur

Une fonction d’itérateur exécute une itération personnalisée sur une collection, comme une liste ou un tableau. Une fonction d’itérateur utilise l’instruction Yield pour retourner chaque élément un par un. Quand une instruction Yield est atteinte, l’emplacement actif dans le code est mémorisé. L’exécution est redémarrée à partir de cet emplacement lors de l’appel suivant de la fonction d’itérateur.

Vous appelez un itérateur depuis le code client en utilisant une instruction For Each...Next.

Le type de retour d’une fonction d’itérateur peut être IEnumerable, IEnumerable<T>, IEnumerator ou IEnumerator<T>.

Pour plus d'informations, consultez Itérateurs.

Exemple 1

L’exemple suivant utilise l’instruction Function pour déclarer le nom, les paramètres et le code qui forment le corps d’une procédure Function. Le modificateur ParamArray permet à la fonction d’accepter un nombre variable d’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

Exemple 2

L’exemple suivant appelle la fonction déclarée dans l’exemple précédent.

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

Exemple 3

Dans l’exemple suivant, DelayAsync est une AsyncFunction dont le type de retour est Task<TResult>. DelayAsync a une instruction Return qui retourne un entier. Ainsi, la déclaration de méthode de DelayAsync doit avoir un type de retour de Task(Of Integer). Étant donné que le type de retour est Task(Of Integer), l’évaluation de l’expression Await dans DoSomethingAsync produit un entier. Ceci est illustré dans cette instruction : Dim result As Integer = Await delayTask.

La procédure startButton_Click est un exemple de procédure Async Sub. Étant donné que DoSomethingAsync est une fonction Async, la tâche de l’appel à DoSomethingAsync doit être attendue, comme le démontre l’instruction suivante : Await DoSomethingAsync(). La procédure startButton_ClickSub doit être définie avec le modificateur Async, car elle a une expression Await.

' 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

Voir aussi

  • Last updated on