Sdílet prostřednictvím

Zpracování výjimek (Průvodce programováním v C#)

Programátoři jazyka C# používají blok try k dělení kódu, který může být ovlivněn výjimkou. Přidružené bloky catch se používají ke zpracování všech výsledných výjimek. Blok finally obsahuje kód, který se spustí bez ohledu na to, zda je v try bloku vyvolána výjimka, například pro uvolnění prostředků, které byly přiděleny v try bloku. Blok try vyžaduje jeden nebo více přidružených catch bloků, finally blok nebo obojí.

Následující příklady ukazují try-catch příkaz, try-finally příkaz a try-catch-finally příkaz.

try
{
    // Code to try goes here.
}
catch (SomeSpecificException ex)
{
    // Code to handle the exception goes here.
    // Only catch exceptions that you know how to handle.
    // Never catch base class System.Exception without
    // rethrowing it at the end of the catch block.
}

try
{
    // Code to try goes here.
}
finally
{
    // Code to execute after the try block goes here.
}

try
{
    // Code to try goes here.
}
catch (SomeSpecificException ex)
{
    // Code to handle the exception goes here.
}
finally
{
    // Code to execute after the try (and possibly catch) blocks
    // goes here.
}

Blok try bez bloku catch nebo finally způsobí chybu kompilátoru.

Zachytávání bloků

catch Blok může určit typ výjimky, která se má zachytit. Specifikace typu se nazývá filtr výjimek. Typ výjimky by měl být odvozen z Exception. Obecně platí, že jako filtr výjimek nezadávejte Exception , pokud nevíte, jak zpracovat všechny výjimky, které by mohly být vyvolány v try bloku, nebo jste zahrnuli throw příkaz na konec catch bloku.

Více catch bloků s různými třídami výjimek lze zřetězit dohromady. Bloky catch se v kódu vyhodnocují shora dolů, ale pro každou výjimku, která je vyvoláná, se provede pouze jeden catch blok. Spustí se první catch blok, který určuje přesný typ nebo základní třídu vyvolané výjimky. Pokud žádný catch blok neurčí odpovídající třídu výjimky, je vybrán některý catch blok, který nemá žádný typ, pokud je přítomen v příkazu. Nejprve je důležité umístit catch bloky s nejkonkrétnějšími (tj. nejodvozenějšími) třídami výjimek.

Zachyťte výjimky, pokud jsou splněny následující podmínky:

  • Máte dobrý přehled o tom, proč může být vyvolán výjimka, a můžete implementovat konkrétní obnovení, například vyzvat uživatele k zadání nového názvu souboru při zachycení objektu FileNotFoundException .
  • Můžete vytvořit a vyvolat novou, konkrétnější výjimku.
    int GetInt(int[] array, int index)
{
    try
    {
        return array[index];
    }
    catch (IndexOutOfRangeException e)
    {
        throw new ArgumentOutOfRangeException(
            "Parameter index is out of range.", e);
    }
}
  • Chcete částečně zpracovat výjimku, než ji předáte pro další zpracování. V následujícím příkladu se blok catch používá k přidání položky do protokolu chyb před opětovným vyvoláním výjimky.
    try
{
    // Try to access a resource.
}
catch (UnauthorizedAccessException e)
{
    // Call a custom error logging procedure.
    LogError(e);
    // Re-throw the error.
    throw;
}

Můžete také zadat filtry výjimek pro přidání logického výrazu do klauzule catch. Filtry výjimek označují, že konkrétní klauzule catch odpovídá pouze tehdy, když je tato podmínka pravdivá. V následujícím příkladu obě klauzule catch používají stejnou třídu výjimek, ale je zaškrtnutá další podmínka pro vytvoření jiné chybové zprávy:

int GetInt(int[] array, int index)
{
    try
    {
        return array[index];
    }
    catch (IndexOutOfRangeException e) when (index < 0) 
    {
        throw new ArgumentOutOfRangeException(
            "Parameter index cannot be negative.", e);
    }
    catch (IndexOutOfRangeException e)
    {
        throw new ArgumentOutOfRangeException(
            "Parameter index cannot be greater than the array size.", e);
    }
}

Filtr výjimek, který vždy vrací false , lze použít k prozkoumání všech výjimek, ale ne ke zpracování. Typickým použitím je protokolování výjimek:

public class ExceptionFilter
{
    public static void Main()
    {
        try
        {
            string? s = null;
            Console.WriteLine(s.Length);
        }
        catch (Exception e) when (LogException(e))
        {
        }
        Console.WriteLine("Exception must have been handled");
    }

    private static bool LogException(Exception e)
    {
        Console.WriteLine($"\tIn the log routine. Caught {e.GetType()}");
        Console.WriteLine($"\tMessage: {e.Message}");
        return false;
    }
}

Metoda LogException vždy vrátí false, žádná klauzule catch, která používá tento filtr výjimek, neodpovídá. Klauzule catch může být obecná, používající System.Exception, a další bloky mohou zpracovávat konkrétnější třídy výjimek.

Konečné bloky

Blok finally umožňuje vyčistit akce prováděné v try bloku. Pokud je přítomen, blok finally se spustí jako poslední, po bloku try a po všech odpovídajících blocích catch. finally Blok se vždy spustí, ať už je vyvolán výjimka, nebo catch blok odpovídající typu výjimky.

Blok finally lze použít k uvolnění prostředků, jako jsou streamy souborů, připojení k databázi a grafické popisovače, aniž byste čekali na uvolnění paměti v modulu runtime k dokončení objektů.

V následujícím příkladu finally se blok používá k zavření souboru, který je otevřen v try bloku. Všimněte si, že stav popisovače souboru je zkontrolován před zavřením souboru. try Pokud blok nemůže soubor otevřít, má popisovač souboru stále hodnotu null a finally blok se ho nepokouší zavřít. Místo toho, pokud je soubor úspěšně otevřen v try bloku, finally blok zavře otevřený soubor.

FileStream? file = null;
FileInfo fileinfo = new System.IO.FileInfo("./file.txt");
try
{
    file = fileinfo.OpenWrite();
    file.WriteByte(0xF);
}
finally
{
    // Check for null because OpenWrite might have failed.
    file?.Close();
}

Specifikace jazyka C#

Další informace naleznete v tématu Výjimky a příkaz try ve specifikaci jazyka C#. Specifikace jazyka je konečným zdrojem syntaxe a použití jazyka C#.

Viz také

  • Last updated on