Exceções personalizadas; projeto de erros
Crie exceções personalizadas pequenas, escolha os tipos integrados corretos (ArgumentException, InvalidOperationException) e adicione contexto com InnerException.
Exceções personalizadas; projeto de erros é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 3 aulas no total.
Objetivo e metas
Objetivo: tornar os erros claros e fáceis de capturar.
- Use um tipo específico para cada falha específica
- Uma boa mensagem + InnerException para fornecer contexto
- Prefira os tipos integrados quando forem adequados
Tipo de exceção personalizado
Derive de Exception, termine o nome com Exception e adicione os construtores padrão. Armazene dados pequenos e úteis.
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 para contexto
Envolva exceções de baixo nível com uma exceção de domínio e defina InnerException para preservar a causa raiz.
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);
}
}
}
Escolha primeiro os tipos integrados
Use tipos integrados para problemas comuns: 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); }
}
}
Exceções versus validações
Use exceções para situações excepcionais. Para falhas esperadas, prefira validações TryX ou códigos de retorno.
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");
}
}
Lista de verificação do projeto de erros
Lista de verificação:
- Escolha um tipo integrado quando possível.
- Caso contrário, crie um pequeno CustomException com os construtores padrão.
- Associe InnerException para preservar a causa raiz.
- Use exceções para casos inesperados; use TryX para falhas esperadas.
Projeto de exceções personalizadas
Recapitulação
Recapitulação: prefira exceções integradas; caso contrário, defina um pequeno tipo personalizado com os construtores padrão e use InnerException para adicionar contexto sem perder a causa.
Perguntas Frequentes
A aula “Exceções personalizadas; projeto de erros” é grátis?
Sim — o texto completo de “Exceções personalizadas; projeto de erros” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 3 aulas no total.
O que vou aprender em “Exceções personalizadas; projeto de erros”?
Crie exceções personalizadas pequenas, escolha os tipos integrados corretos (ArgumentException, InvalidOperationException) e adicione contexto com InnerException. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C# Academy?
Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.
Quanto tempo leva a aula “Exceções personalizadas; projeto de erros”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C# Academy?
Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- try/catch/finally, throw new versus relançamento
- Exceções personalizadas; projeto de erros
- IDisposable, instrução using