Le débogage sous Visual Basic 6

Date de publication : 29 octobre 2011.

Par DarkVader (http://www.developpez.com/)
 

       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

II-1-3. Auto-completion

II-1-4. Info-express automatique (Ctrl Maj I/Ctrl I)

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'erreur 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

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 (Alt IL)

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

NB: 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.

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 eut 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'object Err est limitée à la procédure à laquelle est associée un gestionnaire d'erreur «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 pouvoir être traité automatiquement - a 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 lorsque qu'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, il présente l'avantage que sa modification soit 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é au cas particuliers.

IV. Spécificités en mode compilé

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

Néophytes, s'abstenir !!

IV.2. Debogage 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ée 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,)
• voir si nécessaire utiliser une session de l'OS en mode sans échec,
• ou 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 2 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 Standart (Ctrl N) ; celui-ci servira de projet support pour le test
• Créer un groupe de projet en ajoutant le projet du control à tester (Alt FA) => les contrôles sont disponibles dans la Boite à Outils du projet de test.

• déposer le control à 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 standart 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