Le débogage sous Visual Basic 6 et Visual Basic pour Application(1re partie)

Menu Outils/Options (Alt OT) > Onglet Éditeur

Cocher toutes les options « Paramètres du code ».

II-A-1. Vérification automatique de la syntaxe▲

II-A-2. Déclaration des variables obligatoire▲

Option Explicit

'- Exemples de ce qu'il faut faire et NE PAS faire :

Dim MyVar    ' INCORRECT: MyVar est de type Variant
Dim MyVar As String    ' CORRECT: Typage fort, MyVar est définie comme type String

Dim MyVar1, MyVar2 As Integer    ' INCORRECT: seule MyVar2 est typée comme Integer, MyVar1 est de type Variant
Dim MyVar1 As Integer, MyVar2 As Integer    ' CORRECT: MyVar1 ET MyVar2 sont correctement typées comme Integer

II-A-3. Autocomplétion▲

L'autocomplétion (liste automatique des membres) fournit au développeur dans une zone de liste les propriétés, méthodes, etc. du modèle objet sélectionné (racine) ce qui permet de réduire le temps de développement et assure un code syntaxiquement correct (caractère d'activation « . »).

II-A-4. Info-express automatique▲

La zone d'Info-express (Ctrl+Maj+I/Ctrl+I) est complémentaire de l'autocomplétion ; elle fournit la syntaxe de fonction, d'instruction, de méthode et des paramètres liés en indiquant le paramètre en cours d'édition.

II-A-5. Info-bulle automatique▲

L'outil Info-bulle fonctionne en mode arrêt ; il permet d'afficher (dans la limite des 72 premiers caractères – nom de variable inclus) la valeur en cours de l'expression se situant sous le curseur.

Le paramétrage des options de l'IDE va conditionner le comportement des gestionnaires d'erreurs notamment l'activation ou la désactivation des gestionnaires.

Trois possibilités sont présentes sur le comportement face à une erreur :

• arrêt sur toutes les erreurs : désactive tous les gestionnaires d'erreurs et marque un arrêt sur toutes les erreurs ;
• arrêt sur les erreurs non gérées : active les gestionnaires d'erreur et marque un arrêt uniquement sur les erreurs non gérées ;
• arrêt dans les modules de classe : se distingue de l'option précédente marquant un point d'arrêt dans le module de classe au lieu du module d'appel de la classe.

• exécuter directement des instructions (pour une utilisation d'instructions multiples, utilisez une seule ligne et le séparateur d'instructions « : » ) :

• visualiser le résultat de partie de code en cours d'exécution en mode runtime (instruction Debug.Print) :

• lancer une procédure particulière quand le code actif s'exécute et se trouve en mode arrêt.

Elle permet de visualiser ou modifier les variables en cours.
La capacité d'affichage d'une variable est fonction de la largeur maximum d'affichage de la fenêtre.

Permet de suivre la valeur de retour de propriétés, de fonctions, etc. ou de déterminer une expression dont la valeur stoppera l'exécution du code en mode runtime.
L'affichage des variables est limité aux 250 premiers caractères.
Les menus en rapport : Ajouter un espion - Modifier un espion

génèrera la fenêtre suivante en cours d'exécution…

et un arrêt sur la ligne suivante.

Cette fenêtre affiche la liste des procédures en cours d'exécution pendant le mode arrêt et éventuellement affiche le code de la procédure sélectionnée.
Cet outil est utile pour analyser les procédures récursives ou pour retrouver un gestionnaire d'erreur parent.

Les outils fournis par MZ-Tools.MZ-Tools

L'addin MZ-ToolsMZ-Tools met à disposition deux outils intéressants pour la gestion d'erreurs.

Cet outil permet d'automatiser l'indexation des lignes de code

• soit au niveau procédure ;
• soit au niveau d'un module ;
• soit au niveau de tout le projet.

Il peut être fastidieux d'ajouter une gestion d'erreur à de nombreuses procédures ; cet outil répond à ce problème en suivant un modèle prédéfini en fonction de différentes variables.

Les champs disponibles pour définir le modèle sont :

Soit, par exemple, le modèle suivant :

On Error GoTo {PROCEDURE_NAME}_Error

{PROCEDURE_BODY}

On Error GoTo 0
Exit {PROCEDURE_TYPE}

{PROCEDURE_NAME}_Error:

MsgBox "Error " & Err.Number & " (" & Err.Description & ") in procedure {PROCEDURE_NAME} of {MODULE_TYPE} {MODULE_NAME}"

qui génèrera le résultat suivant :

N. B. Les lignes ajoutées sont marquées d'un signet dans la marge.

L'outil «Signet» permet de signaler une ligne en ajoutant un tag dans la marge.

On Error … Instruction

L'instruction On Error supporte plusieurs syntaxes :

• On Error Goto Etiquette : permet de rerouter l'exécution vers un bloc de gestion de l'exception levée, placé en général immédiatement après une instruction Exit Sub/Exit Function/Exit Property ;
• On Error Goto 0 : supprime toute gestion d'erreur préalablement installée ;
• On Error Resume Next : permet de générer un gestionnaire d'erreurs «passif» : le contrôle de l'exécution est transmis directement à la ligne suivante sans qu'aucun traitement ne soit effectué.

' exemple :
On Error Resume Next
ret= Val(myString)
If ret<>0 Then
    '.../...
endif

' et non pas :
If Val(myString) Then

Resume Instruction
Provoque une réinitialisation de l'objet Err (équivalent à Err.Clear) et la poursuite de l'exécution après la gestion de l'exception :

• Resume : l'exécution reprend à la ligne où l'interruption a eu lieu ;
• Resume Next : l'exécution reprend à la ligne suivante en ignorant la ligne ayant levé l'exception ;
• Resume Line : l'exécution reprend à une ligne spécifique en fonction d'un numéro de ligne ou d'une étiquette.

Error Instruction
Assure la compatibilité avec les versions précédentes ; préférer Err.Raise.

IsError Expression
Renvoie Vrai si expression est une valeur d'erreur.

CVErr Function
Permet de créer des erreurs définies par l'utilisateur dans des procédures créées par l'utilisateur (voir également la constante vbObjectError).

Err Object

ERL Function
Retourne le n° de ligne (Long) sur laquelle s'est produite la dernière erreur levée (portée procédure).

Debug Object

La création d'un gestionnaire d'erreurs «actif» consiste à élaborer une gestion au cas par cas afin de répondre à toutes les erreurs susceptibles de se produire.
Illustration par l'exemple…

Option Explicit

' Nécessite que l'option de l'Ide «Arrêt sur les erreurs non gérées» soit activée
Private Sub Form_Load()
    Dim strErrnum As String
    Dim intErr    As Integer
    Dim intReturn As Integer

    On Error GoTo Exemple1_Error

10    intErr = 3 / intReturn    ' (div 0)
20    intErr = 10 ^ 31          ' dépassement de capacité

30    strErrnum = 71        ' disque non prêt
40    intErr = Val(strErrnum)
50    Err.Raise Number:=intErr

Exit Sub

Exemple1_Error:
    Select Case Err.Number
        Case 6
            Resume Next ' Erreur non corrigée : Passer à la ligne suivante

        Case 11
            intReturn = 1 ' Correction de l'erreur ...
            MsgBox "=> La valeur 0 va être remplacée par la valeur 1"
            Resume ' Reprendre l'exécution

        Case 68
            If MsgBox(Err.Description, vbRetryCancel) = vbRetry Then Resume ' Exécuter à nouveau ou annuler ?

        Case Else    ' Signaler toute autre erreur et sortie du code de la procédure incriminée
            MsgBox Err.Description ,,  "Form_Load (Line " & Erl & ")"

    End Select
End Sub

Le choix du mode de sortie de l'erreur dépend du contexte :

• la boîte de dialogue (Msgbox) : pour interagir avec l'utilisateur final ou permettre d'entrer en mode pas à pas pendant la mise au point ;
• la fenêtre d'exécution (Debug.Print) : permet de signaler une erreur sans interrompre le déroulement du programme ;
• le fichier journal : il a le mérite de ne pas être éphémère, de transmettre des informations non déformées et de pouvoir être traité automatiquement - à réserver en production ou dans le cadre de mise au point suite à erreur fatale (dans ce cadre, l'écriture doit être optimisée) ;
• le presse-papier : ce peut être une solution intermédiaire entre la fenêtre de Debug et le fichier log pour la phase de mise au point ;
• la console : peut éventuellement présenter un intérêt lorsqu'une quantité importante d'information doit être présentée à l'utilisateur final ;
• l'imprimante : accessoirement, peut être utilisée pour analyser la génération de résultats erronés.

Établir un gestionnaire centralisé consiste à réaliser une ou plusieurs procédures spécifiques de traitement des exceptions qu'il suffira ensuite d'appeler lors de l'interception de l'erreur.

Comme pour le choix du mode de sortie, c'est le contexte qui déterminera le choix entre gestionnaire en ligne et/ou gestionnaire centralisé :

• un gestionnaire centralisé présente l'avantage de ne pas multiplier les actions similaires, en conséquence, sa modification s'en trouve simplifiée puisque répercutée sur l'ensemble de l'application ; c'est même un investissement si le gestionnaire est réutilisable dans des projets différents ;
• un gestionnaire en ligne est, au contraire, destiné aux cas particuliers.

L'un comme l'autre peut éventuellement dépendre d'un fichier de ressources dédié qui sera aisément traductible (ex. vb6xx.dll pour Visual Basic).

> Propriétés du projet (Alt PP) > Onglet Compilation > Options avancées

conditionnent le comportement de l'exécutable compilé face à une exception.
Si elles permettent d'optimiser la vitesse d'exécution en supprimant des contrôles internes, leur utilisation risque également de créer de graves dysfonctionnements pour peu que la gestion d'erreurs ne soit pas des plus strictes.

> Propriétés du projet (Alt PP) > Onglet Compilation

Générer les informations de débogage symbolique :
cette option permet de générer automatiquement à la compilation un fichier pdb utilisable notamment par VC++ afin de déboguer l'exécutable préalablement compilé en mode natif.
Ces informations sont générées chaque fois qu'un fichier OBJ est créé par le compilateur ; elles contiennent les informations de type, de prototype des fonctions destinées au débogueur.

Le déploiement et l'installation d'un exécutable nécessitent de respecter quelques règles incontournables pour éviter certaines erreurs liées à l'installation.

• Lorsqu'un exécutable inclut des dépendances ActiveX, il importe de conserver les fichiers dep associés ainsi que les dépendances avec les sources, car ils décrivent les éventuelles dépendances imbriquées qu'il sera ultérieurement difficile d'identifier sans eux.
• Il est essentiel de réaliser (et de conserver avec les sources) un Setup d'installation, car il n'est pas acquis que la version du système d'exploitation sur lequel l'installation s'effectuera distribue les dépendances du système sur lequel a été compilé l'exécutable (par exemple, Vista/Seven ne distribue pas une partie des DLL/OCX distribuées sous Win2000/XP).
• Rappelez à l'utilisateur qu'il est essentiel avant l'installation de fermer les autres programmes et d'effectuer l'installation en mode administrateur.
• Il est nécessaire de tester l'exécutable sous les différents OS disponibles afin de connaître les éventuelles contraintes d'installation ou incompatibilités (par exemple, installation en mode compatible sous Seven 32 ou 64 bits).

L'Observateur d'évènements de Windows et les journaux liés peuvent être une source d'information complémentaire sur les erreurs.

V-A-1. L'exécution en mode runtime▲

V-A-2. Tester la stabilité▲

Dim x   As Long, ret As Long
Const k As Long = 1000

On Error Goto cath_Err

For x=1 To k
    ret = myFunction()
Next

cath_Err:
    Debug.Print ret
    If x<=k Then Debug.Print "Error at " & k & " cycles"

V-A-3. Erreur inattendue▲

Il existe deux modes d'exécution :

• le mode Pas à pas (F8) qui permet d'exécuter le programme ligne à ligne,
• le mode normal (F5) qui exécute le programme d'une traite jusqu'à ce qu'une erreur ou un point d'arrêt soit éventuellement rencontré.

Une fois en mode arrêt, il est possible d'exécuter le code par tranche en utilisant :

• mode « Pas à pas principal » (Maj+F8) ;
• mode « Pas à pas sortant » (Ctrl+Maj+F8) ;
• « Exécuter jusqu'au curseur » (Ctrl+F8).

Arrêter l'exécution sur une ligne particulière :

• le point d'arrêt (clic dans la marge de la ligne concernée) : il permet de stopper l'exécution juste avant l'exécution d'une ligne précise,
• l'instruction Stop est identique au point d'arrêt,
• en fonction d'un test dans le code (cf. l'instruction Debug.Assert),
• arrêts conditionnels en fonction d'un Espion (cf. Outils).

=> Durant la phase de mise au point, il peut être intéressant d'utiliser les arguments de compilation conditionnelle
(VB: Alt PP > onglet Créer - VBA: Utiliser des constantes conditionnelles « #Const … »)
afin de gérer automatiquement la non-compilation des instructions d'aide au débogage (Stop, Msgbox, Debug.Print, etc.).

exemple VB : « Arguments de compilation conditionnelle » > NOCOMPILATION=1
exemple VBA : #Const NOCOMPILATION=1

#If NOCOMPILATION Then
    Stop
#End If

Uniquement Visual Basic

Si l'exécution en mode runtime d'un exécutable standard (Exe) ne pose pas de problèmes particuliers, il est moins évident d'exécuter le code des DLL ActiveX, controls et Addins
qui ne peut être exécuté directement dans l'IDE puisqu'une instance doit être créée.
Leur débogage nécessite donc quelques artifices …

Utilisez le paramétrage : (Outils/Options> Onglet Général) : « Arrêt sur les erreurs non gérées » ou « Arrêt dans les modules de classe ».

V-C-1. Control ActiveX▲

V-C-2. DLL ActiveX▲

V-C-3. AddIn▲