C # - Gestion des exceptions

Une exception est un problème qui survient lors de l'exécution d'un programme. Une exception AC # est une réponse à une circonstance exceptionnelle qui survient lors de l'exécution d'un programme, comme une tentative de division par zéro.

Les exceptions fournissent un moyen de transférer le contrôle d'une partie d'un programme à une autre. La gestion des exceptions C # repose sur quatre mots clés:try, catch, finally, et throw.

  • try- Un bloc try identifie un bloc de code pour lequel des exceptions particulières sont activées. Il est suivi d'un ou plusieurs blocs catch.

  • catch- Un programme intercepte une exception avec un gestionnaire d'exceptions à l'endroit dans un programme où vous souhaitez gérer le problème. Le mot clé catch indique la capture d'une exception.

  • finally- Le bloc finally est utilisé pour exécuter un ensemble d'instructions donné, qu'une exception soit levée ou non. Par exemple, si vous ouvrez un fichier, il doit être fermé, qu'une exception soit déclenchée ou non.

  • throw- Un programme lève une exception lorsqu'un problème apparaît. Ceci est fait en utilisant un mot-clé throw.

Syntaxe

En supposant qu'un bloc lève une exception, une méthode intercepte une exception en utilisant une combinaison des mots-clés try et catch. Un bloc try / catch est placé autour du code qui peut générer une exception. Le code dans un bloc try / catch est appelé code protégé, et la syntaxe d'utilisation de try / catch ressemble à ceci:

try {
   // statements causing exception
} catch( ExceptionName e1 ) {
   // error handling code
} catch( ExceptionName e2 ) {
   // error handling code
} catch( ExceptionName eN ) {
   // error handling code
} finally {
   // statements to be executed
}

Vous pouvez répertorier plusieurs instructions catch pour intercepter différents types d'exceptions au cas où votre bloc try lèverait plus d'une exception dans différentes situations.

Classes d'exception en C #

Les exceptions C # sont représentées par des classes. Les classes d'exception en C # sont principalement dérivées directement ou indirectement deSystem.Exceptionclasse. Certaines des classes d'exception dérivées de la classe System.Exception sont lesSystem.ApplicationException et System.SystemException Des classes.

le System.ApplicationExceptionLa classe prend en charge les exceptions générées par les programmes d'application. Par conséquent, les exceptions définies par les programmeurs devraient dériver de cette classe.

le System.SystemException class est la classe de base pour toutes les exceptions système prédéfinies.

Le tableau suivant fournit certaines des classes d'exceptions prédéfinies dérivées de la classe Sytem.SystemException -

N ° Sr. Classe d'exception et description
1

System.IO.IOException

Gère les erreurs d'E / S.
2

System.IndexOutOfRangeException

Gère les erreurs générées lorsqu'une méthode fait référence à un index de tableau hors plage.
3

System.ArrayTypeMismatchException

Gère les erreurs générées lorsque le type ne correspond pas au type de tableau.
4

System.NullReferenceException

Gère les erreurs générées par le référencement d'un objet nul.
5

System.DivideByZeroException

Gère les erreurs générées par la division d'un dividende par zéro.
6

System.InvalidCastException

Gère les erreurs générées lors de la conversion de type.
sept

System.OutOfMemoryException

Gère les erreurs générées par une mémoire libre insuffisante.
8

System.StackOverflowException

Gère les erreurs générées par le débordement de pile.

Gestion des exceptions

C # fournit une solution structurée à la gestion des exceptions sous la forme de blocs try and catch. En utilisant ces blocs, les instructions du programme principal sont séparées des instructions de gestion des erreurs.

Ces blocs de gestion des erreurs sont implémentés à l'aide du try, catch, et finallymots clés. Voici un exemple de levée d'une exception lors de la division par zéro condition -

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 caught: {0}", e);
         } finally {
            Console.WriteLine("Result: {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 votre propre exception. Les classes d'exceptions définies par l'utilisateur sont dérivées deExceptionclasse. L'exemple suivant illustre ceci -

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: Exception {
   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

Lancer des objets

Vous pouvez lancer un objet s'il est dérivé directement ou indirectement du System.Exceptionclasse. Vous pouvez utiliser une instruction throw dans le bloc catch pour lancer l'objet présent comme -

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