C# Gestion des exceptions

Une exception est un problème qui survient pendant l'exécution d'un programme. Les exceptions en C# sont une réponse à des situations exceptionnelles qui se produisent au moment de l'exécution, comme tenter de diviser par zéro.

Les exceptions offrent un moyen de transférer le contrôle du programme d'un endroit à un autre. La gestion des exceptions en C# repose sur quatre mots-clés :try、catch、finallyetthrow。

  • try: Un bloc try identifie un bloc de code pour lequel une exception particulière sera activée. Il est suivi d'un ou plusieurs blocs catch.
  • catch: Le programme intercepte une exception via un gestionnaire d'exceptions. Le mot-clé catch indique l'interception d'une exception.
  • finally: Le bloc finally est utilisé pour exécuter les instructions données, indépendamment du fait qu'une exception soit levée. Par exemple, si vous ouvrez un fichier, le fichier sera fermé qu'une exception se produise ou non.
  • throw: Lorsqu'un problème survient, le programme lève une exception. Cela se fait à l'aide du mot-clé throw.

Syntaxe

En supposant qu'un bloc lèvera une exception, une méthode utilise les mots-clés try et catch pour intercepter l'exception. Le code à l'intérieur d'un bloc try/catch est du code protégé, et la syntaxe try/catch est illustrée ci-dessous :

try
{
   // Instruction qui a provoqué l'exception
}
catch( ExceptionName e1 )
{
   // Code de gestion des erreurs
}
catch( ExceptionName e2 )
{
   // Code de gestion des erreurs
}
catch( ExceptionName eN )
{
   // Code de gestion des erreurs
}
finally
{
   // Instruction à exécuter
}

Vous pouvez lister plusieurs instructions catch pour intercepter différents types d'exceptions, au cas où le bloc try générerait plusieurs exceptions dans différentes situations.

Classes d'exceptions en C#

Les exceptions C# sont représentées à l'aide de classes. Les classes d'exceptions en C# sont principalement dérivées directement ou indirectement de la classeSystem.Exception.System.ApplicationExceptionetSystem.SystemExceptionLa classe est une classe d'exception dérivée de la classe System.Exception.

System.ApplicationExceptionla classe prend en charge les exceptions générées par les applications. Par conséquent, les exceptions définies par le programmeur doivent toutes dériver de cette classe.

System.SystemExceptionLa classe est la classe de base de toutes les exceptions système prédéfinies.

Le tableau suivant répertorie quelques classes d'exceptions prédéfinies dérivées de la classe System.SystemException :

Classe d’exceptionDescription
System.IO.IOExceptionGestion des erreurs d'E/S.
System.IndexOutOfRangeExceptionGère les erreurs générées lorsqu'une méthode accède à un index de tableau en dehors des limites.
System.ArrayTypeMismatchExceptionGère les erreurs générées lorsque les types de tableau ne correspondent pas.
System.NullReferenceExceptionGère les erreurs générées lors du référencement d'un objet null.
System.DivideByZeroExceptionGestion des erreurs générées lors d'une division par zéro.
System.InvalidCastExceptionGère les erreurs générées lors d'une conversion de type.
System.OutOfMemoryExceptionGestion des erreurs générées par une mémoire libre insuffisante.
System.StackOverflowExceptionGestion des erreurs générées par un débordement de pile.

Gestion des exceptions

C# fournit un schéma structuré de gestion des exceptions sous la forme de blocs try et catch. À l'aide de ces blocs, les instructions principales du programme sont séparées des instructions de gestion des erreurs.

Ces blocs de gestion des erreurs sont implémentés à l'aide des mots-clés suivants :try、catchetfinally. Ce qui suit est un exemple de levée d'une exception lors d'une division par zéro :

Exemple

using System;
namespace ErrorHandlingApplication
{
    class DivNumbers
    {
        int result;
        DivNumbers()
        {
            result = 0;
        }
        public void division(int num1, int num2)
        {
            try
            {
                result = num1 / num2;
            }
            catch (DivideByZeroException e)
            {
                Console.WriteLine("Exception interceptée : {0}", e);
            }
            finally
            {
                Console.WriteLine("Résultat : {0}", result);
            }

        }
        static void Main(string[] args)
        {
            DivNumbers d = new DivNumbers();
            d.division(25, 0);
            Console.ReadKey();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Exception caught: System.DivideByZeroException: Attempted to divide by zero. 
at ...
Result: 0

Création d'exceptions définies par l'utilisateur

Vous pouvez également définir vos propres exceptions. Les classes d'exceptions définies par l'utilisateur dérivent de la classeApplicationException. L'exemple suivant le démontre :

Exemple

using System;
namespace UserDefinedException
{
   class TestTemperature
   {
      static void Main(string[] args)
      {
         Temperature temp = new Temperature();
         try
         {
            temp.showTemp();
         }
         catch(TempIsZeroException e)
         {
            Console.WriteLine("TempIsZeroException: {0}", e.Message);
         }
         Console.ReadKey();
      }
   }
}
public class TempIsZeroException: ApplicationException
{
   public TempIsZeroException(string message): base(message)
   {
   }
}
public class Temperature
{
   int temperature = 0;
   public void showTemp()
   {
      if(temperature == 0)
      {
         throw (new TempIsZeroException("Zero Temperature found"));
      }
      else
      {
         Console.WriteLine("Temperature: {0}", temperature);
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

TempIsZeroException: Zero Temperature found

Objet levé

Si l'exception est directement ou indirectement dérivée de la classeSystem.Exception, vous pouvez lever un objet. Vous pouvez utiliser l'instruction throw dans un bloc catch pour lever l'objet actuel, comme indiqué ci-dessous :

Catch(Exception e)
{
   ...
   Throw e
}
autres extensions