Gestion des exceptions (Guide de programmation C#)

Mise à jour : novembre 2007

Un bloc try est utilisé par les programmeurs C# pour partitionner le code qui peut être affecté par une exception, et les blocs catch servent à gérer toutes les exceptions résultantes. Un bloc finally peut être utilisé pour exécuter le code, qu'une exception soit levée ou non. Cette situation est parfois nécessaire étant donné que le code qui suit une construction try/catch ne sera pas exécuté si une exception est levée. Un bloc try doit être utilisé avec un bloc catch ou finally et peut inclure plusieurs blocs catch. Par exemple :

try
{
    // Code to try here.
}
catch (SomeSpecificException ex)
{
    // Code to handle exception here.
    // Only catch exceptions 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 here.
}
finally
{
    // Code to execute after try here.
}

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

Une instruction try sans bloc catch ou finally provoquera une erreur du compilateur.

Blocs Catch

Un bloc catch peut spécifier un type d'exception à intercepter. Ce type est appelé un filtre d'exception et doit être un type dérivé d'Exception. En général, ne spécifiez pas Exception dans un bloc catch à moins que vous ne soyez sûr de pouvoir gérer toutes les exceptions qui peuvent être levées dans le bloc try ou que vous n'incluiez une instruction throw à la fin de votre bloc catch.

Plusieurs blocs catch avec les filtres d'exception différents peuvent être enchaînés. Plusieurs blocs catch sont évalués de haut en bas, mais seul un bloc catch est exécuté pour chaque exception 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 (le cas échéant) sera exécuté. Il est important de placer les blocs catch avec les classes 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 savez exactement pourquoi l'exception a été levée et vous êtes en mesure d'implémenter une opération de récupération spécifique, comme intercepter un objet FileNotFoundException et inviter l'utilisateur à entrer un nouveau nom de fichier.

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

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

• Pour gérer partiellement une exception. Par exemple, un bloc catch pourrait être utilisé pour ajouter une entrée à un journal d'erreurs. Levez donc à nouveau l'exception pour autoriser la gestion ultérieure de l'exception. Par exemple :

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

Blocs Finally

Un bloc finally autorise le nettoyage d'actions effectuées dans un bloc try. S'il est présent, le bloc finally s'exécute après l'exécution des blocs try et catch. 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 cet exemple, le bloc finally permet de fermer un fichier ouvert dans le bloc try. Remarquez que l'état du handle de fichier est vérifié avant qu'il soit fermé. Si le bloc try n'a pas ouvert le fichier, le handle de fichier aura toujours la valeur null. Ou bien, si le fichier s'ouvre avec succès et qu'aucune exception n'est levée, le bloc finally sera encore exécuté et fermera 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, consultez les sections suivantes dans Spécifications du langage C#.

• 16 Exceptions

• 8.9.5 L'instruction throw

• 8.10 L'instruction try

Voir aussi

Concepts

Guide de programmation C#

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#)

Autres ressources

Référence C#