Obsługa błędów w C#

Obsługa błędów w C# jest kluczowym aspektem tworzenia niezawodnych i bezpiecznych aplikacji. Poprawne zarządzanie błędami pozwala na diagnozowanie i naprawianie problemów, a także poprawia doświadczenie użytkownika.

Oto kilka kluczowych koncepcji i praktyk związanych z obsługą błędów w C#:

1. Mechanizmy Obsługi Błędów:

Wyjątki:

• Wyjątki w C# są używane do obsługi błędów i sytuacji wyjątkowych.
• Wyjątki są zgłaszane przez kod, a program może przechwytywać i obsługiwać wyjątki za pomocą bloku try-catch.

try
{
    // Kod, który może zgłosić wyjątek
}
catch (Exception ex)
{
    // Obsługa wyjątku
    Console.WriteLine($"Wystąpił błąd: {ex.Message}");
}
finally
{
    // Kod jest wykonywany zawsze, niezależnie od tego, czy wyjątek został zgłoszony
}

Instrukcje try-catch w Zakresie:

• Instrukcje try-catch mogą być używane z blokami using do zarządzania zasobami, takimi jak pliki czy połączenia do baz danych.

try
{
    using (var plik = new FileStream("plik.txt", FileMode.Open))
    {
        // Kod, który korzysta z pliku
    }
}
catch (IOException ex)
{
    // Obsługa błędów związanych z operacjami wejścia-wyjścia (IO)
    Console.WriteLine($"Błąd IO: {ex.Message}");
}

2. Rzucanie Własnych Wyjątków:

• Rzucanie własnych wyjątków pozwala na bardziej precyzyjne informowanie o błędach i dostarczanie dodatkowych informacji.

public class MojaKlasa
{
    public void Metoda()
    {
        if (warunek)
        {
            throw new ApplicationException("Wystąpił błąd w metodzie.");
        }
    }
}

3. Logowanie Błędów:

• Logowanie błędów jest kluczowym elementem diagnostyki i utrzymania systemu.
• Użyj narzędzi do logowania, takich jak ILogger w ASP.NET Core, aby rejestrować błędy.

public class MojaKlasa
{
    private readonly ILogger<MojaKlasa> _logger;

    public MojaKlasa(ILogger<MojaKlasa> logger)
    {
        _logger = logger;
    }

    public void Metoda()
    {
        try
        {
            // Kod, który może zgłosić wyjątek
        }
        catch (Exception ex)
        {
            // Logowanie błędów
            _logger.LogError(ex, "Wystąpił błąd w metodzie.");
        }
    }
}

4. Niwelowanie Błędów:

Sprawdzanie Działania (Code Contracts):

• Używaj asercji i pre/post-warunków, aby sprawdzać poprawność danych i stanu programu.

public class MojaKlasa
{
    public void Metoda(int x)
    {
        Contract.Requires<ArgumentException>(x > 0, "x musi być większe od zera.");

        // Reszta kodu
    }
}

Obsługa Opcji:

• Używaj obsługi opcji zamiast obsługi wartości null, gdy to możliwe.

public class MojaKlasa
{
    public string PobierzImie()
    {
        return opcja?.Imie ?? "DomyślneImie";
    }
}

5. Praktyki w Asynchronicznych Operacjach:

• W operacjach asynchronicznych błędy mogą być zgłaszane poprzez Task lub Task<T>.

public async Task<string> PobierzDaneAsynchronicznie()
{
    try
    {
        // Kod asynchroniczny, który może zgłosić wyjątek
        return await OperacjaAsynchroniczna();
    }
    catch (Exception ex)
    {
        // Obsługa błędów
        Console.WriteLine($"Wystąpił błąd: {ex.Message}");
        return "Błąd";
    }
}

6. Testowanie Obsługi Błędów:

• Testuj różne scenariusze błędów, aby upewnić się, że kod obsługuje je poprawnie.
• Testowanie jednostkowe i testy integracyjne są kluczowe dla zapewnienia niezawodności obsługi błędów.

7. Globalna Obsługa Błędów w Aplikacjach ASP.NET Core:

W aplikacjach ASP.NET Core, możesz skonfigurować globalną obsługę błędów w pliku Startup.cs:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }
}

8. Dostosowane Wyjątki (Custom Exceptions):

• Twórz dostosowane klasy wyjątków, aby reprezentować specyficzne błędy w twojej aplikacji.

public class CustomException : Exception
{
    public CustomException(string message) : base(message)
    {
    }
}

9. Obsługa Multiplekstowania Wyjątków:

• Korzystaj z wielu bloków catch, aby obsłużyć różne typy wyjątków w sposób indywidualny.

try
{
    // Kod, który może zgłosić różne wyjątki
}
catch (CustomException ex)
{
    // Obsługa wyjątku niestandardowego
    Console.WriteLine($"Niestandardowy błąd: {ex.Message}");
}
catch (DivideByZeroException ex)
{
    // Obsługa błędu dzielenia przez zero
    Console.WriteLine($"Dzielenie przez zero: {ex.Message}");
}
catch (Exception ex)
{
    // Obsługa innych wyjątków
    Console.WriteLine($"Inny błąd: {ex.Message}");
}

10. Obsługa Błędów w Delegatach i Wyrażeniach Lambda:

• W przypadku korzystania z delegatów i wyrażeń lambda, stosuj odpowiednie obsługi błędów.

Action akcja = () =>
{
    try
    {
        // Kod, który może zgłosić wyjątek
    }
    catch (Exception ex)
    {
        // Obsługa błędu
        Console.WriteLine($"Błąd: {ex.Message}");
    }
};

akcja();

11. Wykorzystanie Wzorców Wyjątków (Exception Patterns):

• W C# 7.0 i nowszych wersjach możesz korzystać z wzorców wyjątków, które pozwalają na bardziej precyzyjne dopasowanie typu wyjątku.

try
{
    // Kod, który może zgłosić wyjątek
}
catch (CustomException ce) when (ce.WaznyWarunek())
{
    // Obsługa niestandardowego wyjątku z dodatkowym warunkiem
    Console.WriteLine($"Niestandardowy błąd: {ce.Message}");
}
catch (Exception ex)
{
    // Obsługa innych wyjątków
    Console.WriteLine($"Inny błąd: {ex.Message}");
}

12. Wykorzystanie ASP.NET Core Middleware do Obsługi Błędów HTTP:

W aplikacjach ASP.NET Core, możesz skonfigurować middleware do obsługi błędów HTTP:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }
}

Middleware UseExceptionHandler pozwala na zdefiniowanie ścieżki, do której użytkownik zostanie przekierowany w przypadku wystąpienia błędu.

13. Monitorowanie i Alarmowanie:

• Implementuj system monitorowania, aby natychmiastowe dowiadywanie się o krytycznych błędach.
• Wykorzystuj narzędzia do alarmowania, takie jak Azure Application Insights lub inne rozwiązania monitorujące.

14. Wykorzystanie try-catch z when dla Warunków:

• when może być używane w blokach catch, aby dodać warunki, które muszą być spełnione, aby obsłużyć dany blok catch.

try
{
    // Kod, który może zgłosić wyjątek
}
catch (IOException ex) when (ex.Message.Contains("plik"))
{
    // Obsługa błędów związanych z operacjami wejścia-wyjścia (IO) dla pliku
    Console.WriteLine($"Błąd IO związany z plikiem: {ex.Message}");
}
catch (IOException ex)
{
    // Inne obsługi błędów IO
    Console.WriteLine($"Błąd IO: {ex.Message}");
}
catch (Exception ex)
{
    // Obsługa innych wyjątków
    Console.WriteLine($"Inny błąd: {ex.Message}");
}

15. Korzystanie z throw do Przekazywania Błędów:

• W bloku catch można użyć throw, aby ponownie zgłosić ten sam lub inny wyjątek.

try
{
    // Kod, który może zgłosić wyjątek
}
catch (IOException ex)
{
    // Obsługa błędów związanych z operacjami wejścia-wyjścia (IO)
    Console.WriteLine($"Błąd IO: {ex.Message}");

    // Ponowne zgłoszenie tego samego wyjątku
    throw;
}
catch (Exception ex)
{
    // Obsługa innych wyjątków
    Console.WriteLine($"Inny błąd: {ex.Message}");

    // Ponowne zgłoszenie innego wyjątku
    throw new CustomException("Wystąpił niestandardowy błąd.", ex);
}

16. Korzystanie z using dla Zarządzania Zasobami:

• Korzystaj z bloków using, aby zapewnić, że zasoby, takie jak pliki czy połączenia do baz danych, zostaną poprawnie zwolnione.

try
{
    using (var plik = new FileStream("plik.txt", FileMode.Open))
    {
        // Kod, który korzysta z pliku
    }
}
catch (IOException ex)
{
    // Obsługa błędów związanych z operacjami wejścia-wyjścia (IO)
    Console.WriteLine($"Błąd IO: {ex.Message}");
}

17. Praktyki Bezpiecznego Programowania:

• Unikaj operacji, które mogą spowodować błąd, zanim sprawdzisz, czy są one bezpieczne do wykonania.
• Wykorzystuj mechanizmy walidacji danych, aby zapobiec wprowadzaniu błędnych danych do systemu.

if (numer > 0)
{
    // Bezpieczne dzielenie przez numer
    wynik = 42 / numer;
}
else
{
    // Obsługa błędnego numeru
    Console.WriteLine("Numer musi być większy od zera.");
}

Te praktyki obejmują bardziej zaawansowane aspekty obsługi błędów, takie jak warunki w blokach catch, ponowne zgłaszanie wyjątków (throw) w kontrolowany sposób, a także zastosowanie bloków using dla zarządzania zasobami. Dążąc do bezpiecznego i niezawodnego kodu, zawsze warto dostosować praktyki do konkretnego kontekstu projektowego.

18. Walidacja Wejścia:

• Na wejściu funkcji lub metody, szczególnie publicznej, przeprowadzaj walidację parametrów. To pozwoli uniknąć nieoczekiwanych błędów.

public void Metoda(int x)
{
    if (x <= 0)
    {
        throw new ArgumentException("x musi być większe od zera.", nameof(x));
    }

    // Reszta kodu
}

19. Obsługa Błędów w Kodzie Asynchronicznym:

• W kodzie asynchronicznym obsługa błędów może wymagać specjalnego podejścia. Wyjątki z operacji asynchronicznych są opakowane w AggregateException.

try
{
    await OperacjaAsynchroniczna();
}
catch (Exception ex) when (ex is InvalidOperationException || ex is TimeoutException)
{
    // Obsługa konkretnych wyjątków
    Console.WriteLine($"Wystąpił błąd: {ex.Message}");
}
catch (AggregateException ex)
{
    foreach (var innerException in ex.InnerExceptions)
    {
        // Obsługa wszystkich wyjątków
        Console.WriteLine($"Wystąpił błąd: {innerException.Message}");
    }
}

20. Obsługa Błędów w Testach Jednostkowych:

• W testach jednostkowych specjalnie zadbaj o sprawdzenie, czy metody zgłaszają oczekiwane wyjątki.

[TestMethod]
[ExpectedException(typeof(DivideByZeroException))]
public void DzieleniePrzezZeroPowinnoZglosicWyjatek()
{
    Kalkulator.Dzielenie(42, 0);
}

21. Zastosowanie Environment.FailFast:

• W niektórych przypadkach, kiedy aplikacja napotyka na nieodwracalny błąd, można skorzystać z Environment.FailFast, co powoduje zakończenie aplikacji bez próby wykonywania innych operacji.

try
{
    // Kod, który może zgłosić nieodwracalny błąd
}
catch (Exception ex)
{
    Console.WriteLine($"Wystąpił nieodwracalny błąd: {ex.Message}");
    Environment.FailFast("Aplikacja zakończona z powodu nieodwracalnego błędu.");
}

22. Zastosowanie Wzorców w Blokach catch (C# 9.0 i nowsze):

• W nowszych wersjach C# możesz korzystać z wzorców w blokach catch do bardziej zaawansowanego dopasowywania do typów wyjątków.

try
{
    // Kod, który może zgłosić wyjątek
}
catch (Exception ex) when (ex is IOException ioException && ioException.Message.Contains("plik"))
{
    // Obsługa błędów IO związanych z plikiem
    Console.WriteLine($"Błąd IO związany z plikiem: {ex.Message}");
}
catch (Exception ex)
{
    // Obsługa innych wyjątków
    Console.WriteLine($"Inny błąd: {ex.Message}");
}

23. Uwzględnienie Kontekstu Błędu:

• W logach błędów staraj się uwzględnić odpowiedni kontekst, takie jak wartości zmiennych czy informacje o stanie aplikacji.

try
{
    // Kod, który może zgłosić wyjątek
}
catch (Exception ex)
{
    // Logowanie błędu z uwzględnieniem kontekstu
    _logger.LogError(ex, $"Wystąpił błąd w metodzie {nameof(Metoda)}. Zmienna x = {x}");
}

24. Logowanie Kontekstu Przed Błędem:

• Przed zgłoszeniem błędu zapisz logi związane z kontekstem działania programu. To ułatwi diagnozowanie błędów w późniejszym czasie.

try
{
    // Kod, który może zgłosić wyjątek
}
catch (Exception ex)
{
    // Logowanie kontekstu przed błędem
    LogContextInfo();

    // Logowanie błędu
    _logger.LogError(ex, "Wystąpił błąd.");
}

25. Uwzględnienie Usterek w Kodzie:

• W przypadku niektórych rodzajów błędów, szczególnie tych, które mogą być trudne do zdiagnozowania, rozważ umieszczanie w kodzie tzw. “usterek” (asserts), które sprawdzają pewne warunki i zgłaszają błąd, jeśli warunek nie jest spełniony.

Debug.Assert(x > 0, "Wartość x musi być większa od zera.");

26. Używanie Debug.Assert podczas Rozwoju:

• W trakcie rozwoju możesz używać Debug.Assert do wprowadzania asercji, które pomogą zidentyfikować błędy w fazie developmentu.

Debug.Assert(warunek, "To jest wiadomość błędu wyświetlana podczas debugowania.");

27. Współpraca z Zespołem ds. Operacji (DevOps):

• W projekcie zaangażowanym w praktyki DevOps, dostarczaj informacje zwrotne o błędach do systemu monitorowania i logowania, aby zespół ds. operacji mógł szybko zareagować na ewentualne problemy.

28. Używanie Kodeków Bezpieczeństwa (Security Code Analysis):

• Korzystaj z narzędzi analizy kodu pod kątem bezpieczeństwa, aby wykrywać potencjalne luki w zabezpieczeniach.

29. Testy Fuzzingowe:

• Wprowadzaj testy fuzzingowe, które generują przypadkowe dane wejściowe, aby sprawdzić, czy aplikacja obsługuje je poprawnie i bezpiecznie.

30. Kontrola Wydajności:

• Przy obsłudze błędów, zwłaszcza w często wywoływanych fragmentach kodu, zwracaj uwagę na wydajność. Unikaj ciężkich operacji w blokach catch.

Warto podkreślić, że obsługa błędów w dużej mierze zależy od specyfiki projektu i jego wymagań. Dostosuj praktyki obsługi błędów do kontekstu swojej aplikacji, a także bierz pod uwagę przyszłe potrzeby rozwoju i utrzymania systemu.

Podsumowanie:

• Skoncentruj się na czytelnym i zrozumiałym kodzie, który jasno definiuje, jak obsługiwać błędy.
• Loguj błędy, aby ułatwić diagnozę problemów w środowisku produkcyjnym.
• Staraj się unikać zbyt obszernych bloków catch, aby uniknąć ukrywania błędów.
• Używaj instrukcji using dla zasobów, aby zapewnić, że zostaną one poprawnie zwolnione, nawet w przypadku błędu.

Obsługa błędów jest nieodłączną częścią procesu programowania, a dobre praktyki w tym zakresie pomagają utrzymać wysoką jakość kodu i skrócić czas diagnozowania i naprawiania problemów.