try-catch (référence C#)
L'instruction try-catch consiste en un bloc try suivi d'une ou de plusieurs clauses catch, qui désignent les gestionnaires des différentes exceptions. Quand une exception est levée, le Common Language Runtime (CLR) recherche l'instruction catch qui gère cette exception. Si la méthode en cours d'exécution ne contient pas de bloc catch, le CLR examine la méthode qui a appelé la méthode actuelle, et ainsi de suite en remontant la pile des appels. Si aucun bloc catch n'est trouvé, le CLR affiche un message d'exception non gérée destiné à l'utilisateur et arrête l'exécution du programme.
Le bloc try contient le code protégé risquant de provoquer l'exception. Le bloc est exécuté jusqu'à la levée d'une exception ou jusqu'à sa réussite totale. Par exemple, la tentative suivante d'opérer un cast sur un objet null déclenche l'exception NullReferenceException :
object o2 = null;
try
{
int i2 = (int)o2; // Error
}
Bien que la clause catch puisse être employée sans arguments afin d'intercepter tout type d'exception, cette utilisation est déconseillée. En général, vous devez intercepter uniquement les exceptions que vous savez récupérer. Par conséquent, vous devez toujours spécifier un argument objet dérivé de System.Exception. Exemple :
catch (InvalidCastException e)
{
}
Il est possible d'utiliser plus d'une clause catch spécifique dans la même instruction try-catch. Dans ce cas, l'ordre des clauses catch est important parce que les clauses catch sont examinées dans l'ordre. Interceptez les exceptions les plus spécifiques avant celles qui le sont le moins. Le compilateur génère une erreur si vous ordonnez vos blocs catch de sorte qu'un bloc ultérieur ne soit jamais atteint.
Une instruction throw peut être utilisée dans un bloc catch pour lever une nouvelle fois l'exception interceptée par l'instruction catch. L'exemple suivant extrait des informations source d'une exception IOException, puis lève l'exception à la méthode parente.
catch (FileNotFoundException e)
{
// FileNotFoundExceptions are handled here.
}
catch (IOException e)
{
// Extract some information from this exception, and then
// throw it to the parent method.
if (e.Source != null)
Console.WriteLine("IOException source: {0}", e.Source);
throw;
}
Vous pouvez intercepter une exception et lever une exception différente. Dans ce cas, spécifiez l'exception que vous avez interceptée comme une exception interne, comme indiqué dans l'exemple suivant.
catch (InvalidCastException e)
{
// Perform some action here, and then throw a new exception.
throw new YourCustomException("Put your error message here.", e);
}
Vous pouvez aussi lever à nouveau une exception lorsqu'une condition spécifiée a la valeur true, comme indiqué dans l'exemple suivant.
catch (InvalidCastException e)
{
if (e.Data == null)
{
throw;
}
else
{
// Take some action.
}
}
Depuis un bloc try, initialisez uniquement les variables déclarées à l'intérieur. Sinon, une exception peut se produire avant la fin de l'exécution du bloc. Par exemple, dans l'exemple de code suivant, la variable n est initialisée dans le bloc try. Toute tentative d'utilisation de cette variable en dehors du bloc try dans l'instruction Write(n) générera une erreur de compilation.
static void Main()
{
int n;
try
{
// Do not initialize this variable here.
n = 123;
}
catch
{
}
// Error: Use of unassigned local variable 'n'.
Console.Write(n);
}
Pour plus d'informations sur catch, consultez try-catch-finally.
Exemple
Dans cet exemple, le bloc try contient un appel à la méthode ProcessString qui peut provoquer une exception. La clause catch contient le gestionnaire d'exceptions qui affiche simplement un message à l'écran. Quand l'instruction throw est appelée de l'intérieur de MyMethod, le système recherche l'instruction catch et affiche le message Exception caught.
class TryFinallyTest
{
static void ProcessString(string s)
{
if (s == null)
{
throw new ArgumentNullException();
}
}
static void Main()
{
string s = null; // For demonstration purposes.
try
{
ProcessString(s);
}
catch (Exception e)
{
Console.WriteLine("{0} Exception caught.", e);
}
}
}
/*
Output:
System.ArgumentNullException: Value cannot be null.
at TryFinallyTest.Main() Exception caught.
* */
Dans cet exemple, deux instructions catch sont utilisées. L'instruction la plus spécifique, qui apparaît la première, est interceptée.
class ThrowTest3
{
static void ProcessString(string s)
{
if (s == null)
{
throw new ArgumentNullException();
}
}
static void Main()
{
try
{
string s = null;
ProcessString(s);
}
// Most specific:
catch (ArgumentNullException e)
{
Console.WriteLine("{0} First exception caught.", e);
}
// Least specific:
catch (Exception e)
{
Console.WriteLine("{0} Second exception caught.", e);
}
}
}
/*
Output:
System.ArgumentNullException: Value cannot be null.
at Test.ThrowTest3.ProcessString(String s) ... First exception caught.
*/
Dans l'exemple précédent, si vous commencez par la clause catch la moins spécifique, vous obtiendrez le message d'erreur suivant :
A previous catch clause already catches all exceptions of this or a super type ('System.Exception')
Cependant, pour intercepter l'exception la moins spécifique, remplacez l'expression throw par la suivante :
throw new Exception();
Spécification du langage C#
Pour plus d'informations, consultez 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
Tâches
Comment : lever explicitement des exceptions
Référence
try, catch, and throw Statements (C++)
Instructions de gestion des exceptions (Référence C#)
Concepts
Autres ressources
Historique des modifications
Date |
Historique |
Motif |
|---|---|---|
|
Juillet 2010 |
Mise à jour des exemples throw. |
Commentaires client. |