Gestion des exceptions C#

Ici, vous apprendrez à gérer les exceptions en utilisant les blocs try, catch et finally en C#.

Il est nécessaire de gérer les exceptions dans l'application pour éviter les plantages du programme et des résultats inattendus, en enregistrant les exceptions et en poursuivant l'exécution des autres fonctions. C# fournit un soutien pré-défini pour la gestion des exceptions en utilisant les blocs try, catch et finally.

Syntaxe :

try
{
　　　　//　Placer le code ici peut déclencher des exceptions
}
catch
{
　　　　//　Traitez les exceptions ici
}
finally
{
　　　　//　Code de nettoyage final
}

bloc try :Tous les codes suspects qui peuvent déclencher des exceptions doivent être placés dans un bloc try{ }. Si une exception se produit pendant l'exécution, le flux de contrôle saute au premier bloc catch correspondant.

catch bloc:Le bloc catch est un bloc de gestion des exceptions, dans lequel vous pouvez exécuter certaines opérations, telles que l'enregistrement et l'audit des exceptions. Le bloc catch prend un paramètre de type d'exception, que vous pouvez utiliser pour obtenir des détails sur l'exception.

finally bloc:Le bloc finally est toujours exécuté, qu'il y ait ou non une exception. Habituellement, finally devrait utiliser un bloc pour libérer des ressources, par exemple, fermer tout flux ou objet de fichier ouvert dans le bloc try.

Si vous entrez des caractères non numériques, le contenu suivant peut déclencher une exception.

class　Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　Console.WriteLine("Entrez un nombre: ");
　　　　　　　　var num = int.Parse(Console.ReadLine());
　　　　　　　　Console.WriteLine($"Carré de {num} est {num");　*　num");
　　　　}
}

Pour gérer les exceptions possibles dans l'exemple ci-dessus, enveloppez le code dans un bloc try, puis traitez les exceptions dans le bloc catch, comme indiqué ci-dessous.

class　Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　try
　　　　　　　　{
　　　　　　　　　　　　Console.WriteLine("Entrez un nombre: ");
　　　　　　　　　　　　var num = int.parse(Console.ReadLine());
　　　　　　　　　　　　Console.WriteLine($"Carré de {num} est {num");　*　num");
　　　　　　　　}
　　　　　　　　catch
　　　　　　　　{
　　　　　　　　　　　　Console.Write("Error occurred.");
　　　　　　　　}
　　　　　　　　finally
　　　　　　　　{
　　　　　　　　　　　　Console.Write("Re");-try　with　a　different　number.");
　　　　　　　　}
　　　　}
}

Dans l'exemple ci-dessus, nous enveloppons ce code dans un bloc try. Si une exception se produit dans le bloc try, le programme saute au bloc catch. Dans le bloc catch, nous affichons un message pour indiquer à l'utilisateur les informations sur son erreur, et dans le bloc finally, nous affichons un message concernant les opérations après l'exécution du programme.

Le bloc try doit être suivi d'un bloc catch ou finally ou des deux. Si le bloc try n'est pas suivi d'un bloc catch ou finally, une erreur de compilation se produira.

Dans l'idéal, le bloc catch doit inclure des paramètres de classes d'exceptions pré-définies ou personnalisées pour obtenir des détails d'erreur. Voici l'exemple, Exception capture tous les types d'exceptions via le paramètre type.

class　Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　try
　　　　　　　　{
　　　　　　　　　　　　Console.WriteLine("Entrez un nombre: ");
　　　　　　　　　　　　var num = int.parse(Console.ReadLine());
　　　　　　　　　　　　Console.WriteLine($"Carré de {num} est {num");　*　num");
　　　　　　　　}
　　　　　　　　catch(Exception ex)
　　　　　　　　{
　　　　　　　　　　　　Console.Write("Error info:");　+　ex.Message);
　　　　　　　　}
　　　　　　　　finally
　　　　　　　　{
　　　　　　　　　　　　Console.Write("Re");-try　with　a　different　number.");
　　　　　　　　}
　　　　}
}

Filtre d'exception

Vous pouvez utiliser plusieurs blocs catch avec des paramètres de types d'exceptions différents. Cela s'appelle un filtre d'exception. Il est utile de utiliser un filtre d'exception lorsque vous souhaitez traiter différemment des exceptions de types différents.

class　Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　Console.Write("Please　enter　a　number　to　divide　100:　");
　　　　　　　　
　　　　　　　　try
　　　　　　　　{
　　　　　　　　　　　　int　num　=　int.Parse(Console.ReadLine());
　　　　　　　　　　　　int　result　=　100　/　num;
　　　　　　　　　　　　Console.WriteLine("100　/　{0}　=　{1}
　　　　　　　　}
　　　　　　　　catch(DivideByZeroException　ex)
　　　　　　　　{
　　　　　　　　　　　　Console.Write("不能被零除。请再试一次.");
　　　　　　　　}
　　　　　　　　catch(InvalidOperationException　ex)
　　　　　　　　{
　　　　　　　　　　　　Console.Write("无效操作。请再试一次.");
　　　　　　　　}
　　　　　　　　catch(FormatException　　ex)
　　　　　　　　{
　　　　　　　　　　　　Console.Write("不是有效格式。　请再试一次.");
　　　　　　　　}
　　　　　　　　catch(Exception　　ex)
　　　　　　　　{
　　　　　　　　　　　　Console.Write("发生错误！请再试一次.");
　　　　　　　　}
　　　　}
}

Dans l'exemple ci-dessus, nous avons spécifié plusieurs blocs catch avec des types d'exceptions différents. Nous pouvons afficher un message approprié à l'utilisateur en fonction de l'erreur, afin que l'utilisateur ne répète pas la même erreur.

Bloc catch invalide

Il n'est pas permis d'utiliser un bloc catch sans paramètres et un bloc catch avec un paramètre Exception dans la même instruction try..catch, car ils exécutent toutes deux la même opération.

try
{
　　　　//Code susceptible de déclencher une exception
}
catch　//Il ne peut pas y avoir à la fois catch et catch（Exception　异常）
{　
　　　　Console.WriteLine("Exception　occurred");
}
catch(Exception ex)　//Il ne peut pas y avoir à la fois catch et catch（异常异常）
{
　　　　Console.WriteLine("Exception　occurred");
}

De plus, le bloc catch sans paramètres catch {} ou le bloc catch générique catch (Exception ex){} doit être le dernier bloc. Si il y a d'autres blocs catch après le bloc catch {} ou catch (Exception ex), le compilateur donnera une erreur.

　 　 Exemple : capture catch invalide

try
{
　　　　//Code susceptible de déclencher une exception
}
catch
{　
　　　　//　Ce bloc catch doit être le dernier
}
catch (NullReferenceException nullEx)
{
　　　　Console.WriteLine(nullEx.Message);
}
catch (InvalidCastException inEx)
{
　　　　Console.WriteLine(inEx.Message);
}

Bloc finally

Le bloc finally est un bloc optionnel qui doit suivre un bloc try ou catch. Le bloc finally sera toujours exécuté, qu'une exception se produise ou non. Le bloc finally est généralement utilisé pour le code de nettoyage, par exemple pour gérer les objets non gérés.

　 　 Exemple : bloc finally

static void Main(string[] args)
{
　　　　FileInfo file = null;
　　　　try
　　　　{
　　　　　　　　Console.Write("Entrez un nom de fichier à écrire : ");
　　　　　　　　string fileName = Console.ReadLine();
　　　　　　　　file = new FileInfo(fileName);
　　　　　　　　file.AppendText("Hello World!")
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　Console.WriteLine("Erreur survenue : {0}", ex.Message);
　　　　}
　　　　finally
　　　　{
　　　　　　　　//　Ici, nettoyez l'objet fichier ;
　　　　　　　　file = null;
　　　　}
}

Finally ne peut pas être utilisé plusieurs blocs. De plus, le bloc finally ne peut pas contenir les mots-clés return, continue ou break. Il n'autorise pas la sortie du bloc finally.

Try imbriqué-catch

C# permet des try imbriqués-Lorsqu'un try imbriqué est utilisé-Lorsqu'un bloc catch est utilisé, l'exception sera capturée dans le premier bloc correspondant après le bloc try où l'exception a été capturée.

static void Main(string[] args)
{
　　　　var divider = 0;
　　　　try
　　　　{
　　　　　　　　try
　　　　　　　　{
　　　　　　　　　　　　var result =　100/diviseur;
　　　　　　　　}
　　　　　　　　catch
　　　　　　　　{
　　　　　　　　　　　　Console.WriteLine("catch interne");
　　　　　　　　}
　　　　}
　　　　catch
　　　　{
　　　　　　　　Console.WriteLine("catch externe");
　　　　}
}

Catch interne

Dans l'exemple ci-dessus, un bloc interne sera exécuté car c'est le premier bloc catch à traiter toutes les exceptions.

Si aucun bloc catch interne ne correspond au type d'exception lancée, le contrôle passera au bloc catch externe jusqu'à ce qu'un filtre d'exception approprié soit trouvé. Voici un exemple.

static void Main(string[] args)
{
　　　　var divider = 0;
　　　　try
　　　　{
　　　　　　　　try
　　　　　　　　{
　　　　　　　　　　　　var result =　100/diviseur;
　　　　　　　　}
　　　　　　　　catch(NullReferenceException ex)
　　　　　　　　{
　　　　　　　　　　　　Console.WriteLine("catch interne");
　　　　　　　　}
　　　　}
　　　　catch
　　　　{
　　　　　　　　Console.WriteLine("catch externe");
　　　　}
}

catch externe

Dans l'exemple ci-dessus, une exception de type DivideByZeroException sera déclenchée. Comme le bloc catch interne ne traite que NullReferenceTypeException, le bloc catch externe le traitera.