0Pricing
C# Academy · Lekcja

Własne wyjątki i projektowanie błędów

Proszę tworzyć niewielkie własne wyjątki, wybierać właściwe typy wbudowane (ArgumentException, InvalidOperationException) oraz dodawać kontekst za pomocą InnerException.

Własne wyjątki i projektowanie błędów to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 2 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 3 lekcji w sumie.

Cel i założenia

Cel: Sprawić, aby błędy były jasne i możliwe do przechwycenia.

  • Używać konkretnego typu dla konkretnego niepowodzenia
  • Stosować dobry komunikat i InnerException dla zachowania kontekstu
  • Preferować typy wbudowane, gdy pasują do sytuacji

Własny typ wyjątku

Dziedzicz po Exception, kończ nazwę przyrostkiem Exception i dodaj standardowe konstruktory. Przechowuj niewielką ilość przydatnych danych.

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 jako kontekst

Opakowuj wyjątki niższego poziomu w wyjątek domenowy i ustawiaj InnerException, aby zachować pierwotną przyczynę.

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);
    }
  }
}

Najpierw wybieraj typy wbudowane

Używaj typów wbudowanych w przypadku typowych problemów: ArgumentNullException, ArgumentOutOfRangeException, FormatException, InvalidOperationException itd.

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); }
  }
}

Wyjątki a kontrole

Używaj wyjątków w sytuacjach wyjątkowych. W przypadku oczekiwanych niepowodzeń preferuj kontrole TryX lub kody zwrotne.

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 kontrolna projektowania błędów

Lista kontrolna:

  • Jeśli to możliwe, wybierz typ wbudowany.
  • W przeciwnym razie utwórz niewielki CustomException ze standardowymi konstruktorami.
  • Dołącz InnerException, aby zachować pierwotną przyczynę.
  • Używaj wyjątków w nieoczekiwanych sytuacjach, a TryX w przypadku oczekiwanych niepowodzeń.

Projektowanie własnego wyjątku

Szybkie sprawdzenie: Jaki sposób projektowania własnego typu wyjątku jest zalecany w C#?

Podsumowanie

Podsumowanie: Preferuj wyjątki wbudowane, a w przeciwnym razie zdefiniuj niewielki własny typ ze standardowymi konstruktorami i używaj InnerException, aby dodać kontekst bez utraty przyczyny.

Często zadawane pytania

Czy lekcja „Własne wyjątki i projektowanie błędów” jest bezpłatna?

Tak — pełny tekst „Własne wyjątki i projektowanie błędów” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 3 lekcji w sumie.

Co nauczysz się w „Własne wyjątki i projektowanie błędów”?

Proszę tworzyć niewielkie własne wyjątki, wybierać właściwe typy wbudowane (ArgumentException, InvalidOperationException) oraz dodawać kontekst za pomocą InnerException. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 3.

Ile czasu zajmuje lekcja „Własne wyjątki i projektowanie błędów”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. try/catch/finally, throw new a ponowne zgłaszanie
  2. Własne wyjątki i projektowanie błędów
  3. IDisposable, instrukcja using
← Powrót do C# Academy