[Tutoriel C#] Gestion des exceptions C#

Gestion des exceptions C#

Les exceptions sont des problèmes qui se produisent lors de l'exécution du programme. Une exception en C# est une réponse à une situation particulière qui se produit pendant l'exécution du programme, telle qu'une tentative de division par zéro.

Les exceptions permettent de transférer le contrôle d'un programme d'une partie à une autre. La gestion des exceptions C# est basée sur quatre mots-clés : try, catch, enfin et throw.

try : Un bloc try identifie un bloc de code qui sera activé pour une exception spécifique. Suivi d'un ou plusieurs blocs catch.

catch : Le programme intercepte les exceptions via des gestionnaires d'exceptions. Le mot-clé catch indique la capture d'exceptions.

finally : le bloc final est utilisé pour exécuter une instruction donnée, qu'une exception soit levée ou non. Par exemple, si vous ouvrez un fichier, celui-ci sera fermé, qu'une exception se produise ou non.

throw : lorsqu'un problème survient, le programme lève une exception. Utilisez le mot-clé throw pour y parvenir.

Syntaxe

Supposons qu'un bloc lèvera une exception et une méthode pour intercepter l'exception à l'aide de mots-clés try et catch. Le code à l'intérieur du bloc try/catch est du code protégé. Utilisez la syntaxe try/catch comme suit :

try
{
   // 引起异常的语句
}
catch( ExceptionName e1 )
{
   // 错误处理代码
}
catch( ExceptionName e2 )
{
   // 错误处理代码
}
catch( ExceptionName eN )
{
   // 错误处理代码
}
finally
{
   // 要执行的语句
}

Vous pouvez répertorier plusieurs instructions catch pour capturer différents types d'exceptions au cas où le bloc try aurait plusieurs exceptions. générés dans des circonstances différentes.

Classes d'exception en C#

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

La classe System.ApplicationException prend en charge les exceptions générées par les applications. Par conséquent, toutes les exceptions définies par le programmeur doivent être dérivées de cette classe.

La classe System.SystemException est la classe de base pour 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 Sytem.SystemException :

Classe d'exception

Description

System.IO.IOException Gère les erreurs d'E/S.

System.IndexOutOfRangeException Gère l'erreur générée lorsqu'une méthode pointe vers un index de tableau hors plage.

System.ArrayTypeMismatchException Gère les erreurs générées lorsque les types de tableaux ne correspondent pas.

System.NullReferenceException Gère les erreurs générées lors de l'utilisation d'un objet nul.

System.DivideByZeroException Gère les erreurs générées lors de la division par zéro.

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

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

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 de gestion des exceptions sous la forme de blocs try and catch. Utilisez ces blocs pour séparer les instructions du programme principal des instructions de gestion des erreurs.

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

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 les résultats suivants :

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

Créer un utilisateur personnalisé Exceptions

Vous pouvez également définir vos propres exceptions. Les classes d'exceptions définies par l'utilisateur sont dérivées de la classe ApplicationException. L'exemple suivant le démontre :

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 les résultats suivants :

TempIsZeroException: Zero Temperature found

Lance l'objet

Vous pouvez lève un objet si l'exception est dérivée directement ou indirectement de la classe System.Exception. Vous pouvez lancer l'objet actuel en utilisant une instruction throw à l'intérieur d'un bloc catch comme ceci :

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

 以上就是【c#教程】C# 异常处理的内容，更多相关内容请关注PHP中文网（www.php.cn）！