Wyjątki w C# – obsługa błędów

// 😰 Program bez obsługi błędów

Console.Write("Podaj liczbę: ");
string input = Console.ReadLine();

// Co jeśli użytkownik wpisze "abc"?
int liczba = int.Parse(input);  // 💥 CRASH!

Console.WriteLine($"Wpisałeś: {liczba}");

// Wynik dla "abc":
// Unhandled exception. System.FormatException:
// Input string was not in a correct format.

// 1. Nieprawidłowy format danych
int x = int.Parse("abc");  // 💥 FormatException

// 2. Dzielenie przez zero
int wynik = 10 / 0;  // 💥 DivideByZeroException

// 3. Brak pliku
string txt = File.ReadAllText("nieistnieje.txt");  // 💥 FileNotFoundException

// 4. Null reference
string s = null;
int len = s.Length;  // 💥 NullReferenceException

// 5. Indeks poza tablicą
int[] arr = { 1, 2, 3 };
int v = arr[10];  // 💥 IndexOutOfRangeException

Console.Write("Podaj liczbę: ");
string input = Console.ReadLine();

try
{
    // Kod który MOŻE rzucić wyjątek
    int liczba = int.Parse(input);
    Console.WriteLine($"Wpisałeś: {liczba}");
}
catch
{
    // Kod wykonywany GDY wystąpi błąd
    Console.WriteLine("To nie jest poprawna liczba!");
}

Console.WriteLine("Program działa dalej...");

// Dla "abc":
// To nie jest poprawna liczba!
// Program działa dalej...

try
{
    int x = int.Parse("42");  // OK!
    Console.WriteLine($"Liczba: {x}");  // Wykonane
}
catch
{
    Console.WriteLine("Błąd!");  // POMINIĘTE
}

// Wynik:
// Liczba: 42

try
{
    int x = int.Parse("abc");
}
catch (Exception ex)  // Przechwytujemy obiekt wyjątku
{
    Console.WriteLine($"Typ: {ex.GetType().Name}");
    Console.WriteLine($"Komunikat: {ex.Message}");
    Console.WriteLine($"Stack trace: {ex.StackTrace}");
}

// Wynik:
// Typ: FormatException
// Komunikat: Input string was not in a correct format.
// Stack trace: at System.Number.ThrowOverflowOrFormat...

Console.Write("Podaj wiek: ");
string input = Console.ReadLine();

try
{
    int wiek = int.Parse(input);
    Console.WriteLine($"Za 10 lat będziesz mieć {wiek + 10} lat");
}
catch (Exception ex)
{
    // Przyjazny komunikat dla użytkownika
    Console.WriteLine("❌ Podaj poprawną liczbę całkowitą!");
    
    // Szczegóły dla programisty (np. do logów)
    Console.WriteLine($"[DEBUG] {ex.GetType().Name}: {ex.Message}");
}

Exception                          ← Klasa bazowa
├── SystemException
│   ├── FormatException
│   ├── DivideByZeroException
│   ├── NullReferenceException
│   ├── IndexOutOfRangeException
│   ├── ArgumentException
│   │   └── ArgumentNullException
│   ├── InvalidOperationException
│   └── OverflowException
├── IOException
│   └── FileNotFoundException
└── ApplicationException           ← Własne wyjątki (stare podejście)

Console.Write("Podaj dzielnik: ");
string input = Console.ReadLine();

try
{
    int dzielnik = int.Parse(input);
    int wynik = 100 / dzielnik;
    Console.WriteLine($"100 / {dzielnik} = {wynik}");
}
catch (FormatException)
{
    Console.WriteLine("❌ To nie jest liczba!");
}
catch (DivideByZeroException)
{
    Console.WriteLine("❌ Nie można dzielić przez zero!");
}
catch (Exception ex)  // Catch-all na końcu
{
    Console.WriteLine($"❌ Nieznany błąd: {ex.Message}");
}

try
{
    // kod
}
// Łączenie typów (C# 6+)
catch (Exception ex) when (ex is FormatException or OverflowException)
{
    Console.WriteLine("Problem z liczbą!");
}

// Filtr when
catch (Exception ex) when (ex.Message.Contains("timeout"))
{
    Console.WriteLine("Przekroczono czas!");
}

StreamReader reader = null;

try
{
    reader = new StreamReader("dane.txt");
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
}
catch (FileNotFoundException)
{
    Console.WriteLine("Plik nie istnieje!");
}
finally
{
    // ZAWSZE się wykona – zamknij plik!
    if (reader != null)
    {
        reader.Close();
        Console.WriteLine("Plik zamknięty.");
    }
}

// Można użyć try/finally BEZ catch
// Wyjątek poleci wyżej, ale finally się wykona

try
{
    // Otwórz zasób
    // Użyj zasobu (może rzucić wyjątek)
}
finally
{
    // Zamknij zasób (ZAWSZE)
}

public class Osoba
{
    private int _wiek;
    
    public int Wiek
    {
        get { return _wiek; }
        set
        {
            if (value < 0)
            {
                throw new ArgumentException("Wiek nie może być ujemny!");
            }
            if (value > 150)
            {
                throw new ArgumentException("Wiek nie może przekraczać 150!");
            }
            _wiek = value;
        }
    }
}

// Użycie
try
{
    Osoba o = new Osoba();
    o.Wiek = -5;  // 💥 ArgumentException!
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message);  // "Wiek nie może być ujemny!"
}

public class Konto
{
    public decimal Saldo { get; private set; }
    
    public void Wplac(decimal kwota)
    {
        if (kwota <= 0)
            throw new ArgumentException("Kwota musi być dodatnia", nameof(kwota));
        
        Saldo += kwota;
    }
    
    public void Wyplac(decimal kwota)
    {
        if (kwota <= 0)
            throw new ArgumentException("Kwota musi być dodatnia", nameof(kwota));
        
        if (kwota > Saldo)
            throw new InvalidOperationException("Brak wystarczających środków");
        
        Saldo -= kwota;
    }
}

public void PrzetworzPlik(string sciezka)
{
    try
    {
        string content = File.ReadAllText(sciezka);
        // przetwarzanie...
    }
    catch (Exception ex)
    {
        // Zaloguj błąd
        Console.WriteLine($"[LOG] Błąd: {ex.Message}");
        
        // Rzuć dalej (zachowuje stack trace!)
        throw;
    }
}

public void ZapiszDane(string dane)
{
    try
    {
        File.WriteAllText("dane.txt", dane);
    }
    catch (IOException ex)
    {
        // Opakuj w własny wyjątek z dodatkowym kontekstem
        throw new InvalidOperationException(
            "Nie udało się zapisać danych", ex);  // ex = InnerException
    }
}

// Własny wyjątek
public class BrakSrodkowException : Exception
{
    public decimal KwotaBrakujaca { get; }
    
    public BrakSrodkowException(decimal brakuje)
        : base($"Brakuje {brakuje:C} na koncie")
    {
        KwotaBrakujaca = brakuje;
    }
}

// Użycie w klasie
public class Konto
{
    public decimal Saldo { get; private set; } = 100;
    
    public void Wyplac(decimal kwota)
    {
        if (kwota > Saldo)
        {
            decimal brakuje = kwota - Saldo;
            throw new BrakSrodkowException(brakuje);
        }
        Saldo -= kwota;
    }
}

// Obsługa
try
{
    Konto k = new Konto();
    k.Wyplac(500);
}
catch (BrakSrodkowException ex)
{
    Console.WriteLine(ex.Message);
    Console.WriteLine($"Doładuj konto o: {ex.KwotaBrakujaca:C}");
}

public class WalidacjaException : Exception
{
    public string NazwaPola { get; }
    
    // Konstruktor domyślny
    public WalidacjaException() : base() { }
    
    // Z komunikatem
    public WalidacjaException(string message) 
        : base(message) { }
    
    // Z komunikatem i nazwą pola
    public WalidacjaException(string message, string nazwaPola) 
        : base(message)
    {
        NazwaPola = nazwaPola;
    }
    
    // Z inner exception
    public WalidacjaException(string message, Exception inner) 
        : base(message, inner) { }
}

int liczba;
bool poprawne = false;

while (!poprawne)
{
    Console.Write("Podaj liczbę (1-100): ");
    
    try
    {
        liczba = int.Parse(Console.ReadLine());
        
        if (liczba < 1 || liczba > 100)
            throw new ArgumentOutOfRangeException();
        
        poprawne = true;
    }
    catch (FormatException)
    {
        Console.WriteLine("To nie jest liczba!");
    }
    catch (ArgumentOutOfRangeException)
    {
        Console.WriteLine("Liczba musi być z zakresu 1-100!");
    }
}

Console.WriteLine($"Dziękuję! Wybrałeś: {liczba}");

// ❌ Wolniejsze – wyjątek jest kosztowny
try
{
    int x = int.Parse(input);
}
catch (FormatException) { }

// ✅ Szybsze – bez wyjątku
if (int.TryParse(input, out int x))
{
    Console.WriteLine($"Liczba: {x}");
}
else
{
    Console.WriteLine("To nie jest liczba");
}

public static string OdczytajBezpiecznie(string sciezka)
{
    try
    {
        return File.ReadAllText(sciezka);
    }
    catch (FileNotFoundException)
    {
        Console.WriteLine($"Plik nie istnieje: {sciezka}");
        return null;
    }
    catch (UnauthorizedAccessException)
    {
        Console.WriteLine($"Brak dostępu do pliku: {sciezka}");
        return null;
    }
    catch (IOException ex)
    {
        Console.WriteLine($"Błąd odczytu: {ex.Message}");
        return null;
    }
}

// Pełna składnia try/catch/finally
try
{
    // Kod który może rzucić wyjątek
}
catch (SpecyficznyWyjatek ex)
{
    // Obsługa konkretnego typu
}
catch (Exception ex)
{
    // Catch-all (ostatni)
}
finally
{
    // Zawsze się wykonuje
}

// Rzucanie wyjątku
throw new ArgumentException("komunikat");

// Własny wyjątek
public class MojWyjatek : Exception
{
    public MojWyjatek(string msg) : base(msg) { }
}