Home

Gestion des Exceptions

 

Introduction aux exceptions

 

Une vue d'ensemble

Imaginez que vous souhaitez écrire un programme qui demande un certain nombre à l'utilisateur, multipliez le nombre par 2 et affichez le résultat. La forme de ce programme peut être conçue comme suit :

Introduction to Exceptions

private void button1_Click(object sender, EventArgs e)
{
        double Number;
        
        Number = double.Parse(textBox1.Text);
    
        textBox2.Text = (Number * 2).ToString();
}

Cela ressemble à une simple demande. Lorsqu'elle s'affiche, l'utilisateur est invité à taper simplement un nombre. Le nombre pourrait alors être multiplié par 2 et afficher le résultat. Imaginez qu'un utilisateur saisit quelque chose qui n'est pas un nombre valide, telle que le nom d'un pays ou le numéro de téléphone de quelqu'un.

Étant donné que ce programme s'attendait à un nombre et il n'est pas préparé à multiplier une chaîne à un certain nombre, il produirait une erreur. Chaque fois que le compilateur est remis à une tâche, il essaierait d'effectuer la tâche. S'il ne peut pas effectuer la tâche, pour une raison quelconque à laquelle il n'est pas préparé, il déclencherait une erreur. En tant que programmeur, si vous pouvez anticiper le type d'erreur qui pourrait se produire dans votre programme, vous pouvez intercepter l'erreur vous-même, traiter et dire au compilateur quoi faire lorsque ce type d'erreur se produit.

ApplicationApplication : Présentation de gestion des exceptions

  1. Démarrez Microsoft Visual Studio
  2. Pour créer une nouvelle application, dans le menu principal, cliquez sur fichier - > nouveau projet...
  3. Sélectionnez l'application Windows Forms
  4. Définissez le nom de ClarksvilleIceCream1
  5. Cliquez sur OK
  6. Pour créer un nouveau formulaire, dans le menu principal, cliquez sur projet - > ajouter un formulaire Windows...
  7. Dans la boîte de dialogue Ajouter un nouvel élément, définissez le nom du formulaire de calcul, puis cliquez sur Ajouter
  8. Concevez le nouveau formulaire comme suit :
     

Clarksville Ice Scream - Difference Calculation

Control

Name

Text

Additional Properties

Label

Label

 

Order Total

 

TextBox

ListBox

txtOrderTotal

0.00

TextAlign : Right
Modifier : Public

Label

Label

 

Amount Tended :

 

TextBox

ListBox

txtAmountTended

0.00

TextAlign : Rigth

Button

Button

btnCalculate

Calculate

 

Label

Label

 

Difference :

 

TextBox

ListBox

txtDifference

0.00

TextAlign : Right

Button

Button

btnClose

Close

 

  1. Double-cliquez sur le bouton Calculer
  2. Mettez en œuvre l'événement Click comme suit :
    private void btnCalculate_Click(object sender, EventArgs e)  
    {      
        double TotalOrder,             
               AmountTended = 0.00,             
               Difference;        
     
     
        // Get the value of the total order. Actually, this value       
       // will be provided by the main form      
      TotalOrder = double.Parse(this.txtOrderTotal.Text);  	      
     
     
      // The amount tended will be entered by the user  	
         AmountTended = double.Parse(this.txtAmountTended.Text);        
     
     
     // Calculate the difference of both values, assuming       
     // that the amount tended is higher      
     Difference = AmountTended - TotalOrder;        
     
     
     // Display the result in the Difference text box      
     this.txtDifference.Text = Difference.ToString();  
    }
  3. Revenez au formulaire de calcul
  4. Cliquez deux fois sur le bouton Fermer
  5. Mettez en œuvre l'événement comme suit :
    private void btnClose_Click(object sender, EventArgs e)  
    {      
        Close();  
    }
  6. Dans l'Explorateur de solutions, cliquez droit sur Form1.cs et cliquez sur Renommer
  7. Tapez ClarksvilleIceCream.cs et appuyez sur entrée
  8. Cliquez droit sur le formulaire, puis cliquez sur Propriétés
  9. Dans la fenêtre Propriétés, modifiez Text à Clarksville Ice Cream
  10. Concevez le formulaire comme suit :

    Clarksville Ice Cream: Form Design

    Control

    Name

    Text

    Additional Properties

    GroupBox

    GroupBox

    grpIceCream

     

     

    Label

    Label

     

    Order Date :

     

    TextBox

    ListBox

    txtOrderDate

     

     

    Label

    Label

     

    Order Time :

     

    TextBox

    ListBox

    txtOrderTime

     

     

    Label

    Label

     

    Flavor :

     

    TextBox

    ListBox

    txtFlavor

     

     

    Label

    Label

     

    Container :

     

    TextBox

    ListBox

    txtContainer

     

     

    Label

    Label

     

    Ingredients :

     

    TextBox

    ListBox

    txtIngredient

     

     

    Label

    Label

     

    Scoops :

     

    TextBox

    ListBox

    txtScoops

    1

    TextAlign : Right

    Label

    Label

     

    Order Total :

     

    TextBox

    ListBox

    txtOrderTotal

    0.00

    TextAlign : Right

    Button

    Button

    btnCalculate

    Calculate

     

    Button

    Button

    btnNewOrder

    New Order

     

    Button

    Button

    btnMoneyChange

    Money Change

     

    Button

    Button

    btnClose

    Close

     

     
  11. Cliquez deux fois sur le bouton Calculer le total pour accéder à son événement Click
  12. Mettez en œuvre comme suit :
    private void btnCalculate_Click(object sender, EventArgs e)  
    {      
        double priceContainer = 0.00,             
               priceIngredient = 0.00,             
               priceScoops = 0.00,             
               orderTotal = 0.00;      
        int numberOfScoops = 1;        
     
     
        // Find out what container the customer requested      
        // The price of a container depends on which one the customer selected      
        if (txtContainer.Text == "Cone")          
            priceContainer = 0.55;      
        else if (txtContainer.Text == "Cup")          
            priceContainer = 0.75;      
        else          priceContainer = 1.15;        
     
        
        // If the customer selected an ingredient, which is not "None", add $.95      
        if (txtIngredient.Text != "None")          
            priceIngredient = 0.95;
            
     
        // Get the number of scoops      
        numberOfScoops = int.Parse(this.txtScoops.Text);        
     
        if (numberOfScoops == 2)          
            priceScoops = 2.55;      
        else if (numberOfScoops == 3)          
            priceScoops = 3.25;      
        else          
            priceScoops = 1.85; 
           
     
        // Make sure the user selected a flavor,       
        // otherwise, there is no reason to process an order      
        if (txtFlavor.Text != "")          
            orderTotal = priceScoops + priceContainer + priceIngredient;        
     
        
        this.txtOrderTotal.Text = orderTotal.ToString("F");      
        btnMoneyChange.Enabled = true;  
    }
  13. Revenez à l'écran.
  14. Cliquez deux fois sur le bouton Nouvelle commande pour accéder à son événement Click et mettez en œuvre comme suit :
    private void btnNewOrder_Click(object sender, EventArgs e)  
    {      
        // If the user clicks New Order, we reset the form with the default values      
        txtOrderDate.Text = DateTime.Today.ToShortDateString();      
        txtOrderTime.Text = DateTime.Now.ToShortTimeString();      
        txtFlavor.Text = "Vanilla";      
        txtContainer.Text = "Cone";      
        txtIngredient.Text = "None";      
        txtScoops.Text = "1";      
        txtOrderTotal.Text = "0.00";      
        btnMoneyChange.Enabled = false;  
    }
  15. Revenez à l'écran.
  16. Cliquez deux fois sur le bouton Modifier de Money
  17. Mettez en œuvre l'événement Click comme suit :
    private void btnChange_Click(object sender, EventArgs e)  
    {      
        // Declare a variable for the Calculation form      
        Calculation dlgCalculation = new Calculation();        
    
        // Transfer the current value of the Order Total text       
        // box from the main form to the other form      
        dlgCalculation.txtOrderTotal.Text = this.txtOrderTotal.Text;      
        // Display the other form      
        dlgCalculation.ShowDialog();  
    }
  18. Modifiez les événements Click du Calculate Total et les boutons de commandes comme suit :
    private void btnClose_Click(object sender, EventArgs e)  
    {      
        Close();  
    }
  19. Pour enregistrer l'application, dans le menu principal, cliquez sur fichier - > enregistrer tout
  20. Acceptez le nom et l'emplacement par défaut. Cliquez sur Enregistrer
  21. Pour tester l'application, dans le menu principal, cliquez sur Debug - > démarrer le débogage
  22. Fermez l'écran et revenez à Visual Studio

Les Comportements exceptionnels

Une exception est une situation inhabituelle qui pourrait se produire dans votre programme. En tant que programmeur, vous devriez prévoir n'importe quel comportement anormal qui pourrait être causé par un utilisateur entrant des informations erronées qui pourraient autrement entraîner des résultats imprévisibles. La capacité de traiter un programme éventuel avec un comportement anormal est appelé gestion des exceptions. C# dispose de quatre mots-clés pour gérer une exception. A ce moment, nous passerons en revue deux d'entre eux : try et catch. Plus tard, un mot-clé de plus, throw, sera examiné. Dans une autre leçon, nous allons introduire le dernier mot-clé finally.

  1. Essay du flux normal : Pour faire face au comportement attendu d'un programme, utilisez le mot-clé try comme dans la syntaxe suivante :

    try { comportement }

    Le mot-clé try est requis. Il permet au compilateur de savoir que vous tentez un flux normal de votre programme. Le comportement réel qui doit être évalué est compris entre une accolade d'ouverture "{" et une accolade de fermeture"}" . à l'intérieur des supports, implémentez le flux normal que le programme doit suivre, au moins pour cette section du code. Voici un exemple :
    private void button1_Click(object sender, EventArgs e)  
    {      
        double Number;        
     
     
        try       
        {  	
            Number = double.Parse(textBox1.Text);    	
            
            textBox2.Text = (Number * 2).ToString();      
         }    
     
     
    }
  2. Capture des erreurs : Pendant le flux du programme dans le cadre de la section try, si un comportement anormal se produit, au lieu de laisser l'écrasement du programme ou au lieu de laisser le compilateur, envoyez l'erreur du système d'exploitation, vous pouvez transférer le flux du programme à une autre section qu'il peut traiter. La syntaxe utilisée par cette section est :

    catch { WhatToDo }

    Cette section suit toujours la section try. Il ne doit pas y avoir de code entre la parenthèse finale de try et la section de catch. Le mot-clé catch est nécessaire et suit la section try. Combiné avec le bloc try, la syntaxe d'une exception serait :

    try  
    {  	
              // Try the program flow  
    }  
    catch  
    {  	
             // Catch the exception  
    }

    Un programme qui comprend une section catch apparaitrait comme suit :
    private void button1_Click(object sender, EventArgs e)  
    {      
        double Number;        
     
     
        try       
        {  	
            Number = double.Parse(textBox1.Text);    	
     
     
            textBox2.Text = (Number * 2).ToString();      
         }      
         catch      
         {        
         }  
    }

ApplicationApplication : Présentation des exceptions vagues

  1. Sur l'écran, cliquez deux fois sur le bouton Calculer
  2. Pour introduire des exceptions, modifiez l'événement comme suit :
    private void btnCalculate_Click(object sender, EventArgs e)  
    {     
        double priceContainer = 0.00,             
               priceIngredient = 0.00,             
               priceScoops = 0.00,             
               orderTotal = 0.00;      
        int numberOfScoops = 1;        
     
     
        // Find out what container the customer requested      
        // The price of a container depends on which one the customer selected      
        if (txtContainer.Text == "Cone")          
            priceContainer = 0.55;      
        else if (txtContainer.Text == "Cup")          
            priceContainer = 0.75;      
        else          
            priceContainer = 1.15;        
     
        // If the customer selected an ingredient, which is not "None", add $.95      
        if (txtIngredient.Text != "None")          
            priceIngredient = 0.95;        
     
        try      
        {         
            // Get the number of scoops          
            numberOfScoops = int.Parse(this.txtScoops.Text);            
     
            if (numberOfScoops == 2)              
                priceScoops = 2.55;          
            else if (numberOfScoops == 3)              
                priceScoops = 3.25;          
            else              
                priceScoops = 1.85;      
          }      
          catch      
          {         
          }        
     
          // Make sure the user selected a flavor,       
          // otherwise, there is no reason to process an order      
          if (txtFlavor.Text != "")          
              orderTotal = priceScoops + priceContainer + priceIngredient;        
     
          
          txtOrderTotal.Text = orderTotal.ToString("F");      
          btnMoneyChange.Enabled = true;  
    }
  3. Exécutez l'application.
  4. Dans la zone de texte scoops, tapez 1 et cliquez sur Calculer
  5. Revenez à votre environnement de programmation

Les Exceptions et messages personnalisés

Comme déjà dit, si une erreur se produit lors du traitement du programme dans la section try, le compilateur transfère le traitement à la section suivante de la capture. Vous pouvez ensuite utiliser la section catch pour vous occuper de l'erreur. Au minimum, vous pouvez afficher un message pour informer l'utilisateur. Voici un exemple:

private void button1_Click(object sender, EventArgs e)  
{      
    double Number;        
    
    try       
    {  	
         Number = double.Parse(textBox1.Text);    	
 
 
         textBox2.Text = (Number * 2).ToString();      
    }      
    catch      
    {  	
        MessageBox.Show("Invalid Number");      
    }  
}

Custom Message

Bien entendu, votre message peut ne pas être particulièrement clair, mais cette fois, le programme ne sera pas bloqué. Dans les sections suivantes, nous apprendrons les meilleures façons de traiter les erreurs et les messages.

ApplicationApplication : Affichage des messages personnalisés

  1. Pour afficher des messages personnalisés pour l'utilisateur, modifiez le code de l'événement comme suit :
    private void btnCalculate_Click(object sender, EventArgs e)  
    {      
        double priceContainer = 0.00,             
               priceIngredient = 0.00,             
               priceScoops = 0.00,             
               orderTotal = 0.00;      
        int numberOfScoops = 1;        
     
     
        // Find out what container the customer requested      
        // The price of a container depends on which one the customer selected      
        if (txtContainer.Text == "Cone")          
            priceContainer = 0.55;      
        else if (txtContainer.Text == "Cup")          
            priceContainer = 0.75;      
        else          
            priceContainer = 1.15;  
          
     
        // If the customer selected an ingredient, which is not "None", add $.95      
        if (txtIngredient.Text != "None")          
            priceIngredient = 0.95;        
     
        try      
        {          
             // Get the number of scoops          
             numberOfScoops = int.Parse(this.txtScoops.Text);            
     
             if (numberOfScoops == 2)              
                 priceScoops = 2.55;          
             else if (numberOfScoops == 3)              
                 priceScoops = 3.25;          
             else              
                 priceScoops = 1.85;      
         }      
         catch      
         {          
             MessageBox.Show("The value you entered for the scoops is not valid" +                          
                             "\nOnly natural numbers such as 1, 2, or 3 are allowed" +                          
                             "\nPlease try again", "Clarksville Ice Cream",                          
                             MessageBoxButtons.OK, MessageBoxIcon.Information);      
          }        
     
         
          // Make sure the user selected a flavor,       
          // otherwise, there is no reason to process an order      
          if (txtFlavor.Text != "")          
             orderTotal = priceScoops + priceContainer + priceIngredient;        
     
        
         txtOrderTotal.Text = orderTotal.ToString("F");      
         btnMoneyChange.Enabled = true;  
    }
2. Testez l'application avec des valeurs valides et non valides. Voici un exemple :

Clarksville Ice Cream

3. Fermez le formulaire et le retourner à votre environnement de programmation

Les Exceptions dans le .NET Framework

 

La Classe d' Exception

Dans l'erreur traditionnellement orientée traitant des langages tels que C/C++ ou Object Pascal, vous pouvez créer une exception de votre choix, en incluant un nombre numérique ou une chaine. Pour personnaliser la gestion des exceptions, vous pouvez aussi créer votre (vos) propre(s) classe (s). La plupart des bibliothèques telles que Borland's VCL et Microsoft's MFC expédient également leurs propres classes pour gérer les exceptions. L'événement de la bibliothèque Win32 fournit ce type de mécanisme pour faire face aux erreurs. Pour soutenir la gestion des exceptions le .NET Framework fournit une classe spéciale appelée Exception. Une fois que le compilateur rencontre une erreur, la classe Exception vous permet d'identifier le type d'erreur et prendre des mesures approprées..

Normalement, Exception sert principalement à la catégorie générale des exceptions. Anticipant les divers types de problèmes qui peuvent survenir dans un programme, Microsoft a tiré diverses classes d' exception pour rendre cette question plus conviviale. En conséquence, presque n'importe quel type d'exception que vous pouvez rencontrer a déjà une classe créée pour s'occuper d'elle. Par conséquent, lorsqu'une exception est confrontée à votre programme, vous pouvez facilement identifier le type d'erreur. Il y a tellement de classes d'exceptions que nous ne pouvons pas les étudier ou les voir toutes. La solution que nous utiliserons est d'introduire ou de réviser une classe lorsque nous répondrons à son type d'erreur.

Le Message d'exception

Dans la gestion des exceptions, les erreurs sont traitées dans la section catch. Pour ce faire, utilisez les captures comme s'il s'agissait d'une méthode. Cela signifie que, sur le côté droit de catch, en ouvrant la parenthèse, déclarez une variable du type d'exception que vous souhaitez traiter. Par défaut, une exception est la première de type exception. Sur cette base, c'est une formule typique pour mettre en œuvre la gestion des exceptions :

try  
{  	
        // Process the normal flow of the program here  
}  
catch(Exception e)  
{  	
       // Deal with the exception here  
}

Lorsqu'une exception se produit dans la section try, la compilation de code est transférée à la section catch. Si vous déclarez l'exception comme un type d'exception, cette classe identifie l'erreur. Une des propriétés de la classe exception est appelée Message. Cette propriété contient une chaîne qui décrit le type d'erreur qui s'est produite. Vous pouvez ensuite utiliser cette propriété Exception.Message pour afficher un message d'erreur si vous le souhaitez. Voici un exemple :

private void button1_Click(object sender, EventArgs e)  
{          
        double Number;
 
        try          
        { 
               Number = double.Parse(textBox1.Text);                    
               
               textBox2.Text = (Number * 2).ToString();          
        }          
        catch(FormatException ex)          
        {                  
               MessageBox.Show(ex.Message);          
        }  
}  

An exception using the Exception.Message message

Les Messages d'erreur personnalisés

Comme vous pouvez le voir, l'une des forces de la propriété Exception.Message est qu'elle vous donne une bonne indication du type de problème qui s'est produit. Parfois, le message fourni par la classe Exception peut ne pas apparaitre assez explicite. En fait, vous pouvez ne pas l'afficher à l'utilisateur puisque, dans ce cas, l'utilisateur ne peut pas comprendre ce que signifie l'expression "correct format" dans ce contexte et pourquoi il est utilisé. Comme alternative, vous pouvez créer votre propre message et l'afficher à l'utilisateur. Voici un exemple :

private void button1_Click(object sender, EventArgs e)  
{      
    double Number;    
    
    try       
    {  	
           Number = double.Parse(textBox1.Text);  	
           textBox2.Text = (Number * 2).ToString();      
     }      
     catch(Exception Ex)      
     {  	
           MessageBox.Show("The operation could not be carried because " +  			
                           "the number you typed is not valid");      
     }  
}
 
    

An exception with a custom message

Vous pouvez également combiner le message Exception.Message et votre propre message :

private void button1_Click(object sender, EventArgs e)  
{      
    double Number;        
 
 
    try       
    {  	
        Number = double.Parse(textBox1.Text);  	
        textBox2.Text = (Number * 2).ToString();      
    }      catch(Exception ex)      
    {  	
        MessageBox.Show(ex.Message +                          
                        "\nThe operation could not be carried because " +  			
                        "the number you typed is not valid");      
     }  
}

Une revue des Classes d'Exception .NET

 

Introduction

Le .NET Framework fournit des classes différentes pour gérer presque n'importe quel type d'exception à laquelle vous pouvez penser. Il existe beaucoup de ces classes que nous pouvons mentionner, seulement peu que nous utiliserons régulièrement dans notre application.

Il y a deux façons principales que vous pouvez utiliser l'une des classes du .NET Framework. Si vous êtes sûr qu'une exception particulière sera produite, passez son nom à la clause catch(). Vous n'avez pas le nom de l'argument. Puis, dans la section catch(), affichez un message personnalisé. La deuxième option que vous avez consiste à utiliser le mot-clé throw. Nous l'étudierons plus tard.

Désormais, nous allons essayer de toujours indiquer le type d'exception qui pourrait être levée si quelque chose va mal dans un programme.

L'Exception de Format

Tout ce que l'utilisateur tape dans une application à l'aide du clavier est principalement une chaîne et vous devez le convertir dans le type approprié avant de l'utiliser. Lorsque vous demandez un type spécifique de la valeur de l'utilisateur, après que l'utilisateur ait tapé et vous décidez de convertir le type approprié, si la conversion échoue, le programme produit (nous allons utiliser le mot "throw") une erreur. L'erreur provient de la classe FormatException.

Voici un programme qui traite avec une exception FormatException :

private void button1_Click(object sender, System.EventArgs e)  
{      
    double Number;        

    try       
    {  		
          Number = double.Parse(textBox1.Text);
    		
          textBox2.Text = (Number * 2).ToString();  	
    }  	
    catch(FormatException)  	
    {  		
         MessageBox.Show("You typed an invalid number");  	
    }  
}

The FormatException exception

Application : Utilisation de la classe FormatException

  1. Modifiez l'événement Click du bouton calculer comme suit :
    private void btnCalculate_Click(object sender, EventArgs e)  
    {      
        double priceContainer = 0.00,             
               priceIngredient = 0.00,             
               priceScoops = 0.00,             
               orderTotal = 0.00;      
        int numberOfScoops = 1;        
     
     
         // Find out what container the customer requested      
         // The price of a container depends on which one the customer selected      
         if (txtContainer.Text == "Cone")          
             priceContainer = 0.55;      
         else if (txtContainer.Text == "Cup")          
              priceContainer = 0.75;      
         else          
              priceContainer = 1.15;      
      
     
          // If the customer selected an ingredient, which is not "None", add $.95      
          if (txtIngredient.Text != "None")          
              priceIngredient = 0.95;        
         
          try      
          {          
             // Get the number of scoops          
             numberOfScoops = int.Parse(this.txtScoops.Text);            
     
             if (numberOfScoops == 2)              
                 priceScoops = 2.55;          
             else if (numberOfScoops == 3)              
                  priceScoops = 3.25;          
             else              
                  priceScoops = 1.85;      
           }      
           catch (FormatException)      
           {          
               MessageBox.Show("The value you entered for the scoops is not valid" +                          
                               "\nOnly natural numbers such as 1, 2, or 3 are allowed" +                          
                               "\nPlease try again", "Clarksville Ice Cream",                          
                               MessageBoxButtons.OK, MessageBoxIcon.Information);      
            }        
     
            // Make sure the user selected a flavor,       
            // otherwise, there is no reason to process an order      
            if (txtFlavor.Text != "")          
                orderTotal = priceScoops + priceContainer + priceIngredient;  
          
            txtOrderTotal.Text = orderTotal.ToString("F");      
            btnMoneyChange.Enabled = true;  }
  2. Dans l'Explorateur de solutions, cliquez Calculation.cs et affichez le code
  3. Modifiez le code du bouton calculer comme suit :
    private void btnCalculate_Click(object sender, EventArgs e)  
    {      
         double totalOrder,             
                amountTended = 0.00,             
                difference;        
     
     
         // Get the value of the total order. Actually, this value       
         // will be provided by the main form      
         totalOrder = double.Parse(this.txtOrderTotal.Text);        
     
     
         try      
         {          
             // The amount tended will be entered by the user          
             amountTended = double.Parse(this.txtAmountTended.Text);      
         }      
         catch (FormatException)      
         {          
             MessageBox.Show("The amount you entered is not " +                   
                      "valid - Please try again!");      
          }        
     
          // Calculate the difference of both values, assuming       
          // that the amount tended is higher      
          difference = amountTended - totalOrder;        
     
          // Display the result in the Difference text box      
          txtDifference.Text = difference.ToString("F");  
    }
  4. Exécutez l'application.
  5. Revenez à votre environnement de programmation
  6. Fermez Microsoft Visual Studio. Si on vous demande si vous souhaitez enregistrer le projet, cliquez sur Oui

L'Exception de Débordement

Une application informatique reçoit, traite et produit des valeurs sur une base régulière que le programme est en cours d'exécution. Afin de mieux gérer ces valeurs, comme nous l'avons vu lors de l'étude des variables et des types de données à la Leçon 2, le compilateur utilise les montants appropriés d'espace pour stocker ses valeurs. Il n'est pas rare que soit vous le programmeur ou un utilisateur de votre application fournit une valeur qui est hors de la plage autorisée selon le type de données. Par exemple, nous avons vu qu'un octet utilise 8 bits pour stocker une valeur et une combinaison de 8 bits peut stocker un nombre qui ne dépasse pas 255. Si vous fournissez une valeur supérieure à 255 pour être stockée dans un octet, vous obtenez une erreur. Prenons le programme suivant :

private void button1_Click(object sender, System.EventArgs e)  
{  	
        byte NumberOfPages;   
   
        NumberOfPages = byte.Parse(this.textBox1.Text);
 
        this.textBox2.Text = NumberOfPages.ToString();
}

Quand une valeur au-delà de la plage autorisée est demandée pour être stockée dans la mémoire, le compilateur produit (le verbe est "plaids" comme nous apprendront bientôt) une erreur de la classe exception OverflowException. Voici un exemple de l'exécution du programme avec un mauvais numéro :

Comme avec les autres erreurs, lorsque cette exception est levée, vous devez prendre les mesures appropriées.

L'Argument d' Exception de Plage

Une fois encore, nous savons qu'une valeur est transmise à la méthode Parse() de son type de données pour l'analyse. Pour un type de données primitives, la méthode Parse() analyse la chaîne, et si la chaîne ne peut pas être convertie en un caractère valide ou un numéro, le compilateur génère généralement une exception FormatException comme nous l'avons vu ci-dessus. D'autres classes telles que DateTime utilisent également une méthode Parse() pour analyser les valeurs qui lui sont soumises. Par exemple, si vous demandez une valeur de date à l'utilisateur, la méthode DateTime.Parse() analyse la chaîne à valider. En anglais américain, Parse() prévoit l'utilisateur à taper une chaîne dans la forme jj/aa ou mm/jj/aa jj/mm/aaaa. Prenons le programme suivant :

private void button1_Click(object sender, System.EventArgs e)  
{ 
      	DateTime DateHired;    
 
 
      	DateHired = DateTime.Parse(this.textBox1.Text);    
 
 
      	this.textBox2.Text = DateHired.ToString();  
}

Exception

Si l'utilisateur tape une valeur qui ne peut pas être convertie en une date valide, le compilateur génère une exception ArgumentOutOfRangeException . Voici un exemple d'exécution du programme ci-dessus avec une date non-valide :

Exception

Une façon d'éviter cela est de guider l'utilisateur, mais encore prendre des mesures appropriées, juste au cas où cette erreur est levée.

La Division par l'Exception Zéro

La division par zéro est une opération à toujours éviter. Elle est si importante qu'elle est l'une des exceptions les plus fondamentales de l'ordinateur. Elle est adressée au niveau de la base même par les processeurs Intel et AMD. Elle est également abordée par les systèmes d'exploitation à leur niveau. Elle est également abordée par la plupart, sinon la totalité, des compilateurs. Elle est également abordée par la plupart, sinon, toutes les bibliothèques. Cela signifie que cette exception n'est jamais accueillie partout. Le .NET Framework fournit également sa propre classe pour faire face à cette opération. .

S'il y a une tentative de diviser une valeur par 0, le compilateur génère une exception DivideByZeroException. Nous verrons plus tard un exemple.

Les Techniques d'Utilisation des Exceptions

 

Lancer une Exception

Comme mentionné ci-dessus, la classe Exception est équipée d'une propriété Message qui a effectué un message pour l'erreur qui s'est produite. Nous avons également mentionné que le message de cette propriété ne peut pas être particulièrement utile pour un utilisateur. Heureusement, vous pouvez créer votre propre message et passer à l' Exception. Pour pouvoir recevoir des messages personnalisés, la classe Exception fournit le constructeur suivant :

public Exception(string message);

Pour l'utiliser, dans la section dans laquelle vous prévoyez l'erreur, tapez le mot-clé throw suivi d'une instance new de la classe Exception à l'aide du constructeur qui prend une chaîne. Voici un exemple :

private void button1_Click(object sender, System.EventArgs e)  
{          
        double Operand1, Operand2;          
        double Result = 0.00;          
        string Operator;                
 
 
        try           
        {  	
        Operand1 = double.Parse(this.txtNumber1.Text);  	
        Operator = this.txtOperator.Text;  	
        Operand2 = double.Parse(this.txtNumber2.Text);    	
 
 
        if( Operator != "+" && Operator != "-" && Operator != "*" && Operator != "/" )  		
                throw new Exception(Operator);    	
 
        switch(Operator)  	
        {  	
        case "+":  		
                  Result = Operand1 + Operand2;  		
                  break;  	
        case "-":  		
                  Result = Operand1 - Operand2;  		
                  break;  	
        case "*":  		
                  Result = Operand1 * Operand2;  		
                  break;  	
        case "/":  		
                  Result = Operand1 / Operand2;  		
                  break;  	
        default:  		
                  MessageBox.Show("Bad Operation");  		
                  break;  	
        }    	
        this.txtResult.Text = Result.ToString();          
        }          
        catch(Exception ex)          
        {  	
        MessageBox.Show("Operation Error: " + ex.Message + " is not a valid operator");          
    }  
}

Calculator 1: Exception Handling

Capture de Diverses Exceptions

Dans les exemples ci-dessus, lorsque nous avons prévu un type de problème, nous avons demandé au compilateur d'utiliser notre section de capture par défaut. Nous l'avons laissée jusqu'au compilateur pour savoir quand il y avait un problème et nous avons fourni une section captures pour s'occuper d'elle. Une méthode avec des opérations nombreuses ou complexes et des demandes peut également produire différents types d'erreurs. Avec ce type de programme, vous devez être capable de faire face à des problèmes différents et de traiter individuellement avec eux, chacun par son propre genre. Pour ce faire, vous pouvez créer des sections de captures différentes, à chacun de prévoir une erreur particulière. La formule utilisée serait :

try {  	
             // Code to Try  
}  
catch(Arg1)  
{  	
            // One Exception  
}  
catch(Arg2)  
{  	
            // Another Exception  
}

Le compilateur se déroulerait dans un top-down :

  1. Après l'écoulement normal du programme, le compilateur insère le bloc try
  2. Si aucune exception ne survient dans le bloc try, le reste du bloc try est exécuté.
    Si une exception se produit dans le bloc try, le compilateur enregistre le type d'erreur qui s'est produite. S'il existe une ligne throw, le compilateur l'enregistre également :
    1. Le compilateur sort de la section try
    2. Le compilateur examine la première capture. Si la première capture correspond à l'erreur levée, cette capture exécute et la gestion de routine des exceptions peut saisir. Si la première capture â de ¢ doesnà ' ¬â „¢ t correspond à l'erreur levée, le compilateur se poursuit avec l'erreur suivante.
    3. Le compilateur vérifie le prochain match, le cas échéant et se poursuit comme dans le premier match. Cela continue jusqu'à ce que le compilateur trouve une capture qui correspond à l'erreur levée
    4. Si une des captures correspond à l'erreur levée, son corps s'exécute. Si aucune capture ne correspond à l'erreur levée, le compilateur appelle la classe exception et utilise le message par défaut

Plusieurs captures sont écrites si ou lorsqu'un bloc try est censé déclencher différents types d'erreurs. Par exemple, dans notre calculatrice, nous ne voulons considérer que l'addition, la soustraction, la multiplication et la division. Il est aussi probable que l'utilisateur peut taper un ou deux numéros non valides. Cela nous amène à savoir que notre programme peut produire au moins deux types d'erreurs en ce moment. Sur cette base, nous pouvons traiter en utilisant deux clauses catch comme suit :

private void button1_Click(object sender, System.EventArgs e)  
{          
        double Operand1, Operand2;          
        double Result = 0.00;          
        string Operator;            
 
 
        try           
        {  	
        Operand1 = double.Parse(this.txtNumber1.Text);  	
		 Operator = this.txtOperator.Text;  	
		 Operand2 = double.Parse(this.txtNumber2.Text);    	
 
 
        if( Operator != "+" && Operator != "-" && Operator != "*" && Operator != "/" )  		
                throw new Exception(Operator);    	
		 switch(Operator)  	
		 {  	
		 case "+":  		
				Result = Operand1 + Operand2;  		
				break;  	
		 case "-":  		
				Result = Operand1 - Operand2;  		
				break;  	
		 case "*":  		
				Result = Operand1 * Operand2;  		
				break;  	
		 case "/":  		
				Result = Operand1 / Operand2;  		
				break;  	
		 default:  		
				MessageBox.Show("Bad Operation");  		
				break;  	
		 }    	
		 this.txtResult.Text = Result.ToString();          
		 }          
		 catch(FormatException)          
		 {  	
		 MessageBox.Show("You type an invalid number. Please correct it");          
		 }          
		 catch(Exception ex)          
		 {  	
		 MessageBox.Show("Operation Error: " + ex.Message + " is not a valid operator");          
	}  
}

Catching multiple exceptions
Ce programme fonctionne très bien tant que l'utilisateur tape deux nombres valides et un opérateur arithmétique valide. N'importe quoi d'autre, tel un nombre non valide ou un opérateur inattendu provoquerait une erreur levée :


Exception

Exception

évidemment diverses mauvaises choses peuvent se produire lorsque ce programme est en cours d'exécution. Imaginez que l'utilisateur souhaite effectuer une division. Vous devez indiquer au compilateur que faire si l'utilisateur saisit le dénominateur comme 0 (ou 0,00). Dans ce cas, une des options que vous devriez envisager est d'afficher un message et de sortir. Heureusement, le .NET Framework fournit la classe DivideByZeroException pour traiter avec une exception provoquée par la division par zéro. Comme avec le message transmis à la classe exception, vous pouvez rédiger votre propre message et transmettre au constructeur DivideByZeroException (chaîne message ) constructeur.

Exception est la mère de toutes les classes d'exception. Cela correspond aux trois périodes d'un C++ «bloc catch(...). Par conséquent, si vous écrivez plusieurs blocs catch, celui qui prend l'exception comme argument doit être le dernier.

Voici un exemple qui attrape deux types d'exceptions :

private void button1_Click(object sender, System.EventArgs e)  
{          
    double Operand1, Operand2;          
    double Result = 0.00;          
    string Operator;            
       
    try          
	{  	
	    Operand1 = double.Parse(this.txtNumber1.Text);  	
	    Operator = this.txtOperator.Text;  	
	    Operand2 = double.Parse(this.txtNumber2.Text);    	
 
 
	 if( Operator != "+" && Operator != "-" && Operator != "*" && Operator != "/" )  		
		         throw new Exception(Operator);    	
 
		 switch(Operator)  	
		 {  	
		 case "+":  	        
				Result = Operand1 + Operand2;  	        
				break;  	
		 case "-":  	        
				Result = Operand1 - Operand2;  	        
				break;  	
		 case "*":  	        
				Result = Operand1 * Operand2;  	        
				break;  	
		 case "/":  	        
				if( Operand2 == 0 )  		
				throw new DivideByZeroException("Division by zero is not allowed");  	        
				Result = Operand1 / Operand2;  	        
				break;  	
		 default:  	        
				MessageBox.Show("Bad Operation");  	        
				break;  	
		 }    	
		 
		 this.txtResult.Text = Result.ToString();          
		 }          
		 catch(FormatException)          
		 {  	
		 MessageBox.Show("You type an invalid number. Please correct it");          
		 }          
		 catch(DivideByZeroException ex)          
		 {  	
		 MessageBox.Show(ex.Message);          
		 }          
		 catch(Exception ex)          
		 {  	
		 MessageBox.Show("Operation Error: " + ex.Message + " is not a valid operator");          
	}  
}

Les Exceptions Nesting

Le simulateur de calculateur que nous avons étudié jusqu'ici effectue la division comme l'une de ses missions. Nous avons appris que, dans le but d'effectuer toute opération, le compilateur doit d'abord s'assurer que l'utilisateur a entré un opérateur valide. A condition que l'exploitant soit l'un de ceux que nous attendons, nous devons aussi nous assurer que l'utilisateur a entré un numéro valide. Même si ces deux critères sont remplis, il est possible que l'utilisateur entre 0 pour le dénominateur. Le bloc qui est utilisé pour vérifier un dénominateur non-zero dépend de l'exception qui valide les opérateurs. L'exception qui pourrait résulter d'un dénominateur zéro dépend du premier utilisateur d'entrer un numéro valide pour le dénominateur.

Vous pouvez créer une exception à l'intérieur d'une autre. Ceci est appelé une exception d'imbrication. Ceci est fait en appliquant les mêmes techniques que nous avons utilisées pour imbriquer des instructions conditionnelles. Cela signifie que vous pouvez écrire une exception qui dépend et est soumise à une autre exception. Pour imbriquer une exception, écrivez un bloc try dans le corps de l'exception de parent. Le bloc Try imbriqué doit être suivi de sa propre clause catch (es). Afin de gérer efficacement l'exception, veillez à inclure un throw approprié dans le bloc try. Voici un exemple :

private void button1_Click(object sender, System.EventArgs e)  
{          
        double Operand1, Operand2;          
  		 double Result = 0.00;          
		 string Operator;            
 
 
		 try           
		 {  	
		 Operand1 = double.Parse(this.txtNumber1.Text);  	
		 Operator = this.txtOperator.Text;  	
		 Operand2 = double.Parse(this.txtNumber2.Text);    	
 
 
		 if( Operator != "+" && Operator != "-" && Operator != "*" && Operator != "/" )  		
		         throw new Exception(Operator);    	
 
		 switch(Operator)  	
		 {  	
		 case "+":  		
				Result = Operand1 + Operand2;  		
				this.txtResult.Text = Result.ToString();  		
				break;  	
		 case "-":  		
				Result = Operand1 - Operand2;  		
				this.txtResult.Text = Result.ToString();  		
				break;  	
		 case "*":  		
				Result = Operand1 * Operand2;  		
				this.txtResult.Text = Result.ToString();  		
				break;  	
		 case "/":  	        
				try   	       
			   {  		
				if( Operand2 == 0 )  			
						throw new DivideByZeroException("Division by zero is not allowed");  		
				Result = Operand1 / Operand2;  		
				this.txtResult.Text = Result.ToString();  	        
				}  	        
				catch(DivideByZeroException ex)  	        
				{  		
				MessageBox.Show(ex.Message);  	        
				}  	        
				break;  	
		 default:  	        
				MessageBox.Show("Bad Operation");  	        
				break;                 
			   }          
		 }          
		 catch(FormatException)          
		 {  	
		 MessageBox.Show("You type an invalid number. Please correct it");          
		 }          
		 catch(Exception ex)          
		 {  	
		 MessageBox.Show("Operation Error: " + ex.Message + " is not a valid operator");          
	}  
}

Les Exceptions et méthodes

Une des techniques les plus efficaces permettant de traiter le code consiste à isoler les affectations. Nous l'avons appris lors de l'étude des méthodes des classes. Par exemple, l'instruction switch qui effectuait les opérations dans la version "normal"  de notre programme peut être écrite comme suit :

private double Calculation(double Value1, double Value2, char Symbol)  
{                 
		 double Result = 0.00;
            
		 switch(Symbol)          
		 {          
		 case '+':  	
		 Result = Value1 + Value2;  	
		 break;          
		 case '-':  	
		 Result = Value1 - Value2;  	
		 break;          
		 case '*':  	
		 Result = Value1 * Value2;  	
		 break;          
		 case '/':  	
		 Result = Value1 / Value2;  	
		 break;          
		 }            
 
 
		return Result;  
}    
private void button1_Click(object sender, System.EventArgs e)  
{          
        double Operand1, Operand2;          
		 double Result = 0.00;          
		 char Operator;            
 
 
		 try           
		 {  	
		 Operand1 = double.Parse(this.txtNumber1.Text);  	
		 Operator = char.Parse(this.txtOperator.Text);  	
		 Operand2 = double.Parse(this.txtNumber2.Text);    	
		 
		 if( (Operator != '+') &&                      
					(Operator != '-') &&   	    
			 (Operator != '*') &&   	    
			 (Operator != '/') )  	        
				 throw new Exception(Operator.ToString());    	
 
		 if( Operator == '/' )  	        
				 if( Operand2 == 0 )  	                
						 throw new DivideByZeroException("Division by zero is not allowed");  	
		 Result = Operand1 / Operand2;  	
		 this.txtResult.Text = Result.ToString();  				  	
 
		 
		 Result = Calculation(Operand1, Operand2, Operator);  	
		 this.txtResult.Text = Result.ToString();          
		 }          
		 catch(FormatException)          
		 {  	
		 MessageBox.Show("You type an invalid number. Please correct it");          
		 }          
		 catch(DivideByZeroException ex)          
	  	 {  	
	  	 MessageBox.Show(ex.Message);          
		 }          
		 catch(Exception ex)          
		 {  	
		 MessageBox.Show("Operation Error: " + ex.Message + " is not a valid operator");          
		 }  
}

Il s'agit d'un exemple de l'exécution du programme :

Exception

Vous pouvez toujours utiliser les méthodes régulières avec les méthodes qui gèrent des exceptions. Voici un exemple :

private double Addition(double Value1, double Value2)  
{  	
		 double Result;  		
		         Result = Value1 + Value2;  	
		 return Result;  
}    
 
 
private double Subtraction(double Value1, double Value2)  
{  	
		 double Result;    	
 
 
		 Result = Value1 - Value2;  	
		 return Result;  
}    
 
 
private double Multiplication(double Value1, double Value2)  
{  	
		 double Result;    	
 
		
		 Result = Value1 * Value2;  	
		 return Result;  
}    
 
 
private double Division(double Value1, double Value2)  
{  	
		 double Result;    	
 
 
		 Result = Value1 / Value2;  	
		 return Result;  
}    
 
 
private void button1_Click(object sender, System.EventArgs e)  
{  	
		 double Operand1, Operand2;  	
		 double Result = 0.00;  	
		 char Operator;    	
 
 
		 try   	
		 {  		
				Operand1 = double.Parse(this.txtNumber1.Text);  		
				Operator = char.Parse(this.txtOperator.Text);  		
				Operand2 = double.Parse(this.txtNumber2.Text);    		
 
 
				if( Operator != '+' && Operator != '-' &&   			
						Operator != '*' && Operator != '/' )  			
						throw new Exception(Operator.ToString());    		
 
				 
				 if( Operator == '/' )  			
						 if( Operand2 == 0 )  			
						 throw new DivideByZeroException("Division by zero is not allowed");  				  		
 
				
				  switch(Operator)  		
				  {  			
						  case '+':  				
								  Result = Addition(Operand1, Operand2);  				
								  break;  			
						  case '-':  				
								  Result = Subtraction(Operand1, Operand2);  				
								  break;  			
						  case '*':  				
								  Result = Multiplication(Operand1, Operand2);  				
								  break;  			
						  case '/':  				
								  Result = Division(Operand1, Operand2);  				
								  break;  		
				 }   
 		
				 this.txtResult.Text = Result.ToString();  	
		}  	
		catch(FormatException)  	
		{  		
				MessageBox.Show("You type an invalid number. Please correct it");  	
		}  	
		catch(DivideByZeroException ex)  	
		{  		
				MessageBox.Show(ex.Message);  	
		}  	
		catch(Exception ex)  	
		{  		
				MessageBox.Show("Operation Error: " + ex.Message + " is not a valid operator");  	
		}  
}

Comme dans main(), n'importe quelle méthode d'un programme peut s'occuper de ses propres exceptions qui se produisent dans son corps. Isoler les affectations et les remettre aux méthodes sont un sujet important dans le domaine de la programmation d'applications. Examinez la méthode suivante de la division :

private double Addition(double Value1, double Value2)  
{  	
        double Result;    	
 
 
		 Result = Value1 + Value2;  	
		 return Result;  
}    
 
 
private double Subtraction(double Value1, double Value2)  
{  	
		 double Result;    	
 
 
		 Result = Value1 - Value2;  	
		 return Result;  
}    
 
 
private double Multiplication(double Value1, double Value2)  
{  	
 
 
		 double Result;    	
 
 
		 Result = Value1 * Value2;  	
		 return Result;  
}    
 
 
private double Division(double Value1, double Value2)  
{  	
		 double Result;    	
		 try   	
		 {  		
				if( Value2 == 0 )  			
						throw new DivideByZeroException("Division by zero is not allowed");  				  		
 
				Result = Value1 / Value2;  		
				return Result;  	
		 }  	
		 catch(DivideByZeroException ex)  	
		 {  		
				MessageBox.Show(ex.Message);  	
		 }    	
		 return 0.00; 
}    
 
private void button1_Click(object sender, System.EventArgs e) 
{  	
		 double Operand1, Operand2;  	
		 double Result = 0.00;  	
		 char Operator;    	
		
		 try   	
		 {  		
				Operand1 = double.Parse(this.txtNumber1.Text);  		
				Operator = char.Parse(this.txtOperator.Text);  		
				Operand2 = double.Parse(this.txtNumber2.Text);    		
 
				if( Operator != '+' && Operator != '-' &&   			
						Operator != '*' && Operator != '/' )  			
						throw new Exception(Operator.ToString());    		
 
				switch(Operator)  		
				{  			
						case '+':  				
								Result = Addition(Operand1, Operand2);  				
								break;  			
						case '-':  				
								Result = Subtraction(Operand1, Operand2);  				
								break;  			
						case '*':  				
								Result = Multiplication(Operand1, Operand2);  				
								break;  			
						case '/':  				
								Result = Division(Operand1, Operand2);  				
								break;  		
				}    		
				
				this.txtResult.Text = Result.ToString();  	
		 }  	
		 catch(FormatException)  	
		 {  		
				 MessageBox.Show("You type an invalid number. Please correct it");  	
		 }  	
		 catch(Exception ex)  	
		 {  		
				MessageBox.Show("Operation Error: " + ex.Message + " is not a valid operator");  	
		 }  
}

L'une des manières que vous pouvez utiliser les méthodes de routines d'exception est d'avoir une méthode centrale qui reçoit des variables et les envoie à une méthode externe. La méthode externe teste la valeur d'une variable. Si une exception se produit, la méthode externe affiche ou envoie throw. Ce throw peut être capté par la méthode qui a envoyé l'erreur.

Exercices

 

Les Calculs géométriques

  1. Créez une Application Windows nommée GeometricCalculations
  2. Ajoutez une classe nommée sphère au projet. La classe doit être équipée de propriétés qui peuvent produire le diamètre, la circonférence, la zone et le volume
  3. Concevez le formulaire afin qu'il puisse prendre une valeur de rayon et puisse afficher le diamètre, la circonférence, la zone et le volume.
  4. écrivez du code qui peut afficher les résultats du diamètre, le volume, la zone et la circonférence calculée à partir de la classe de sphère
  5. Ajoutez les info-bulles à tous les contrôles sur le formulaire.
  6. Créez un fichier d'aide qui aide l'utilisateur avec l'application.

Services de nettoyage de Georgetown

  1. Ouvrez l'application GeorgetownCleaningServices1 dans la leçon précédente
  2. Ajoutez les info-bulles à tous les contrôles sur le formulaire
  3. Créez un fichier d'aide qui aide l'utilisateur avec l'application
 
 
 
 

Précédent Copyright © 2009-2011, yevol.com Suivant