Réponse.

Historique de la question :

Les procédures imbriquées (local functions) en Visual Basic sont apparues uniquement dans les versions VB.NET à partir de VB 15.0 (Visual Studio 2017), ce qui les distingue du classique VB6, où cette possibilité n'existait pas. Cette caractéristique permet de déclarer des procédures à l'intérieur d'autres procédures, élargissant l'expressivité du langage et simplifiant l'organisation de la logique auxiliaire dans une seule portée.

Problème

Il arrive souvent qu'une certaine logique auxiliaire soit nécessaire uniquement à l'intérieur d'une méthode spécifique et ne soit pas nécessaire ailleurs. Auparavant, il fallait créer des méthodes privées de classe, ce qui augmentait l'encombrement de l'espace de noms et compliquait la navigation dans le code. Mais avec les local functions, on peut également faire face à des problèmes de portée, d'erreurs d'accès aux variables et de difficultés de débogage.

Solution

Les procédures imbriquées permettent d'encapsuler la logique auxiliaire dans la procédure « parente », rendant le code plus lisible et limitant la portée des méthodes auxiliaires. En VB.NET, la déclaration de fonctions imbriquées apparaît comme suit :

Sub MainProc()
    Dim x As Integer = 5
    Dim y As Integer = 10
    Console.WriteLine($"Somme — {Add(x, y)}")
    
    Function Add(a As Integer, b As Integer) As Integer
        Return a + b
    End Function
End Sub

Caractéristiques clés :

Les procédures imbriquées ne sont visibles que dans la procédure « parente » et ne doivent pas être utilisées en dehors de celle-ci.
Elles peuvent avoir des paramètres et renvoyer des valeurs (Function), et prennent également en charge des procédures imbriquées Sub.
Elles peuvent capturer des variables de la procédure externe, mais ne prennent pas en charge tous les types de modificateurs d'accès.

Questions piégeuses.

Les procédures imbriquées peuvent-elles avoir des modificateurs d'accès Public, Friend ou Protected ?

Non, pour les procédures imbriquées, seul le niveau d'accessibilité à l'intérieur de leur procédure « parente » est autorisé. Elles ne peuvent pas être déclarées comme Public/Friend/Protected et sont accessibles uniquement localement.

Peut-on déclarer une procédure imbriquée à l'intérieur d'une construction For ou If ?

Non, les fonctions locales ne peuvent être déclarées qu'à un premier niveau à l'intérieur de la méthode (procédure), mais pas à l'intérieur de blocs imbriqués (par exemple, For, If, While).

Les procédures imbriquées peuvent-elles être asynchrones (Async Sub/Function) ?

Oui, il est possible de déclarer des local functions asynchrones, ce qui permet d'encapsuler la logique d'exécution asynchrone à l'intérieur de la méthode :

Async Sub DoOperationsAsync()
    Await LocalAsync()
    
    Async Function LocalAsync() As Task
        Await Task.Delay(1000)
        Console.WriteLine("Opération asynchrone terminée.")
    End Function
End Sub

Erreurs typiques et anti-modèles

Déclarer des procédures imbriquées à l'intérieur d'if/for ou d'autres blocs imbriqués.
Utiliser des procédures imbriquées pour une logique qui pourrait être utile dans d'autres parties de la classe (il est préférable de créer une méthode privée).
Incohérence de la portée des variables capturées (menant à des erreurs).

Exemple de la vie réelle

Cas négatif

Dans le projet, des méthodes privées ont été excessivement utilisées au lieu de local functions, ce qui a encombré l'interface de la classe avec des dizaines de procédures auxiliaires. La navigation est devenue très difficile.

Avantages :

Les méthodes étaient réutilisables à l'avenir.

Inconvénients :

Il est devenu plus difficile de maintenir la classe, de nombreuses méthodes auxiliaires compliquent la lecture de la logique métier principale.
Certaines méthodes étaient appelées accidentellement en dehors de la procédure principale, ce qui entraînait des erreurs.

Cas positif

Pour la logique interne, une approche avec des fonctions locales a été utilisée : tout le traitement auxiliaire est placé à l'intérieur de la méthode principale, le code est auto-documenté et facile à maintenir.