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

Date de mise à jour : 28 décembre 2011.

Par DarkVader (le site de DarkVader)
 

Tout ce que vous devez savoir sur le débogage et la gestion des erreurs sous Visual Basic 6.

Vos commentaires sont les bienvenus 5 commentaires

       Version PDF (Miroir)   Version hors-ligne (Miroir)

                    

I. Introduction

Pour tout complément d'information, consultez la  MSDN

II. Les outils

II-1. Les outils d'aide à l'écriture

L'IDE Visual Basic dispose avec la technologie Intellisense de différents outils d'aide à l'écriture (Listes automatiques , Info-bulles, des Infos-express ). Outre le fait de limiter le risque d'erreurs de syntaxe, ils ont pour propriété de devenir non fonctionnels s'il existe une erreur (défaut de typage, de paramètres, etc.) ce qui permet donc indirectement de signaler une erreur.

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

II-1-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: seul 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ée comme Integer

Vous devrez ajouter manuellement Option Explicit dans tous les modules de votre projet, créés ou importés AVANT d'avoir coché cette case ! (Form, Module, Module de classe, etc.)

II-1-3. Auto-complétion

II-1-4. Info-express automatique

II-1-5. Info-bulle automatique

II-2. Le paramétrage des Options de gestion d'erreurs

• 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'erreurs 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.

II-3. Les outils dédiés au débogage

La fenêtre d'exécution (Ctrl+G) permet les actions suivantes :

• 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.

L'utilisation de la fenêtre d'exécution est utilisable en mode arrêt lors d'une exécution en mode runtime ou directement en mode conception.

La fenêtre des variables locales (VB:Alt+I+L - VBA: Alt+A+V)

Pour modifier la valeur d'une variable dans la fenêtre Variables locales : double-cliquer sur la valeur concernée afin de l'éditer.

La fenêtre Espions

Il est possible d'ajouter un espion en effectuant un Glisser Déposer de la variable préalablement sélectionnée dans la fenêtre Espions.

Pile des Appels (Ctrl+L)

II-4. Les utilitaires dédiés

Les outils fournis par  MZ-Tools.

Le numéroteur de lignes

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

Il est possible de déterminer dans le paramétrage de l'addin, l'incrémentation des numéros de lignes.

La numérotation au niveau projet ou module est possible en utilisant le menu contextuel (clic droit) après sélection du contexte dans l'Explorateur de projet.

Ajouter une procédure d'erreur

Le modèle est à définir dans l'interface des Options MZ-Tools (onglet «Gestionnaire d'erreur»).

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}"

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

III. Gestion des erreurs par le code

III.1. Les instructions de gestion

• 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é.

Utiliser impérativement une variable intermédiaire si une instruction de test doit être effectuée sous le contrôle d'une instruction On Error Resume Next.

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

' et non pas :
If Val(myString) Then

La portée d'une instruction On Error ... est limitée à la procédure courante.

• 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.

La portée de l'objet Err est limitée à la procédure à laquelle est associée un gestionnaire d'erreurs «On Error ...».

III.2. Créer un gestionnaire d'erreurs

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

III.3. Le choix de l'externalisation

• 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.

III.4. Gestionnaire d'erreurs 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.

IV. Spécificités en mode compilé

IV.1. Les options et paramètres de compilation

Néophytes, s'abstenir !!

IV.2. Débogage symbolique

IV.3. Remarques

• Lorsque qu'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).

V. Le débogage

V.1. Mise au point d'un programme

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

L'IDE VB6 permet d'exécuter du code en mode «runtime» tout en permettant d'intervenir sur celui-ci lors de son exécution dès qu'il entre en mode arrêt.

• la modification du code existant ;
• l'ajout de lignes d'instructions ;
• l'ajout ou la modification de déclarations ;
• la modification de valeur de variables ;
• le saut d'instructions, de procédures, etc.

Il est possible dans le même temps, d'exécuter du code en parallèle depuis la fenêtre d'Exécution => l'exécution des instructions, procédures ou fonctions se répercutera sur le code global en mode arrêt

• il faut l'éviter dans les procédures de rappels au risque d'un crash de l'IDE ;
• il n'est pas question d'effectuer des modifications importantes dans ce contexte car la stabilité de l'IDE est en relation avec le cumul des erreurs interceptées, leur gravité et les modifications opérées consécutivement.

V.1-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.1-3. Erreur inattendue

• travailler avec un environnement restreint (fermeture de tous les programmes, désactivation des éventuels compléments, etc.) ;
• si nécessaire, utiliser une session de l'OS en mode sans échec ;
• accessoirement, tester si l'erreur se reproduit sous différents systèmes d'exploitation.

V.2. Exécuter le code

• 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é.

Les deux modes peuvent être utilisés consécutivement au sein d'une même session.

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

• 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).

L'instruction Stop ne doit pas apparaître dans un exécutable compilé.

#If NOCOMPILATION Then
    Stop
#End If

V.3. Cas particuliers des exécutions d'instances

V.3-1. Control ActiveX

• Créer un nouveau projet Exe Standard (Ctrl N) ; celui-ci servira de projet support pour le test.
• Créer un groupe de projet en ajoutant le projet du contrôle à tester (Alt FA) => les contrôles sont disponibles dans la Boite à Outils du projet de test.

• déposer le contrôle à tester sur la feuille du projet de test => la partie « Concepteur » du code s'exécute...
• exécutez le projet de test en mode Runtime (F5) => la partie du code « Utilisateur » s'exécute...

L'ordre d'ouverture des projets dans le groupe détermine le projet qui s'exécutera en mode runtime.

V.3-2. DLL ActiveX

• ajouter un module standard au projet à tester ;
• ajouter une procédure de test dans laquelle est initialisée la classe à tester ;
• exécuter la procédure en l'appelant depuis la fenêtre d'Exécution.

V.3-3. AddIn

Afin de ne pas avoir à gérer l'installation de l'addin à l'ouverture de l'application cliente : => Définir le mode de démarrage de l'addin (Comportement Initial) à « Startup ».

VI. Conclusion

Tous mes remerciements à ceux qui ont bien voulu prendre un peu de leur temps pour me relire et finaliser cet article,
notamment à ThierryAIM, Pierre Fauconnier, omen999 et jacques_jean.