Gestion des exceptions C#

Les exceptions sont des problèmes qui surviennent 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, finally et throw.

try : Un bloc try identifie un bloc de code qui déclenchera 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 dans le 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 serait utilisé dans différents multiples. des exceptions sont générées dans ce cas.

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

异常类	描述
System.IO.IOException	处理 I/O 错误。
System.IndexOutOfRangeException	处理当方法指向超出范围的数组索引时生成的错误。
System.ArrayTypeMismatchException	处理当数组类型不匹配时生成的错误。
System.NullReferenceException	处理当依从一个空对象时生成的错误。
System.DivideByZeroException	处理当除以零时生成的错误。
System.InvalidCastException	处理在类型转换期间生成的错误。
System.OutOfMemoryException	处理空闲内存不足生成的错误。
System.StackOverflowException	处理栈溢出生成的错误。

Gestion des exceptions

C# sous forme de blocs try and catch Fournit un solution structurée de gestion des exceptions. 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 finally. 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éation d'une exception définie par l'utilisateur

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);
      }
   }
}