System.Exception – třída
Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.
Třída Exception je základní třídou pro všechny výjimky. Pokud dojde k chybě, systém nebo aktuálně spuštěná aplikace ho hlásí vyvoláním výjimky, která obsahuje informace o chybě. Po vyvolání výjimky ji zpracuje aplikace nebo výchozí obslužná rutina výjimky.
Chyby a výjimky
K chybám za běhu může dojít z různých důvodů. Ne všechny chyby by se ale měly zpracovávat jako výjimky v kódu. Tady jsou některé kategorie chyb, ke kterým může dojít za běhu, a vhodné způsoby reakce na ně.
Chyby použití Chyba použití představuje chybu v logikě programu, která může vést k výjimce. Tato chyba by ale neměla být vyřešena prostřednictvím zpracování výjimek, ale úpravou chybného kódu. Například přepsání Object.Equals(Object) metody v následujícím příkladu předpokládá, že
objargument musí být vždy nenulový.using System; public class Person1 { private string _name; public string Name { get { return _name; } set { _name = value; } } public override int GetHashCode() { return this.Name.GetHashCode(); } public override bool Equals(object obj) { // This implementation contains an error in program logic: // It assumes that the obj argument is not null. Person1 p = (Person1) obj; return this.Name.Equals(p.Name); } } public class UsageErrorsEx1 { public static void Main() { Person1 p1 = new Person1(); p1.Name = "John"; Person1 p2 = null; // The following throws a NullReferenceException. Console.WriteLine("p1 = p2: {0}", p1.Equals(p2)); } }// In F#, null is not a valid state for declared types // without 'AllowNullLiteralAttribute' [<AllowNullLiteral>] type Person() = member val Name = "" with get, set override this.GetHashCode() = this.Name.GetHashCode() override this.Equals(obj) = // This implementation contains an error in program logic: // It assumes that the obj argument is not null. let p = obj :?> Person this.Name.Equals p.Name let p1 = Person() p1.Name <- "John" let p2: Person = null // The following throws a NullReferenceException. printfn $"p1 = p2: {p1.Equals p2}"Public Class Person Private _name As String Public Property Name As String Get Return _name End Get Set _name = value End Set End Property Public Overrides Function Equals(obj As Object) As Boolean ' This implementation contains an error in program logic: ' It assumes that the obj argument is not null. Dim p As Person = CType(obj, Person) Return Me.Name.Equals(p.Name) End Function End Class Module Example2 Public Sub Main() Dim p1 As New Person() p1.Name = "John" Dim p2 As Person = Nothing ' The following throws a NullReferenceException. Console.WriteLine("p1 = p2: {0}", p1.Equals(p2)) End Sub End ModuleVýjimka NullReferenceException , kdy
objje možné odstranit,nullúpravou zdrojového kódu explicitně testovat hodnotu null před voláním Object.Equals přepsání a následným opětovným kompilací. Následující příklad obsahuje opravený zdrojový kód, který zpracovávánullargument.using System; public class Person2 { private string _name; public string Name { get { return _name; } set { _name = value; } } public override int GetHashCode() { return this.Name.GetHashCode(); } public override bool Equals(object obj) { // This implementation handles a null obj argument. Person2 p = obj as Person2; if (p == null) return false; else return this.Name.Equals(p.Name); } } public class UsageErrorsEx2 { public static void Main() { Person2 p1 = new Person2(); p1.Name = "John"; Person2 p2 = null; Console.WriteLine("p1 = p2: {0}", p1.Equals(p2)); } } // The example displays the following output: // p1 = p2: False// In F#, null is not a valid state for declared types // without 'AllowNullLiteralAttribute' [<AllowNullLiteral>] type Person() = member val Name = "" with get, set override this.GetHashCode() = this.Name.GetHashCode() override this.Equals(obj) = // This implementation handles a null obj argument. match obj with | :? Person as p -> this.Name.Equals p.Name | _ -> false let p1 = Person() p1.Name <- "John" let p2: Person = null printfn $"p1 = p2: {p1.Equals p2}" // The example displays the following output: // p1 = p2: FalsePublic Class Person2 Private _name As String Public Property Name As String Get Return _name End Get Set _name = Value End Set End Property Public Overrides Function Equals(obj As Object) As Boolean ' This implementation handles a null obj argument. Dim p As Person2 = TryCast(obj, Person2) If p Is Nothing Then Return False Else Return Me.Name.Equals(p.Name) End If End Function End Class Module Example3 Public Sub Main() Dim p1 As New Person2() p1.Name = "John" Dim p2 As Person2 = Nothing Console.WriteLine("p1 = p2: {0}", p1.Equals(p2)) End Sub End Module ' The example displays the following output: ' p1 = p2: FalseMísto použití zpracování výjimek pro chyby použití můžete použít metodu Debug.Assert k identifikaci chyb využití v ladicích buildech a metodu Trace.Assert k identifikaci chyb použití v sestaveních ladění i vydaných verzí. Další informace naleznete v tématu Kontrolní výrazy ve spravovaném kódu.
Chyby programu. Chyba programu je chyba za běhu, které se nemusí nutně vyhnout napsáním kódu bez chyby.
V některých případech může chyba programu odrážet očekávaný nebo rutinní chybový stav. V takovém případě můžete chtít zabránit použití zpracování výjimek k řešení chyby programu a místo toho operaci zopakovat. Pokud se například očekává, že uživatel zadá datum v určitém formátu, můžete analyzovat řetězec kalendářního data voláním DateTime.TryParseExact metody, která vrátí Boolean hodnotu, která určuje, zda byla operace analýzy úspěšná, místo použití DateTime.ParseExact metody, která vyvolá FormatException výjimku, pokud řetězec data nelze převést na DateTime hodnotu. Podobně pokud se uživatel pokusí otevřít soubor, který neexistuje, můžete nejprve volat metodu File.Exists , abyste zkontrolovali, jestli soubor existuje, a pokud ne, vyzve uživatele, zda ho chce vytvořit.
V jiných případech chyba programu odráží neočekávaný chybový stav, který je možné zpracovat v kódu. I když jste například zkontrolovali, že soubor existuje, může být před otevřením odstraněn nebo poškozen. V takovém případě se pokus o otevření souboru vytvořením instance StreamReader objektu nebo voláním Open metody může vyvolat FileNotFoundException výjimku. V těchto případech byste měli k zotavení z chyby použít zpracování výjimek.
Selhání systému. Selhání systému je chyba za běhu, kterou nelze zpracovat programově smysluplným způsobem. Jakákoli metoda může například vyvolat OutOfMemoryException výjimku, pokud modul CLR (Common Language Runtime) nemůže přidělit další paměť. Obvykle se selhání systému nezpracují pomocí zpracování výjimek. Místo toho můžete použít událost, jako AppDomain.UnhandledException je například volání Environment.FailFast metody pro protokolování informací o výjimce, a upozornit uživatele na selhání před ukončením aplikace.
Bloky try/catch
Modul CLR (Common Language Runtime) poskytuje model zpracování výjimek založený na reprezentaci výjimek jako objektů a oddělení kódu programu a zpracování výjimek na try bloky a catch bloky. Může existovat jeden nebo více catch bloků, každý navržený pro zpracování určitého typu výjimky nebo jeden blok navržený tak, aby zachytil konkrétnější výjimku než jiný blok.
Pokud aplikace zpracovává výjimky, ke kterým dochází při provádění bloku kódu aplikace, musí být kód umístěn do try příkazu a nazývá se try blok. Kód aplikace, který zpracovává výjimky vyvolané blokem try , se umístí do catch příkazu a nazývá se catch blok. Bloky jsou přidružené try k bloku nula nebo více catch a každý catch blok obsahuje filtr typu, který určuje typy výjimek, které zpracovává.
Když dojde k výjimce try v bloku, systém prohledá přidružené catch bloky v pořadí, v jakém se zobrazí v kódu aplikace, dokud nenajde catch blok, který zpracovává výjimku. Blok catch zpracovává výjimku typu, pokud filtr typu T bloku catch určuje T nebo jakýkoli typ odvozený T . Systém přestane hledat, jakmile najde první catch blok, který zpracovává výjimku. Z tohoto důvodu musí být v kódu aplikace zadán blok, catch který zpracovává typ, před catch blokem, který zpracovává jeho základní typy, jak je znázorněno v příkladu, který následuje za touto částí. Blok catch, který zpracovává System.Exception , je zadán jako poslední.
Pokud žádný z catch bloků přidružených k aktuálnímu try bloku zpracovává výjimku a aktuální try blok je vnořený do jiných try bloků v aktuálním volání, catch bloky přidružené k dalšímu uzavřenému try bloku se prohledávají. Pokud se nenajde žádný catch blok výjimky, systém prohledá předchozí úrovně vnoření v aktuálním volání. Pokud se v aktuálním volání nenajde žádný catch blok výjimky, předá se výjimka zásobníku volání a předchozí rámec zásobníku vyhledá catch blok, který výjimku zpracuje. Hledání zásobníku volání pokračuje, dokud se nezpracuje výjimka nebo dokud v zásobníku volání neexistují žádné další rámce. Pokud je dosaženo horní části zásobníku volání bez nalezení catch bloku, který zpracovává výjimku, výchozí obslužná rutina výjimky ji zpracuje a aplikace se ukončí.
F# try.. with expression
Jazyk F# nepoužívá catch bloky. Místo toho je vyvolána výjimka, která se shoduje s jedním with blokem. Vzhledem k tomu, že se jedná o výraz, nikoli příkaz, musí všechny cesty vrátit stejný typ. Další informace najdete v tématu Vyzkoušení... s výrazem.
Funkce typu výjimky
Typy výjimek podporují následující funkce:
Čitelný text, který popisuje chybu. Pokud dojde k výjimce, modul runtime zpřístupní textovou zprávu, která uživatele informuje o povaze chyby a navrhne akci k vyřešení problému. Tato textová zpráva je uložena Message ve vlastnosti objektu výjimky. Při vytváření objektu výjimky můžete předat konstruktoru textový řetězec, který popisuje podrobnosti o této konkrétní výjimce. Pokud konstruktoru není zadán žádný argument chybové zprávy, použije se výchozí chybová zpráva. Další informace najdete v Message této vlastnosti.
Stav zásobníku volání při vyvolání výjimky. Vlastnost StackTrace nese trasování zásobníku, které lze použít k určení místa výskytu chyby v kódu. Trasování zásobníku obsahuje seznam všech volaných metod a čísel řádků ve zdrojovém souboru, kde jsou volání provedena.
Vlastnosti třídy výjimky
Třída Exception obsahuje řadu vlastností, které pomáhají identifikovat umístění kódu, typ, soubor nápovědy a důvod výjimky: StackTrace, , MessageInnerException, HelpLink, HResult, , SourceTargetSitea Data. .
Pokud existuje kauzální vztah mezi dvěma nebo více výjimkami, InnerException vlastnost udržuje tyto informace. Vnější výjimka je vyvolán v reakci na tuto vnitřní výjimku. Kód, který zpracovává vnější výjimku, může k vhodnějšímu zpracování chyby použít informace z předchozí vnitřní výjimky. Doplňkové informace o výjimce lze uložit jako kolekci párů klíč/hodnota ve Data vlastnosti.
Řetězec chybové zprávy předaný konstruktoru během vytváření objektu výjimky by měl být lokalizován a lze jej zadat ze souboru prostředků pomocí ResourceManager třídy. Další informace o lokalizovaných prostředcích naleznete v tématech Vytváření satelitních sestavení a balení a nasazování prostředků .
Pokud chcete uživateli poskytnout rozsáhlé informace o tom, proč k výjimce došlo, HelpLink může vlastnost obsahovat adresu URL (nebo URN) do souboru nápovědy.
Třída Exception používá HRESULT COR_E_EXCEPTION, který má hodnotu 0x80131500.
Seznam počátečních hodnot vlastností pro instanci Exception třídy naleznete v Exception konstruktorech.
Důležité informace o výkonu
Vyvolání nebo zpracování výjimky spotřebovává značné množství systémových prostředků a doby provádění. Vyvolání výjimek pouze pro zvládnutí skutečně mimořádné podmínky, nikoli zpracování předvídatelných událostí nebo řízení toku. Například v některých případech, například při vývoji knihovny tříd, je vhodné vyvolat výjimku, pokud je argument metody neplatný, protože očekáváte, že vaše metoda bude volána s platnými parametry. Neplatný argument metody, pokud není výsledkem chyby použití, znamená, že došlo k něčemu mimořádnému. Naopak nevyvolejte výjimku, pokud je vstup uživatele neplatný, protože můžete očekávat, že uživatelé budou občas zadávat neplatná data. Místo toho zadejte mechanismus opakování, aby uživatelé mohli zadat platný vstup. K řešení chyb využití byste neměli používat výjimky. Místo toho pomocí kontrolních výrazů identifikujte a opravte chyby použití.
Kromě toho nevyvolejte výjimku, pokud je dostatečný návratový kód; nepřeveďte návratový kód na výjimku; a nezachyťte výjimku, ignorujte ji a pokračujte ve zpracování.
Opětovné vyvolání výjimky
V mnoha případech obslužná rutina výjimky jednoduše chce předat výjimku volajícímu. Nejčastěji k tomu dochází v těchto situacích:
Knihovna tříd, která zase zabalí volání metod v knihovně tříd .NET nebo jiných knihovnách tříd.
Aplikace nebo knihovna, u které dochází k závažné výjimce. Obslužná rutina výjimky může tuto výjimku protokolovat a pak znovu vyvolat výjimku.
Doporučeným způsobem opětovného vyvolání výjimky je jednoduše použít příkaz throw v jazyce C#, funkci reraise v jazyce F# a příkaz Throw v jazyce Visual Basic bez zahrnutí výrazu. Tím se zajistí, že se při šíření výjimky do volajícího zachovají všechny informace o zásobníku volání. Toto dokládá následující příklad. Metoda FindOccurrencesrozšíření řetězce , zabalí jedno nebo více volání String.IndexOf(String, Int32) bez ověření argumentů předem.
using System;
using System.Collections.Generic;
public static class Library1
{
public static int[] FindOccurrences(this String s, String f)
{
var indexes = new List<int>();
int currentIndex = 0;
try
{
while (currentIndex >= 0 && currentIndex < s.Length)
{
currentIndex = s.IndexOf(f, currentIndex);
if (currentIndex >= 0)
{
indexes.Add(currentIndex);
currentIndex++;
}
}
}
catch (ArgumentNullException)
{
// Perform some action here, such as logging this exception.
throw;
}
return indexes.ToArray();
}
}
open System
module Library =
let findOccurrences (s: string) (f: string) =
let indexes = ResizeArray()
let mutable currentIndex = 0
try
while currentIndex >= 0 && currentIndex < s.Length do
currentIndex <- s.IndexOf(f, currentIndex)
if currentIndex >= 0 then
indexes.Add currentIndex
currentIndex <- currentIndex + 1
with :? ArgumentNullException ->
// Perform some action here, such as logging this exception.
reraise ()
indexes.ToArray()
Imports System.Collections.Generic
Imports System.Runtime.CompilerServices
Public Module Library
<Extension()>
Public Function FindOccurrences1(s As String, f As String) As Integer()
Dim indexes As New List(Of Integer)
Dim currentIndex As Integer = 0
Try
Do While currentIndex >= 0 And currentIndex < s.Length
currentIndex = s.IndexOf(f, currentIndex)
If currentIndex >= 0 Then
indexes.Add(currentIndex)
currentIndex += 1
End If
Loop
Catch e As ArgumentNullException
' Perform some action here, such as logging this exception.
Throw
End Try
Return indexes.ToArray()
End Function
End Module
Volající pak volá FindOccurrences dvakrát. Ve druhém volání FindOccurrencesvolající předá null jako hledaný řetězec, což způsobí String.IndexOf(String, Int32) , že metoda vyvolá ArgumentNullException výjimku. Tato výjimka je zpracována metodou FindOccurrences a předána zpět volajícímu. Protože příkaz throw se používá bez výrazu, výstup z příkladu ukazuje, že zásobník volání je zachován.
public class RethrowEx1
{
public static void Main()
{
String s = "It was a cold day when...";
int[] indexes = s.FindOccurrences("a");
ShowOccurrences(s, "a", indexes);
Console.WriteLine();
String toFind = null;
try
{
indexes = s.FindOccurrences(toFind);
ShowOccurrences(s, toFind, indexes);
}
catch (ArgumentNullException e)
{
Console.WriteLine("An exception ({0}) occurred.",
e.GetType().Name);
Console.WriteLine("Message:\n {0}\n", e.Message);
Console.WriteLine("Stack Trace:\n {0}\n", e.StackTrace);
}
}
private static void ShowOccurrences(String s, String toFind, int[] indexes)
{
Console.Write("'{0}' occurs at the following character positions: ",
toFind);
for (int ctr = 0; ctr < indexes.Length; ctr++)
Console.Write("{0}{1}", indexes[ctr],
ctr == indexes.Length - 1 ? "" : ", ");
Console.WriteLine();
}
}
// The example displays the following output:
// 'a' occurs at the following character positions: 4, 7, 15
//
// An exception (ArgumentNullException) occurred.
// Message:
// Value cannot be null.
// Parameter name: value
//
// Stack Trace:
// at System.String.IndexOf(String value, Int32 startIndex, Int32 count, Stri
// ngComparison comparisonType)
// at Library.FindOccurrences(String s, String f)
// at Example.Main()
open Library
let showOccurrences toFind (indexes: int[]) =
printf $"'{toFind}' occurs at the following character positions: "
for i = 0 to indexes.Length - 1 do
printf $"""{indexes[i]}{if i = indexes.Length - 1 then "" else ", "}"""
printfn ""
let s = "It was a cold day when..."
let indexes = findOccurrences s "a"
showOccurrences "a" indexes
printfn ""
let toFind: string = null
try
let indexes = findOccurrences s toFind
showOccurrences toFind indexes
with :? ArgumentNullException as e ->
printfn $"An exception ({e.GetType().Name}) occurred."
printfn $"Message:\n {e.Message}\n"
printfn $"Stack Trace:\n {e.StackTrace}\n"
// The example displays the following output:
// 'a' occurs at the following character positions: 4, 7, 15
//
// An exception (ArgumentNullException) occurred.
// Message:
// Value cannot be null. (Parameter 'value')
//
// Stack Trace:
// at System.String.IndexOf(String value, Int32 startIndex, Int32 count, Stri
// ngComparison comparisonType)
// at Library.findOccurrences(String s, String f)
// at <StartupCode$fs>.main@()
Module Example1
Public Sub Main()
Dim s As String = "It was a cold day when..."
Dim indexes() As Integer = s.FindOccurrences1("a")
ShowOccurrences(s, "a", indexes)
Console.WriteLine()
Dim toFind As String = Nothing
Try
indexes = s.FindOccurrences1(toFind)
ShowOccurrences(s, toFind, indexes)
Catch e As ArgumentNullException
Console.WriteLine("An exception ({0}) occurred.",
e.GetType().Name)
Console.WriteLine("Message:{0} {1}{0}", vbCrLf, e.Message)
Console.WriteLine("Stack Trace:{0} {1}{0}", vbCrLf, e.StackTrace)
End Try
End Sub
Private Sub ShowOccurrences(s As String, toFind As String, indexes As Integer())
Console.Write("'{0}' occurs at the following character positions: ",
toFind)
For ctr As Integer = 0 To indexes.Length - 1
Console.Write("{0}{1}", indexes(ctr),
If(ctr = indexes.Length - 1, "", ", "))
Next
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' 'a' occurs at the following character positions: 4, 7, 15
'
' An exception (ArgumentNullException) occurred.
' Message:
' Value cannot be null.
' Parameter name: value
'
' Stack Trace:
' at System.String.IndexOf(String value, Int32 startIndex, Int32 count, Stri
' ngComparison comparisonType)
' at Library.FindOccurrences(String s, String f)
' at Example.Main()
Naproti tomu pokud je výjimka znovu vyvolán pomocí tohoto příkazu:
throw e;
Throw e
raise e
... pak se celý zásobník volání nezachová a v příkladu by se vygeneroval následující výstup:
'a' occurs at the following character positions: 4, 7, 15
An exception (ArgumentNullException) occurred.
Message:
Value cannot be null.
Parameter name: value
Stack Trace:
at Library.FindOccurrences(String s, String f)
at Example.Main()
Trochu složitější alternativou je vyvolání nové výjimky a zachování informací o zásobníku volání původní výjimky ve vnitřní výjimce. Volající pak může pomocí vlastnosti nové výjimky InnerException načíst rámec zásobníku a další informace o původní výjimce. V tomto případě je příkaz throw:
throw new ArgumentNullException("You must supply a search string.", e);
raise (ArgumentNullException("You must supply a search string.", e) )
Throw New ArgumentNullException("You must supply a search string.",
e)
Uživatelský kód, který zpracovává výjimku, musí vědět, že InnerException vlastnost obsahuje informace o původní výjimce, jak ukazuje následující obslužná rutina výjimky.
try
{
indexes = s.FindOccurrences(toFind);
ShowOccurrences(s, toFind, indexes);
}
catch (ArgumentNullException e)
{
Console.WriteLine("An exception ({0}) occurred.",
e.GetType().Name);
Console.WriteLine(" Message:\n{0}", e.Message);
Console.WriteLine(" Stack Trace:\n {0}", e.StackTrace);
Exception ie = e.InnerException;
if (ie != null)
{
Console.WriteLine(" The Inner Exception:");
Console.WriteLine(" Exception Name: {0}", ie.GetType().Name);
Console.WriteLine(" Message: {0}\n", ie.Message);
Console.WriteLine(" Stack Trace:\n {0}\n", ie.StackTrace);
}
}
// The example displays the following output:
// 'a' occurs at the following character positions: 4, 7, 15
//
// An exception (ArgumentNullException) occurred.
// Message: You must supply a search string.
//
// Stack Trace:
// at Library.FindOccurrences(String s, String f)
// at Example.Main()
//
// The Inner Exception:
// Exception Name: ArgumentNullException
// Message: Value cannot be null.
// Parameter name: value
//
// Stack Trace:
// at System.String.IndexOf(String value, Int32 startIndex, Int32 count, Stri
// ngComparison comparisonType)
// at Library.FindOccurrences(String s, String f)
try
let indexes = findOccurrences s toFind
showOccurrences toFind indexes
with :? ArgumentNullException as e ->
printfn $"An exception ({e.GetType().Name}) occurred."
printfn $" Message:\n{e.Message}"
printfn $" Stack Trace:\n {e.StackTrace}"
let ie = e.InnerException
if ie <> null then
printfn " The Inner Exception:"
printfn $" Exception Name: {ie.GetType().Name}"
printfn $" Message: {ie.Message}\n"
printfn $" Stack Trace:\n {ie.StackTrace}\n"
// The example displays the following output:
// 'a' occurs at the following character positions: 4, 7, 15
//
// An exception (ArgumentNullException) occurred.
// Message: You must supply a search string.
//
// Stack Trace:
// at Library.FindOccurrences(String s, String f)
// at Example.Main()
//
// The Inner Exception:
// Exception Name: ArgumentNullException
// Message: Value cannot be null.
// Parameter name: value
//
// Stack Trace:
// at System.String.IndexOf(String value, Int32 startIndex, Int32 count, Stri
// ngComparison comparisonType)
// at Library.FindOccurrences(String s, String f)
Try
indexes = s.FindOccurrences(toFind)
ShowOccurrences(s, toFind, indexes)
Catch e As ArgumentNullException
Console.WriteLine("An exception ({0}) occurred.",
e.GetType().Name)
Console.WriteLine(" Message: {1}{0}", vbCrLf, e.Message)
Console.WriteLine(" Stack Trace:{0} {1}{0}", vbCrLf, e.StackTrace)
Dim ie As Exception = e.InnerException
If ie IsNot Nothing Then
Console.WriteLine(" The Inner Exception:")
Console.WriteLine(" Exception Name: {0}", ie.GetType().Name)
Console.WriteLine(" Message: {1}{0}", vbCrLf, ie.Message)
Console.WriteLine(" Stack Trace:{0} {1}{0}", vbCrLf, ie.StackTrace)
End If
End Try
' The example displays the following output:
' 'a' occurs at the following character positions: 4, 7, 15
'
' An exception (ArgumentNullException) occurred.
' Message: You must supply a search string.
'
' Stack Trace:
' at Library.FindOccurrences(String s, String f)
' at Example.Main()
'
' The Inner Exception:
' Exception Name: ArgumentNullException
' Message: Value cannot be null.
' Parameter name: value
'
' Stack Trace:
' at System.String.IndexOf(String value, Int32 startIndex, Int32 count, Stri
' ngComparison comparisonType)
' at Library.FindOccurrences(String s, String f)
Volba standardních výjimek
Pokud potřebujete vyvolat výjimku, můžete často místo implementace vlastní výjimky použít existující typ výjimky v .NET. Za těchto dvou podmínek byste měli použít standardní typ výjimky:
Vyvoláte výjimku, která je způsobena chybou použití (to znamená chybou v programové logice, kterou vytvořil vývojář, který volá vaši metodu). Obvykle byste vyvolali výjimku, například ArgumentException, ArgumentNullException, InvalidOperationExceptionnebo NotSupportedException. Řetězec, který zadáte konstruktoru objektu výjimky při vytvoření instance objektu výjimky, by měl popsat chybu, aby ji vývojář mohl opravit. Další informace najdete v Message této vlastnosti.
Zpracováváte chybu, která se dá volajícímu sdělit s existující výjimkou .NET. Měli byste vyvolat nejvýraznější možnou výjimku. Pokud například metoda vyžaduje, aby argument byl platným členem typu výčtu, měli InvalidEnumArgumentException byste vyvolat (nejvíce odvozenou třídu) místo ArgumentException.
Následující tabulka uvádí běžné typy výjimek a podmínky, za kterých byste je vyvolali.
| Výjimka | Podmínka |
|---|---|
| ArgumentException | Argument, který není null předaný metodě, je neplatný. |
| ArgumentNullException | Argument, který je předán metodě je null. |
| ArgumentOutOfRangeException | Argument je mimo rozsah platných hodnot. |
| DirectoryNotFoundException | Část cesty k adresáři není platná. |
| DivideByZeroException | Jmenovatel v celočíselné operaci nebo Decimal operaci dělení je nula. |
| DriveNotFoundException | Jednotka není k dispozici nebo neexistuje. |
| FileNotFoundException | Soubor neexistuje. |
| FormatException | Hodnota není v odpovídajícím formátu, který má být převeden z řetězce metodou převodu, například Parse. |
| IndexOutOfRangeException | Index je mimo hranice pole nebo kolekce. |
| InvalidOperationException | Volání metody je neplatné v aktuálním stavu objektu. |
| KeyNotFoundException | Zadaný klíč pro přístup k členu v kolekci nebyl nalezen. |
| NotImplementedException | Metoda nebo operace se neimplementuje. |
| NotSupportedException | Metoda nebo operace se nepodporuje. |
| ObjectDisposedException | Operace se provádí u objektu, který byl odstraněn. |
| OverflowException | Výsledkem aritmetické operace, přetypování nebo převodu je přetečení. |
| PathTooLongException | Cesta nebo název souboru překračuje maximální délku definovanou systémem. |
| PlatformNotSupportedException | Operace není na aktuální platformě podporovaná. |
| RankException | Do metody se předá pole s nesprávným počtem dimenzí. |
| TimeoutException | Vypršel časový interval přidělený operaci. |
| UriFormatException | Použije se neplatný identifikátor URI (Uniform Resource Identifier). |
Implementace vlastních výjimek
V následujících případech není použití existující výjimky .NET pro zpracování chybového stavu adekvátní:
Pokud výjimka odráží jedinečnou chybu programu, která nelze namapovat na existující výjimku .NET.
Pokud výjimka vyžaduje zpracování, které se liší od zpracování, které je vhodné pro existující výjimku .NET, nebo musí být výjimka z podobné výjimky nejednoznačná. Pokud například vyvoláte ArgumentOutOfRangeException výjimku při analýze číselné reprezentace řetězce, který je mimo rozsah cílového celočíselného typu, nechcete použít stejnou výjimku pro chybu, která má za následek, že volající při volání metody nezadá odpovídající omezené hodnoty.
Třída Exception je základní třídou všech výjimek v .NET. Mnoho odvozených tříd spoléhá na zděděné chování členů Exception třídy; nepřepíše členy Exception, ani nedefinují žádné jedinečné členy.
Definování vlastní třídy výjimek:
Definujte třídu, která dědí z Exception. V případě potřeby definujte všechny jedinečné členy, které vaše třída potřebuje k poskytnutí dalších informací o výjimce. Třída například ArgumentException obsahuje ParamName vlastnost, která určuje název parametru, jehož argument způsobil výjimku, a RegexMatchTimeoutException vlastnost obsahuje MatchTimeout vlastnost, která označuje interval časového limitu.
V případě potřeby přepište všechny zděděné členy, jejichž funkce chcete změnit nebo upravit. Všimněte si, že většina existujících odvozených Exception tříd nepřepíše chování zděděných členů.
Určete, zda je objekt vlastní výjimky serializovatelný. Serializace umožňuje ukládat informace o výjimce a umožňuje sdílení informací o výjimce serverem a proxy klientem v kontextu vzdálené komunikace. Chcete-li objekt výjimky serializovat, označte jej atributem SerializableAttribute .
Definujte konstruktory vaší třídy výjimek. Třídy výjimek mají obvykle jeden nebo více následujících konstruktorů:
Exception(), která používá výchozí hodnoty k inicializaci vlastností nového objektu výjimky.
Exception(String), který inicializuje nový objekt výjimky se zadanou chybovou zprávou.
Exception(String, Exception), který inicializuje nový objekt výjimky se zadanou chybovou zprávou a vnitřní výjimkou.
Exception(SerializationInfo, StreamingContext), což je
protectedkonstruktor, který inicializuje nový objekt výjimky ze serializovaných dat. Tento konstruktor byste měli implementovat, pokud jste se rozhodli, aby byl objekt výjimky serializovatelný.
Následující příklad ukazuje použití vlastní třídy výjimky. NotPrimeException Definuje výjimku, která se vyvolá, když se klient pokusí načíst sekvenci prvočísla zadáním počátečního čísla, které není na začátku. Výjimka definuje novou vlastnost, NonPrimekterá vrací nenáčinné číslo, které způsobilo výjimku. Kromě implementace chráněného konstruktoru bez parametrů a konstruktoru s SerializationInfo parametry StreamingContext pro serializaci NotPrimeException třída definuje tři další konstruktory pro podporu NonPrime vlastnosti. Každý konstruktor volá konstruktor základní třídy kromě zachování hodnoty jiného než primárního čísla. Třída NotPrimeException je také označena atributem SerializableAttribute .
using System;
using System.Runtime.Serialization;
[Serializable()]
public class NotPrimeException : Exception
{
private int notAPrime;
protected NotPrimeException()
: base()
{ }
public NotPrimeException(int value) :
base(String.Format("{0} is not a prime number.", value))
{
notAPrime = value;
}
public NotPrimeException(int value, string message)
: base(message)
{
notAPrime = value;
}
public NotPrimeException(int value, string message, Exception innerException) :
base(message, innerException)
{
notAPrime = value;
}
protected NotPrimeException(SerializationInfo info,
StreamingContext context)
: base(info, context)
{ }
public int NonPrime
{ get { return notAPrime; } }
}
namespace global
open System
open System.Runtime.Serialization
[<Serializable>]
type NotPrimeException =
inherit Exception
val notAPrime: int
member this.NonPrime =
this.notAPrime
new (value) =
{ inherit Exception($"%i{value} is not a prime number."); notAPrime = value }
new (value, message) =
{ inherit Exception(message); notAPrime = value }
new (value, message, innerException: Exception) =
{ inherit Exception(message, innerException); notAPrime = value }
// F# does not support protected members
new () =
{ inherit Exception(); notAPrime = 0 }
new (info: SerializationInfo, context: StreamingContext) =
{ inherit Exception(info, context); notAPrime = 0 }
Imports System.Runtime.Serialization
<Serializable()> _
Public Class NotPrimeException : Inherits Exception
Private notAPrime As Integer
Protected Sub New()
MyBase.New()
End Sub
Public Sub New(value As Integer)
MyBase.New(String.Format("{0} is not a prime number.", value))
notAPrime = value
End Sub
Public Sub New(value As Integer, message As String)
MyBase.New(message)
notAPrime = value
End Sub
Public Sub New(value As Integer, message As String, innerException As Exception)
MyBase.New(message, innerException)
notAPrime = value
End Sub
Protected Sub New(info As SerializationInfo,
context As StreamingContext)
MyBase.New(info, context)
End Sub
Public ReadOnly Property NonPrime As Integer
Get
Return notAPrime
End Get
End Property
End Class
Třída PrimeNumberGenerator zobrazená v následujícím příkladu používá Sieve z Eratosthenes k výpočtu posloupnosti prime čísel od 2 do limitu určeného klientem ve volání jeho konstruktoru třídy. Metoda GetPrimesFrom vrátí všechna první čísla, která jsou větší nebo rovna zadanému dolnímu limitu, ale vyvolá NotPrimeException , pokud tento dolní limit není primárním číslem.
using System;
using System.Collections.Generic;
[Serializable]
public class PrimeNumberGenerator
{
private const int START = 2;
private int maxUpperBound = 10000000;
private int upperBound;
private bool[] primeTable;
private List<int> primes = new List<int>();
public PrimeNumberGenerator(int upperBound)
{
if (upperBound > maxUpperBound)
{
string message = String.Format(
"{0} exceeds the maximum upper bound of {1}.",
upperBound, maxUpperBound);
throw new ArgumentOutOfRangeException(message);
}
this.upperBound = upperBound;
// Create array and mark 0, 1 as not prime (True).
primeTable = new bool[upperBound + 1];
primeTable[0] = true;
primeTable[1] = true;
// Use Sieve of Eratosthenes to determine prime numbers.
for (int ctr = START; ctr <= (int)Math.Ceiling(Math.Sqrt(upperBound));
ctr++)
{
if (primeTable[ctr]) continue;
for (int multiplier = ctr; multiplier <= upperBound / ctr; multiplier++)
if (ctr * multiplier <= upperBound) primeTable[ctr * multiplier] = true;
}
// Populate array with prime number information.
int index = START;
while (index != -1)
{
index = Array.FindIndex(primeTable, index, (flag) => !flag);
if (index >= 1)
{
primes.Add(index);
index++;
}
}
}
public int[] GetAllPrimes()
{
return primes.ToArray();
}
public int[] GetPrimesFrom(int prime)
{
int start = primes.FindIndex((value) => value == prime);
if (start < 0)
throw new NotPrimeException(prime, String.Format("{0} is not a prime number.", prime));
else
return primes.FindAll((value) => value >= prime).ToArray();
}
}
namespace global
open System
[<Serializable>]
type PrimeNumberGenerator(upperBound) =
let start = 2
let maxUpperBound = 10000000
let primes = ResizeArray()
let primeTable =
upperBound + 1
|> Array.zeroCreate<bool>
do
if upperBound > maxUpperBound then
let message = $"{upperBound} exceeds the maximum upper bound of {maxUpperBound}."
raise (ArgumentOutOfRangeException message)
// Create array and mark 0, 1 as not prime (True).
primeTable[0] <- true
primeTable[1] <- true
// Use Sieve of Eratosthenes to determine prime numbers.
for i = start to float upperBound |> sqrt |> ceil |> int do
if not primeTable[i] then
for multiplier = i to upperBound / i do
if i * multiplier <= upperBound then
primeTable[i * multiplier] <- true
// Populate array with prime number information.
let mutable index = start
while index <> -1 do
index <- Array.FindIndex(primeTable, index, fun flag -> not flag)
if index >= 1 then
primes.Add index
index <- index + 1
member _.GetAllPrimes() =
primes.ToArray()
member _.GetPrimesFrom(prime) =
let start =
Seq.findIndex ((=) prime) primes
if start < 0 then
raise (NotPrimeException(prime, $"{prime} is not a prime number.") )
else
Seq.filter ((>=) prime) primes
|> Seq.toArray
Imports System.Collections.Generic
<Serializable()> Public Class PrimeNumberGenerator
Private Const START As Integer = 2
Private maxUpperBound As Integer = 10000000
Private upperBound As Integer
Private primeTable() As Boolean
Private primes As New List(Of Integer)
Public Sub New(upperBound As Integer)
If upperBound > maxUpperBound Then
Dim message As String = String.Format(
"{0} exceeds the maximum upper bound of {1}.",
upperBound, maxUpperBound)
Throw New ArgumentOutOfRangeException(message)
End If
Me.upperBound = upperBound
' Create array and mark 0, 1 as not prime (True).
ReDim primeTable(upperBound)
primeTable(0) = True
primeTable(1) = True
' Use Sieve of Eratosthenes to determine prime numbers.
For ctr As Integer = START To CInt(Math.Ceiling(Math.Sqrt(upperBound)))
If primeTable(ctr) Then Continue For
For multiplier As Integer = ctr To CInt(upperBound \ ctr)
If ctr * multiplier <= upperBound Then primeTable(ctr * multiplier) = True
Next
Next
' Populate array with prime number information.
Dim index As Integer = START
Do While index <> -1
index = Array.FindIndex(primeTable, index, Function(flag)
Return Not flag
End Function)
If index >= 1 Then
primes.Add(index)
index += 1
End If
Loop
End Sub
Public Function GetAllPrimes() As Integer()
Return primes.ToArray()
End Function
Public Function GetPrimesFrom(prime As Integer) As Integer()
Dim start As Integer = primes.FindIndex(Function(value)
Return value = prime
End Function)
If start < 0 Then
Throw New NotPrimeException(prime, String.Format("{0} is not a prime number.", prime))
Else
Return primes.FindAll(Function(value)
Return value >= prime
End Function).ToArray()
End If
End Function
End Class
Následující příklad provádí dvě volání GetPrimesFrom metody s nenákladnými čísly, z nichž jedna překračuje hranice domény aplikace. V obou případech se výjimka vyvolá a úspěšně zpracuje v klientském kódu.
using System;
using System.Reflection;
class Example1
{
public static void Main()
{
int limit = 10000000;
PrimeNumberGenerator primes = new PrimeNumberGenerator(limit);
int start = 1000001;
try
{
int[] values = primes.GetPrimesFrom(start);
Console.WriteLine("There are {0} prime numbers from {1} to {2}",
start, limit);
}
catch (NotPrimeException e)
{
Console.WriteLine("{0} is not prime", e.NonPrime);
Console.WriteLine(e);
Console.WriteLine("--------");
}
AppDomain domain = AppDomain.CreateDomain("Domain2");
PrimeNumberGenerator gen = (PrimeNumberGenerator)domain.CreateInstanceAndUnwrap(
typeof(Example).Assembly.FullName,
"PrimeNumberGenerator", true,
BindingFlags.Default, null,
new object[] { 1000000 }, null, null);
try
{
start = 100;
Console.WriteLine(gen.GetPrimesFrom(start));
}
catch (NotPrimeException e)
{
Console.WriteLine("{0} is not prime", e.NonPrime);
Console.WriteLine(e);
Console.WriteLine("--------");
}
}
}
open System
open System.Reflection
let limit = 10000000
let primes = PrimeNumberGenerator limit
let start = 1000001
try
let values = primes.GetPrimesFrom start
printfn $"There are {values.Length} prime numbers from {start} to {limit}"
with :? NotPrimeException as e ->
printfn $"{e.NonPrime} is not prime"
printfn $"{e}"
printfn "--------"
let domain = AppDomain.CreateDomain "Domain2"
let gen =
domain.CreateInstanceAndUnwrap(
typeof<PrimeNumberGenerator>.Assembly.FullName,
"PrimeNumberGenerator", true,
BindingFlags.Default, null,
[| box 1000000 |], null, null)
:?> PrimeNumberGenerator
try
let start = 100
printfn $"{gen.GetPrimesFrom start}"
with :? NotPrimeException as e ->
printfn $"{e.NonPrime} is not prime"
printfn $"{e}"
printfn "--------"
Imports System.Reflection
Module Example
Sub Main()
Dim limit As Integer = 10000000
Dim primes As New PrimeNumberGenerator(limit)
Dim start As Integer = 1000001
Try
Dim values() As Integer = primes.GetPrimesFrom(start)
Console.WriteLine("There are {0} prime numbers from {1} to {2}",
start, limit)
Catch e As NotPrimeException
Console.WriteLine("{0} is not prime", e.NonPrime)
Console.WriteLine(e)
Console.WriteLine("--------")
End Try
Dim domain As AppDomain = AppDomain.CreateDomain("Domain2")
Dim gen As PrimeNumberGenerator = domain.CreateInstanceAndUnwrap(
GetType(Example).Assembly.FullName,
"PrimeNumberGenerator", True,
BindingFlags.Default, Nothing,
{1000000}, Nothing, Nothing)
Try
start = 100
Console.WriteLine(gen.GetPrimesFrom(start))
Catch e As NotPrimeException
Console.WriteLine("{0} is not prime", e.NonPrime)
Console.WriteLine(e)
Console.WriteLine("--------")
End Try
End Sub
End Module
' The example displays the following output:
' 1000001 is not prime
' NotPrimeException: 1000001 is not a prime number.
' at PrimeNumberGenerator.GetPrimesFrom(Int32 prime)
' at Example.Main()
' --------
' 100 is not prime
' NotPrimeException: 100 is not a prime number.
' at PrimeNumberGenerator.GetPrimesFrom(Int32 prime)
' at Example.Main()
' --------
Příklady
Následující příklad ukazuje catch blok (with v jazyce F#), který je definován pro zpracování ArithmeticException chyb. Tento catch blok také zachytává DivideByZeroException chyby, protože DivideByZeroException odvozuje a ArithmeticException neexistuje žádný catch blok explicitně definovaný pro DivideByZeroException chyby.
using System;
class ExceptionTestClass
{
public static void Main()
{
int x = 0;
try
{
int y = 100 / x;
}
catch (ArithmeticException e)
{
Console.WriteLine($"ArithmeticException Handler: {e}");
}
catch (Exception e)
{
Console.WriteLine($"Generic Exception Handler: {e}");
}
}
}
/*
This code example produces the following results:
ArithmeticException Handler: System.DivideByZeroException: Attempted to divide by zero.
at ExceptionTestClass.Main()
*/
module ExceptionTestModule
open System
let x = 0
try
let y = 100 / x
()
with
| :? ArithmeticException as e ->
printfn $"ArithmeticException Handler: {e}"
| e ->
printfn $"Generic Exception Handler: {e}"
// This code example produces the following results:
// ArithmeticException Handler: System.DivideByZeroException: Attempted to divide by zero.
// at <StartupCode$fs>.$ExceptionTestModule.main@()
Class ExceptionTestClass
Public Shared Sub Main()
Dim x As Integer = 0
Try
Dim y As Integer = 100 / x
Catch e As ArithmeticException
Console.WriteLine("ArithmeticException Handler: {0}", e.ToString())
Catch e As Exception
Console.WriteLine("Generic Exception Handler: {0}", e.ToString())
End Try
End Sub
End Class
'
'This code example produces the following results:
'
'ArithmeticException Handler: System.OverflowException: Arithmetic operation resulted in an overflow.
' at ExceptionTestClass.Main()
'
Váš názor
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu: https://aka.ms/ContentUserFeedback.
Odeslat a zobrazit názory pro