Différences

Ci-dessous, les différences entre deux révisions de la page.

--- bloc1:csharpa1 [2021/09/30 11:25] – [Ajout de cartouche] techer.charles_educ-valadon-limoges.fr
+++ bloc1:csharpa1 [2021/09/30 11:41] (Version actuelle) – [Outil de débogage :] techer.charles_educ-valadon-limoges.fr
@@ Ligne 327: / Ligne 327: @@
 </WRAP>
 {{ :bloc1:csharp_10.jpg |}}
+===== Etape 9 =====
+==== Tests de l'application ====
+Lorsqu'un programme est termné, il est important de le tester. En réalité, les tests doivent se faire après chaque fonctionalité, ce que vous avez fait. Mais les tests finaux sont importants.
+Le but est de voir si le programme fonctionne quelle que soit la situation. Il est généralement impossible de tester  tous les cas possibles : ici, on ne peut pas essayer tous les nombres ! Le but est plutôt de tester les possibilités classiques, les cas particuliers et les comportements inattendus.
+Dans l'exemple actuel, il faut donc tester les cas suivants :
+  * trouver la valeur en plusieurs essais (cas classique) ;
+  * trouver la valeur au premier essai (cas particulier car le premier essai a été traité différemment, avant la boucle) ;
+  * saisir un caractère au lieu d'un nombre (comportement inattendu).
+<WRAP center round todo>
+**test**
+Essayez les 2 premiers cas qui ne doivent pas poser de problème. Essayez ensuite le dernier cas en tapant une lettre au lieu d'un nombre (dans la valeur, mais le problème sera identique dans l'essai).
+</WRAP>
+Le programme s'arrête violemment et une erreur apparait directement dans le code (voir capture ci-contre). La ligne concernée est mise en évidence :
+<code c#>
+valeur = int.Parse(Console.ReadLine());
+</code>
+et le message d'erreur dit : **System.GormatException : 'Le format de la chaîne d'entrée est incorrect.'**.
+La ligne de code permet de réaliser une saisie, puis de la transformer (**transtyper**) en type **int** (entier) pour pouvoir l'affecter à la variable **valeur** qui est de type **int**.
+Le problème vient du fait qu'une lettre est saisie et que le programme tente de la convertir en **int**, ce qui n'est pas possible.
+Pour éviter l'arrêt brutal du programme, il faut soit éviter la conversion (ce qui n'est pas **naturel** ici, car on veut chercher un nombre), soit **capturer l'erreur**.
+{{ :bloc1:csharp_11.jpg |}}
+==== Tests de l'application (capture d'erreur) ====
+Voilà comment fonctionne la capture d'erreur :
+<code c#>
+try
+{
+     // contenant le code qui peut poser problème
+}
+catch
+{
+     // contenant le code à exécuter, en cas d'erreur
+}
+</code>
+Commençons par la première saisie (valeur). L'idée est de boucler tant que l'utilisateur n'a pas saisi une valeur correcte (un nombre entier). Dans la boucle, pour éviter une erreur, le code de saisie et de transtypage va être mis dans le 'try'. Si le 'catch' s'exécute, c'est qu'il y a une erreur et un message sera affiché. Cela suppose de savoir quelle condition mettre au niveau de la boucle : on veut boucler tant que la saisie n'est pas correcte. Pour cela utilisons une variable 'correct' de type booléen (qui ne peut prendre que les valeurs true ou false). Voici le code à compléter (juste en dessous des déclarations actuelles, et en récupérant les 2 lignes de code qui concernant la saisie de 'valeur') :
+<code c#>
+bool correct = false;
+// saisie du nombre à chercher
+while (!correct)
+{
+    try
+    {
+        Console.Write("Entrez le nombre à chercher = ");
+        valeur = int.Parse(Console.ReadLine());
+        correct = true;
+    }
+    catch
+    {
+        Console.WriteLine("Erreur de saisie : saisissez une nombre entier");
+    }
+}
+Console.Clear();
+</code>
+Le signe "!" devant 'correct' signifie "non" : donc on boucle tant que "non correct", ce qui est équivalent à "correct == false". Dans le 'try', dès que l'ordinateur tombe sur une erreur, il va directement au 'catch', donc la ligne de code "correct = true" ne s'exécutera que s'il n'y a pas d'erreur à la ligne précédente.
+Remarquez une nouvelle erreur : sur la ligne de code "while (essai != valeur)", la variable 'valeur' est soulignée en rouge, avec le message d'erreur "Utilisation d'une variable locale non assignée 'valeur'". Cela vient du fait que 'valeur' peut très bien ne rien recevoir, car son affectation est dans un 'try'. L'ordinateur n'est pas assez 'intelligent' pour comprendre que le programme va justement boucler tant qu'une valeur correcte n'a pas été saisie. Donc, pour éviter cette erreur, il suffit d'initialiser 'valeur' : autant le faire au niveau des déclaration : affectez-lui la valeur 0 (comme vous aviez affecté 1 à 'nbre').
+<WRAP center round todo>
+**test**
+Vérifiez qu'en saisissant une lettre, le message d'erreur s'affiche et la saisie est redemandée. Vous pouvez faire l'erreur plusieurs fois. Saisissez enfin un entier : le jeu continue normalement.
+</WRAP>
+Faites les mêmes modifications pour la saisie de l'essai (attention, il y a une saisie avant la boucle, et une dans la boucle) : vous pouvez bien sûr utiliser la même variable 'correct', mais sans oublier de lui réaffecter la valeur 'false' à chaque fois avant la boucle sur la saisie.
+<WRAP center round important>
+**test**
+Vérifiez que tout le programme fonctionne correctement. Essayez de saisir une lettre lors du premier essai, et aussi lors des essais suivants. Vérifiez aussi que le nombre d'essais, au final, est correct (l'ordinateur n'a pas compté les erreurs de saisie).
+</WRAP>
+Vous avez remarqué que du code se répète : vous apprendrez plus tard comment optimiser le code pour éviter ce genre de répétition.
+{{ :bloc1:csharp_12.jpg |}}
+===== Etape 10 =====
+==== Outil de débogage : ====
+Tous les IDE possèdent un outil de débogage qui permet une exécution pas à pas du programme avec vérification de l'évolution des variables.
+Même si le programme est opérationnel, voyons comment fonctionne cet outil.
+=== Point d'arrêt : ===
+Il est possible de placer un ou plusieurs points d'arrêt dans un programme. Lors du débogage, le programme va s'exécuter normalement jusqu'au point d'arrêt, puis il se met en attente. Pour placer un point d'arrêt, cliquez dans la marge de gauche au niveau de la ligne de code concernée. Un point rouge va apparaître. Pour l'enlever, il suffit de cliquer dessus à nouveau. Placez un point d'arrêt au niveau de la grande boucle de comparaison entre 'essai' et 'valeur' :
+{{ :bloc1:csharp_13.jpg |}}
+La ligne du point d'arrêt apparaît en rouge.
+=== Démarrage du débogueur : ===
+Il est alors possible de lancer le débogueur : menu "Déboguer > Démarrer le débogage". La fenêtre d'exécution s'ouvre normalement. Saisissez une valeur et validez. L'écran s'efface. Saisissez un premier essai (différent de valeur) et validez. Cette fois le programme se met en attente et, dans le code, remarquez que la ligne du point d'arrêt est maintenant en jaune :
+{{ :bloc1:csharp_14.jpg |}}
+A partir de là, vous allez pouvoir consulter l'état des variables et continuer à exécuter le programme ligne par ligne, à votre rythme.
+=== Etat des variables : ===
+Maintenant que le programme s'est arrêté, observez la fenêtre du bas qui donne l'état actuel des variables :
+{{ :bloc1:csharp_15.jpg |}}
+Ne tenez pas compte de 'args'. Vous retrouvez les 4 variables du programme : valeur, essai, nbre, correct. La seconde colonne contient les valeurs actuelles (ici, j'ai tapé 57 pour 'valeur' et 100 pour le premier essai). La troisième colonne donne les types des variables.
+=== Exécution pas à pas : ===
+Vous allez maintenant avancer dans l'exécution, ligne par ligne. Dans le menu Debogueur, remarquez qu'il y a plusieurs possibilités de faire du "pas à pas". On va pour le moment utiliser le "pas à pas principal", que vous pouvez obtenir aussi avec F10. Appuyez sur F10 (ou passez par le menu). La ligne jaune d'exécution a avancé d'une instruction. Elle est maintenant sur l'accolade, et la ligne du point d'arrêt est redevenue rouge. Continuez à avancer avec F10 : le test va être évalué entre essai et valeur et, suivant le résultat, la ligne jaune va se possitionner dans la première partie ou la seconde (le else). Avancez encore une fois : le message "trop petit" ou "trop grand" s'affiche dans la fenêtre d'exécution. Avancez encore : lorsque vous aurez passé l'instruction "correct = false", vous remarquerez le changement de valeur de 'correct' dans la fenêtre des variables :
+{{ :bloc1:csharp_16.jpg |}}
+Cela permet de repérer les changements qui viennent de se faire.
+Continuez d'avancer jusqu'à passer la ligne de saisie de l'essai : cette fois il n'y a plus de ligne jaune et la fenêtre d'exécution est repassée au premier plan, en attente d'une saisie. Saisissez une valeur et validez : vous retournez à nouveau dans le code avec la ligne jaune. Remarquez aussi, dans la fenêtre des variables, que la valeur de 'essai' est en rouge, et aussi 2 informations complémentaires : la valeur saisie (Console.ReadLine) où l'on remarque bien que c'est une chaîne (entre guillemets) et le résultat du changement de type (int.Parse) qui retourne un nombre :
+{{ :bloc1:csharp_17.jpg |}}
+=== Exécution rapide ou arrêt : ===
+A tout moment, il est possible d'arrêter le débogage (en cliquant sur le carrêt rouge, ou menu "déboguer > arrêter le débogage"). Il est aussi possible de reprendre une exécution normale (F5 ou menu "Déboguer > Continuer")  : le débogueur va alors avancer jusqu'à la fin du programme ou jusqu'au point d'arrêt suivant, s'il y en a un. Essayez.