Exceptions personnalisées et conception des erreurs
Créez de petites exceptions personnalisées, choisissez les types intégrés appropriés (ArgumentException, InvalidOperationException) et ajoutez du contexte avec InnerException.
Exceptions personnalisées et conception des erreurs est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.
Objectif et buts
Objectif : rendre les erreurs claires et interceptables.
- Utilisez un type spécifique pour un échec spécifique
- Message clair et InnerException pour le contexte
- Privilégiez les types intégrés lorsqu’ils conviennent
Type d’exception personnalisé
Dérivez de Exception, terminez le nom par Exception et ajoutez les constructeurs standard. Transportez des données limitées et utiles.
using System;
// Custom, specific to our domain
public sealed class ConfigNotFoundException : Exception
{
public string Key { get; private set; }
public ConfigNotFoundException(string key)
: base("Config key not found: " + key)
{
Key = key;
}
public ConfigNotFoundException(string key, Exception inner)
: base("Config key not found: " + key, inner)
{
Key = key;
}
}
public class Program
{
public static void Main(string[] args)
{
try
{
throw new ConfigNotFoundException("ApiUrl");
}
catch (ConfigNotFoundException ex)
{
Console.WriteLine(ex.Message);
}
}
}
InnerException pour le contexte
Enveloppez les exceptions de niveau inférieur dans une exception de domaine et définissez InnerException pour conserver la cause racine.
using System;
using System.IO;
public sealed class ConfigNotFoundException : Exception
{
public string Key { get; private set; }
public ConfigNotFoundException(string key, Exception inner)
: base("Config key not found: " + key, inner) { Key = key; }
}
public static class Config
{
public static string Load(string path, string key)
{
try
{
string[] lines = File.ReadAllLines(path); // may throw
for (int i = 0; i < lines.Length; i++)
{
int idx = lines[i].IndexOf("=");
if (idx > 0 && lines[i].Substring(0, idx) == key)
return lines[i].Substring(idx + 1);
}
throw new ConfigNotFoundException(key, null);
}
catch (IOException io)
{
// Wrap low-level error with domain meaning
throw new ConfigNotFoundException(key, io);
}
}
}
public class Program
{
public static void Main(string[] args)
{
try
{
Console.WriteLine(Config.Load("missing.cfg", "ApiUrl"));
}
catch (ConfigNotFoundException ex)
{
Console.WriteLine("Top: " + ex.Message);
if (ex.InnerException != null)
Console.WriteLine("Inner: " + ex.InnerException.GetType().Name);
}
}
}
Privilégier d’abord les types intégrés
Utilisez les types intégrés pour les problèmes courants : ArgumentNullException, ArgumentOutOfRangeException, FormatException, InvalidOperationException, etc.
using System;
public static class MathUtil
{
public static int Divide(int a, int b)
{
if (b == 0) throw new DivideByZeroException();
return a / b;
}
public static int ParsePositive(string text)
{
if (text == null) throw new ArgumentNullException("text");
int value = int.Parse(text); // may throw FormatException
if (value <= 0) throw new ArgumentOutOfRangeException("text", "must be > 0");
return value;
}
}
public class Program
{
public static void Main(string[] args)
{
try { Console.WriteLine(MathUtil.ParsePositive("-1")); }
catch (ArgumentOutOfRangeException ex) { Console.WriteLine("Range: " + ex.ParamName); }
}
}
Exceptions et vérifications
Utilisez des exceptions dans les situations exceptionnelles. Pour les échecs attendus, préférez les vérifications TryX ou les codes de retour.
using System;
public static class Parser
{
// BAD: using exceptions for expected cases
public static int ParseOrThrow(string s)
{
return int.Parse(s); // will throw often for user input
}
// GOOD: guard-check pattern for expected failure
public static bool TryParsePositive(string s, out int value)
{
value = 0;
int tmp;
if (!int.TryParse(s, out tmp)) return false;
if (tmp <= 0) return false;
value = tmp;
return true;
}
}
public class Program
{
public static void Main(string[] args)
{
int v;
if (Parser.TryParsePositive("12", out v))
Console.WriteLine("OK " + v);
else
Console.WriteLine("Invalid");
}
}
Liste de vérification de la conception des erreurs
Liste de vérification :
- Choisissez un type intégré si possible.
- Sinon, créez une petite CustomException avec les constructeurs standard.
- Joignez InnerException pour préserver la cause racine.
- Utilisez des exceptions pour les cas inattendus ; utilisez TryX pour les échecs attendus.
Conception d’une exception personnalisée
Récapitulatif
Récapitulatif : préférez les exceptions intégrées ; sinon, définissez un petit type personnalisé avec les constructeurs standard et utilisez InnerException pour ajouter du contexte sans perdre la cause.
Questions Fréquemment Posées
La leçon « Exceptions personnalisées et conception des erreurs » est-elle gratuite ?
Oui — le texte complet de « Exceptions personnalisées et conception des erreurs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Exceptions personnalisées et conception des erreurs » ?
Créez de petites exceptions personnalisées, choisissez les types intégrés appropriés (ArgumentException, InvalidOperationException) et ajoutez du contexte avec InnerException. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C# Academy ?
Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.
Combien de temps prend la leçon « Exceptions personnalisées et conception des erreurs » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?
Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- try/catch/finally, throw new et relance
- Exceptions personnalisées et conception des erreurs
- IDisposable et instruction using