ISET Mahdia Programmation évènementielle

Chapitre 4 : Gestion des erreurs et des exceptions

Objectif Général

Ce chapitre présente les types d’erreurs susceptibles de survenir dans un programme ainsi
que les outils de débogage de Microsoft Visual Basic .NET qui va permettre aux étudiants de
diagnostiquer et de corriger ces erreurs. Ce chapitre explique comment utiliser le débogueur de
Microsoft Visual Studio .NET, les fenêtres de débogage et la gestion structurée des exceptions pour
déboguer un programme.

Objectifs Spécifiques

A la fin de ce chapitre les étudiants auront les connaissances nécessaires pour :

 citer des exemples d’erreurs de syntaxe, d’exécution et de logique ;

 déboguer du code à l’aide de la barre d’outils Déboguer, des points d’arrêt, des commandes
Pas à pas, de la syntaxe Exécuter jusqu’au curseur, des fenêtres de débogage et de la
fenêtre Commande ;
 appliquer la gestion structurée des exceptions à du code.

Pré-requis
Programmation orientée objet.

Volume horaire
3 Heures

Table des matières

1. Les différents types d’erreurs ................................................................................................. 3

1.1. Les erreurs de syntaxe ........................................................................................................ 3

Mme. BOUGHAMMOURA Héla 1

ISET Mahdia Programmation évènementielle

1.2. Les erreurs d’exécution ...................................................................................................... 5

1.3. Les erreurs de logique ........................................................................................................ 5
2. Utilisation du débogueur ........................................................................................................ 6
2.1. Utilisation des points d’arrêt .............................................................................................. 6
2.2. Procédure d’analyse pas à pas du code ............................................................................... 7
3. Traitement des erreurs ........................................................................................................... 7
3.1. Les exceptions..................................................................................................................... 7
3.1.1. Try…Catch... Finally............................................................................................... 8
3.2. La gestion en ligne .............................................................................................................. 9

Mme. BOUGHAMMOURA Héla 2

ISET Mahdia Programmation évènementielle

Chapitre 4: Gestion des erreurs et des exceptions

1. Les différents types d’erreurs

La gestion des erreurs est fondamentale en programmation : une bonne gestion d’erreur
permet d’éviter tout plantage brusque de perte de données, renseigner le développeur sur l’origine
du problème et enfin proposer ou choisir des alternatives. On peut classer Les erreurs en trois
catégories :

 Les erreurs de syntaxe

 Les erreurs d’exécution
 Les erreurs de logique

1.1. Les erreurs de syntaxe

Ce type d’erreur se produit au moment de la compilation, lorsqu’un mot clé du langage est
mal orthographié .Si une erreur de syntaxe est détectée, Visual Basic propose les solutions possibles
pour corriger cette erreur. Elles sont affichées en cliquant sur l’icône associée à l’erreur.

Figure 4.1 : Erreur de syntaxe

D’autre part les fautes d’orthographe dans les noms de propriétés ou de méthodes sont
facilement éliminées grâce aux fonctionnalités IntelliSense. IntelliSense prend en charge les
fonctionnalités suivantes :

 L’affichage automatique de la liste des membres disponibles :

Mme. BOUGHAMMOURA Héla 3

ISET Mahdia Programmation évènementielle

Figure 4.2 : Liste des membres

 L’affichage de la liste des paramètres à fournir pour l’appel d’une procédure ou fonct ion :

 L’affichage d’informations ponctuelles sur membres d’une classe :

 Le complément automatique de mots : commencez à saisir un début de mot puis utilisez la

combinaison de touches [Ctrl] [Espace] pour afficher tout ce que vous pouvez utiliser comme
mot, à cet emplacement, commençant par les caractères déjà saisis.
 L’affichage de la liste des valeurs possibles pour une propriété de type énumération.

Mme. BOUGHAMMOURA Héla 4

ISET Mahdia Programmation évènementielle

Figure 4.3 : Liste des valeurs possibles

Remarque : une erreur de syntaxe empêche la compilation du programme et de fait ne peut survenir
lors de l’exécution.

1.2. Les erreurs d’exécution

Ces erreurs apparaissent après la compilation, lorsque vous lancez l’exécution de votre
application. La syntaxe du code est correcte mais l’environnement de votre application ne permet
pas l’exécution d’une instruction utilisée dans votre application. C’est, par exemple, le cas si vous
essayez d’ouvrir un fichier qui n’existe pas sur le disque de votre machine. Vous obtiendrez
sûrement une boîte de dialogue de ce type.

Figure 4.4 : boite de dialogue signalant une erreur

Visual Basic permet la récupération de ce type d’erreur et évite ainsi l’affichage de cette inquiétante
boîte de dialogue. Deux techniques sont disponibles pour la gestion de ce type d’erreurs :

 la gestion en ligne ;
 les exceptions.
1.3. Les erreurs d e logique

Les erreurs de logique se produisent lorsqu’une application ne fonctionne pas comme elle le
devrait. Ces erreurs sont particulièrement difficiles à rechercher puisqu’elles ne génèrent pas de
message d’erreur. Une application peut contenir du code syntaxiquement correct, s’exécuter sans
effectuer d’opérations non valides et, pourtant, produire des résultats incorrects. Le code suivant
contient une erreur de logique amenée à générer une erreur d’exécution.

Di m x As Integer = 2
Do While x < 10
’ Instructions du code
x -= 1

Mme. BOUGHAMMOURA Héla 5

ISET Mahdia Programmation évènementielle

Loop

Dans ce code, la boucle While s’exécute tant que la valeur x reste inférieure à 10. À
l’intérieur de la boucle, l’instruction x - = 1 contient une erreur de logique car la valeur de début de
x est 2 et est décrémentée de 1 à chaque exécution de la boucle. La condition x < 10 reste toujours
définie à True, créant ainsi une boucle infinie. Une erreur d’exécution survient lorsque la valeur x
dépasse la valeur qu’il est possible de stocker dans un Integer.

Le seul moyen de vérifier qu’une application fonctionne correctement est de la tester en d’en
analyser les résultats. Dans le cadre du processus de débogage, vous pouvez utiliser les outils de
débogage de Microsoft Visual Studio .NET pour identifier et résoudre les erreurs de logique
dissimulées dans votre code.

2. Utilisation du débogueur

Les outils de débogage permettent à diagnostiquer des erreurs de programme en examinant

le flux du programme. Elles est utiliser pour interrompre le programme à des moments définis de
l’exécution du code, examiner les modifications apportées aux valeurs des variables et des
propriétés et parcourir des parties du code pas à pas.

2.1. Utilisation des points d’arrêt

Un point d’arrêt est un marqueur intégré à votre code qui permet à Visual Basic
d’interrompre l’exécution du code sur une ligne spécifique. Pour arrêter votre programme à un
emplacement de votre code, là où vous suspectez la présence d’un problème, définissez un point
d’arrêt à ce même emplacement.

Points d’arrêt

Figure 4.5 : Utilisation des points d’arrêt

Mme. BOUGHAMMOURA Héla 6

ISET Mahdia Programmation évènementielle

2.2. Procédure d’analyse pas à pas du code

Une des procédures de débogage les plus courantes est l’analyse pas à pas du code ou
l’exécution du code une ligne à la fois. Le menu Déboguer est doté de trois commandes qui
permettent de parcourir le code pas à pas : Pas à pas détaillé, Pas à pas principal et Pas à pas sortant.
En outre, la commande Exécuter jusqu’au curseur vous permet d’exécuter votre application jusqu’à
ce que le débogueur atteigne le point d’insertion que vous avez défini.

3. Traitement des erreurs

Deux techniques sont disponibles pour le traitement des erreurs dans Visual Basic :
 Les exceptions
 La gestion en ligne

3.1. Les exceptions

Une exception désigne une condition d’erreur ou un comportement inattendu survenant lors
de l’exécution d’un programme et exigeant l’exécution d’un code hors du flux de contrôle normal.
Plusieurs causes peuvent être à l’origine des exceptions : un défaut dans le code ou le code appelé,
des ressources du système d’exploitation indisponibles, des conditions inattendues dans le Common
Language Runtime, etc. Une exception est levée à partir de la zone de code où survient le problème.
.NET Framework fournit le modèle objet d’exception suivant :

Exception

SystemException

OutOfMemoryException

IOException

FileNotFoundException

ApplicationException

Figure 4.6 : Modèle objet d’exception

Mme. BOUGHAMMOURA Héla 7

ISET Mahdia Programmation évènementielle

3.1.1. Try…Catch... Finally

Le bloc Try comprend une expression susceptible de générer une exception(le code
dangereux). Il est constitué d’une ou plusieurs instructions Ca tc h associées permettant de filtrer les
exceptions et de les faire correspondre à une action particulière.
Si l’exception survient, le runtime interrompt la procédure d’exécution normale et part à la
recherche d’un bloc Ca tch capable d’intercepter l’exception en fonction de son type.
Syntaxe :

Try ’ Démarre un gestionnaire structuré des exceptions

{Instructions dangereuses}

Catch Objet 1 As type_exception1

{Instructions à réaliser si exceptions 1}
Catch Objet 2 As type_exception2
{Instructions à réaliser si exceptions 2}
Finally
{Code à excécuter dans tous les cas}

End Try ’ Termine un gestionnaire structuré des exceptions

Le bloc Try d’un gestionnaire d’exceptions Try…Catch contient la section du code que vous
souhaitez gérer à l’aide de votre gestionnaire d’exceptions. Placez les sections du code susceptibles
de lever des exceptions dans un bloc Try, puis le code chargé de la gestion des exceptions dans un
bloc Catch.
Le code d’un bloc Try est toujours exécuté. Si une erreur survient lors de l’exécution d’un
code de la section Try, Visual Basic examine chaque instruction Catch dans le gestionnaire des
exceptions jusqu’à ce que le type de l’exception survenue corresponde au nom de l’exception
spécifiée dans l’instruction Catch, puis il transfère le contrôle de la première ligne du code vers
l’instruction Catch. Si aucun bloc Catch n’est trouvé, une erreur survient.
Le bloc Finally est un bloc de code facultatif qui, s’il est inclus, est toujours exécuté. Dans ce
bloc, vous pouvez définir les actions à entreprendre, indépendamment de l’apparition ou non d’une
exception. Ces actions peuvent inclure notamment la fermeture de fichiers ou la libération d’objets.
Le bloc Finally est le plus souvent employé pour éliminer des ressources utilisées dans votre code
lorsqu’une méthode échoue.
Exemple :

Priva te Sub OuvertureFichier()

Try

Mme. BOUGHAMMOURA Héla 8

ISET Mahdia Programmation évènementielle

My.Computer.FileSystem.OpenTex tFileReader("a: \essai")

Catch exception1 As FileNotFoundException

MessageBox.Show("Fichier de données manquant")

Catch exception2 As system .IO.IOException

MsgBox("erreur d’ouverture du fichier", MsgBoxStyle.OKOnly)

Finally

If Not IsNothing (reader) Then reader.Close( )

If Not IsNothing (file) Then file.Close( )

End Try

End Sub

3.2. La gestion en ligne

L’instruction On Error est l’élément de base de la gestion des erreurs en ligne. Lorsque ce cette

instruction est exécutée, dans une procédure ou fonc tion, elle ac tive la gestion des erreurs pour cette

procédure ou fonction.

 On error resume next : l’exécution du code va se poursuivre par la ligne suivant c elle qui a

provoqué l’erreur.

 On error goto etiquette : l’exécution du code va se poursuivre par la ligne repérée par

étiquette. La syntax e est la suivante :

Private Sub NomProcédure( ByVal argument As Type, … )

On Error Goto GestionErreurs

« Instructions dangereuses »

….

Exit sub

GestionErreurs :

« code de gestion des erreurs »

End Sub

Mme. BOUGHAMMOURA Héla 9

ISET Mahdia Programmation évènementielle

L’étiquette vers laquelle le gestionnaire d’erreurs va rediriger l’exécution doit se trouver dans la
même procédure que l’instruction on error goto. L’instruction exit sub est obligatoire pour que le
code de gestion d’erreur ne soit pas exécuté à la suite des instructions normales mais seulement en
cas d’erreur.
Le code du gestionnaire d’erreur doit déterminer la conduite à tenir en cas d’erreur. Trois solutions
sont possibles.
 Resume : On essaie à nouveau la ligne qui a provoqué l’erreur.
 Resume next : On continue l’exécution par la ligne suivant celle qui a provoqué l’erreur.
 Exit s ub ou exit function : on abandonne l’exécution de cette procédure ou fonction.

Private Sub OuvertureFichier( )

On Error Goto GestionErreurs

My.Computer.FilesSystem.OpenTex tFileReader(‘’ C:\essai ’’)

Exit sub

GestionErreurs :

Di m reponse As String

Reponse = MsgBox(“ i mpossible de lire le fichier “, MsgBox Style.AbortRetryIgnore)

Select case reponse

Case MsgBox Resul t.Retry

Resume

Case MsgBox Resul t.Ignore

Resume nex t

Case MsgBox Resul t.Abort

Exit sub

End Sub

Mme. BOUGHAMMOURA Héla 10