Gestion des exceptions (Guide de programmation C#)

Un bloc try est utilisé par les programmeurs en C# pour partitionner un code susceptible d'être affecté par une exception. Les blocs catch associés sont utilisés pour gérer toutes les exceptions obtenues. Un bloc finally contient du code exécuté, qu'une exception soit lancée ou non dans le bloc try, par exemple la libération de ressources allouées dans le bloc try. Un bloc try requiert un ou plusieurs blocs catch ou un bloc finally, ou bien les deux.

Les exemples suivants montrent une instruction try-catch, une instruction try-finally et une instruction try-catch-finally.

try
{
    // Code to try goes here.
}
catch (SomeSpecificException ex)
{
    // Code to handle the exception goes here. 
    // Only catch exceptions that you know how to handle. 
    // Never catch base class System.Exception without 
    // rethrowing it at the end of the catch block.
}

try
{
    // Code to try goes here.
}
finally
{
    // Code to execute after the try block goes here.
}

try
{
    // Code to try goes here.
}
catch (SomeSpecificException ex)
{
    // Code to handle the exception goes here.
}
finally
{
    // Code to execute after the try (and possibly catch) blocks  
    // goes here.
}

Un bloc try sans bloc catch ou finally entraîne une erreur de compilateur.

Blocs Catch

Un bloc catch peut spécifier un type d'exception à intercepter. La spécification de type est appelée filtre d'exception. Le type d'exception doit être dérivé de Exception. En règle générale, ne spécifiez pas Exception en tant que filtre d'exceptions, à moins que vous ne sachiez gérer toutes les exceptions qui peuvent être levées dans le bloc try ou que vous n'ayez inclus une instruction throw à la fin du bloc catch.

Plusieurs blocs catch avec les filtres d'exception différents peuvent être enchaînés. Les blocs catch sont évalués de haut en bas dans votre code, mais un seul bloc catch est exécuté pour chaque exception qui est levée. Le premier bloc catch qui spécifie le type exact ou une classe de base de l'exception levée sera exécutée. Si aucun bloc catch ne spécifie de filtre d'exception correspondant, un bloc catch sans filtre est sélectionné, s'il en existe un dans l'instruction. Il est important de placer les blocs catch avec les types d'exception les plus spécifiques, c'est-à-dire les plus dérivées en premier.

Vous devez intercepter des exceptions lorsque les conditions suivantes sont remplies :

• Vous avez une bonne compréhension de la raison pour laquelle l'exception peut être levée, et vous pouvez implémenter une récupération spécifique, par exemple inviter l'utilisateur à entrer un nouveau nom de fichier lorsque vous interceptez un objet FileNotFoundException.

• Vous pouvez créer et lever une exception nouvelle, plus spécifique.

  int GetInt(int[] array, int index)
  {
      try
      {
          return array[index];
      }
      catch(System.IndexOutOfRangeException e)
      {
          throw new System.ArgumentOutOfRangeException(
              "Parameter index is out of range.");
      }
  }
  

• Vous voulez traiter partiellement une exception avant de la transmettre en vue d'un traitement supplémentaire. Dans l'exemple suivant, un bloc catch est utilisé pour ajouter une entrée à un journal d'erreurs avant de lever à nouveau une exception.

  try
  {
      // Try to access a resource.
  }
  catch (System.UnauthorizedAccessException e)
  {
      // Call a custom error logging procedure.
      LogError(e);
      // Re-throw the error. 
      throw;     
  }
  

Blocs Finally

Un bloc finally vous permet de nettoyer les actions exécutées dans un bloc try. S'il est présent, le bloc finally s'exécute en dernier, après le bloc try et tout bloc catch correspondant. Un bloc finally est toujours exécuté, indépendamment de si une exception est levée ou si un bloc catch correspondant au type d'exception est trouvé.

Le bloc finally permet de libérer les ressources telles que flux fichier, connexions de bases de données et handles graphiques, sans attendre le garbage collector dans le runtime pour finaliser les objets. Consultez using, instruction (référence C#) pour plus d'informations.

Dans l'exemple suivant, le bloc finally est utilisé pour fermer un fichier ouvert dans le bloc try. Remarquez que l'état du handle de fichier est vérifié avant que le fichier soit fermé. Si le bloc try ne peut pas ouvrir le fichier, le handle de fichier a encore la valeur null et le bloc finally ne tente pas de le fermer. Ou bien, si le fichier est ouvert avec succès dans le bloc try, le bloc finally ferme le fichier ouvert.

System.IO.FileStream file = null;
System.IO.FileInfo fileinfo = new System.IO.FileInfo("C:\\file.txt");
try
{
    file = fileinfo.OpenWrite();
    file.WriteByte(0xF);
}
finally
{
    // Check for null because OpenWrite might have failed. 
    if (file != null)
    {
        file.Close();
    }
}

Spécification du langage C#

Pour plus d'informations, voir la Spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Voir aussi

Référence

Exceptions et gestion des exceptions (Guide de programmation C#)

try-catch (référence C#)

try-finally (référence C#)

try-catch-finally (référence C#)

using, instruction (référence C#)

Concepts

Guide de programmation C#

Autres ressources

Référence C#