Exception Třída

Definice

Představuje chyby, ke kterým dochází během provádění aplikace.

public ref class Exception
public ref class Exception : System::Runtime::Serialization::ISerializable
public ref class Exception : System::Runtime::InteropServices::_Exception, System::Runtime::Serialization::ISerializable
public class Exception
public class Exception : System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
public class Exception : System.Runtime.Serialization.ISerializable
[System.Serializable]
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public class Exception : System.Runtime.InteropServices._Exception, System.Runtime.Serialization.ISerializable
[System.Serializable]
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public class Exception : System.Runtime.Serialization.ISerializable
type Exception = class
type Exception = class
    interface ISerializable
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
type Exception = class
    interface ISerializable
[<System.Serializable>]
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Exception = class
    interface ISerializable
    interface _Exception
[<System.Serializable>]
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Exception = class
    interface ISerializable
Public Class Exception
Public Class Exception
Implements ISerializable
Public Class Exception
Implements _Exception, ISerializable
Dědičnost
Exception
Odvozené
Atributy
Implementuje

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 ArithmeticException a neexistuje žádný catch blok explicitně definovaný pro DivideByZeroException chyby.

using namespace System;
int main()
{
    int x = 0;
    try
    {
        int y = 100 / x;
    }
    catch ( ArithmeticException^ e ) 
    {
        Console::WriteLine( "ArithmeticException Handler: {0}", e );
    }
    catch ( Exception^ e ) 
    {
        Console::WriteLine( "Generic Exception Handler: {0}", e );
    }
}
/*
This code example produces the following results:

ArithmeticException Handler: System.DivideByZeroException: Attempted to divide by zero.
   at main()
 
*/
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()
'

Poznámky

Tato třída 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.

V této části:

Chyby a výjimky
Bloky try/catch
Funkce typu výjimky
Vlastnosti třídy výjimky
Důležité informace o výkonu
Opětovné vyvolání výjimky
Výběr standardních výjimek
Implementace vlastních výjimek

Chyby a výjimky

K chybám za běhu může dojít z různých důvodů. V kódu by se ale neměly zpracovávat všechny chyby jako výjimky. Tady jsou některé kategorie chyb, ke kterým může dojít za běhu, a vhodné způsoby, jak na ně reagovat.

  • Chyby použití. Chyba použití představuje chybu v logikě programu, která může vést k výjimce. Tato chyba by však měla být vyřešena ne 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 obj argument musí být vždy nenulový.

    using System;
    
    public class Person
    {
       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.
          Person p = (Person) obj;
          return this.Name.Equals(p.Name);
       }
    }
    
    public class Example
    {
       public static void Main()
       {
          Person p1 = new Person();
          p1.Name = "John";
          Person 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 Example
       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 Module
    

    Výjimka NullReferenceException , která způsobí, že obj je null možné odstranit ú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á null argument.

    using System;
    
    public class Person
    {
       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.
           Person p = obj as Person;
           if (p == null)
              return false;
           else
              return this.Name.Equals(p.Name);
       }
    }
    
    public class Example
    {
       public static void Main()
       {
          Person p1 = new Person();
          p1.Name = "John";
          Person 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: False
    
    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 handles a null obj argument.
          Dim p As Person = TryCast(obj, Person)
          If p Is Nothing Then 
             Return False
          Else
             Return Me.Name.Equals(p.Name)
          End If
       End Function
    End Class
    
    Module Example
       Public Sub Main()
          Dim p1 As New Person()
          p1.Name = "John"
          Dim p2 As Person = Nothing
          
          Console.WriteLine("p1 = p2: {0}", p1.Equals(p2))   
       End Sub
    End Module
    ' The example displays the following output:
    '       p1 = p2: False
    

    Mí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í ladění i vydané verzi. Další informace najdete 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 psaním kódu bez chyb.

    V některých případech může chyba programu odrážet očekávanou nebo rutinní chybovou podmínku. 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 parsovat řetězec data voláním DateTime.TryParseExact metody, která vrátí Boolean hodnotu, která označuje, zda byla operace parsování úspěšná, místo použití DateTime.ParseExact metody, která vyvolá FormatException výjimku, pokud řetězec kalendářního 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, jestli ho chce vytvořit.

    V jiných případech chyba programu odráží neočekávanou chybovou podmínku, kterou je možné zpracovat ve vašem kódu. Pokud jste například zkontrolovali, jestli soubor existuje, může být odstraněn před otevřením nebo může být poškozen. V takovém případě se pokus o otevření souboru vytvořením instance StreamReader objektu Open nebo voláním 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.

  • Chyby systému. Selhání systému je chyba za běhu, která se nedá zpracovat programově smysluplným způsobem. Pokud například modul CLR (Common Language Runtime) nemůže přidělit další paměť, může libovolná metoda vyvolat OutOfMemoryException výjimku. Obvykle se selhání systému nezpracují pomocí zpracování výjimek. Místo toho můžete použít událost, například AppDomain.UnhandledException metodu Environment.FailFast 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, který je založený na reprezentaci výjimek jako objektů a oddělení kódu programového kódu a zpracování výjimek do try bloků a catch bloků. Může existovat jeden nebo více catch bloků, každý z nich 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á try se blok. Kód aplikace, který zpracovává výjimky vyvolané blokem try , se umístí do catch příkazu a nazývá catch se blok. Bloky jsou spojené s blokem try a catch každý catch blok obsahuje filtr typu, který určuje typy výjimek, které zpracovává.

Pokud dojde k výjimce v try bloku, systém vyhledá přidružené catch bloky v pořadí, v jakém se objeví v kódu aplikace, dokud nenajde catch blok, který zpracovává výjimku. Blok catch zpracovává výjimku typu T , pokud filtr typu 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 se v kódu aplikace musí před blokem, který zpracovává základní typy, zadat catch blok, catch 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, výjimka se předá zásobníku volání a předchozí rámec catch zásobníku vyhledá blok, který výjimku zpracuje. Hledání zásobníku volání pokračuje, dokud se výjimka nezpracuje 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.. s výrazem

F# nepoužívá catch bloky. Místo toho je vyvolaná výjimka vzorem, 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. Když 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 se nachází ve Message vlastnosti objektu výjimky. Během vytváření objektu výjimky můžete konstruktoru předat 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, , InnerExceptionMessage, HelpLinkHResult, , Source, TargetSitea Data.

Pokud existuje kauzální vztah mezi dvěma nebo více výjimkami, InnerException vlastnost udržuje tyto informace. Vnější výjimka se vyvolá v reakci na tuto vnitřní výjimku. Kód, který zpracovává vnější výjimku, může použít informace z dřívější vnitřní výjimky k vhodnějšímu zpracování chyby. 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ředku pomocí ResourceManager třídy. Další informace o lokalizovaných prostředcích najdete 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č došlo k výjimce, HelpLink může vlastnost obsahovat adresu URL (nebo URN) do souboru nápovědy.

Třída Exception používá COR_E_EXCEPTION HRESULT, který má hodnotu 0x80131500.

Seznam počátečních hodnot vlastností pro instanci Exception třídy naleznete v Exception konstruktorech.

Otázky 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 zpracování skutečně výjimečných podmínek, 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 metoda bude volána s platnými parametry. Neplatný argument metody, pokud není výsledkem chyby použití, znamená to, ž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řevést návratový kód na výjimku; a nezachyťte výjimku, ignorujte ji a pak 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:

  • Knihovna tříd, která zase zabalí volání metod v knihovně tříd rozhraní .NET Framework 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 výjimku znovu vyvolat.

Doporučeným způsobem, jak znovu vyvolat výjimku, je jednoduše použít příkaz throw v jazyce C#, funkci reraise v jazyce F# a příkaz Throw v Visual Basic bez zahrnutí výrazu. Tím zajistíte, ž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 rozšíření řetězce, FindOccurrenceszabalí jedno nebo více volání String.IndexOf(String, Int32) bez ověření argumentů předem.

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;

public static class Library
{
   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 e) {
         // 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 FindOccurrences(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. Vzhledem k tomu, ž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 Example
{
   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 Example
   Public Sub Main()
      Dim s As String = "It was a cold day when..."
      Dim indexes() As Integer = s.FindOccurrences("a")
      ShowOccurrences(s, "a", indexes)
      Console.WriteLine()

      Dim toFind As String = Nothing
      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:{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()

Naopak pokud je výjimka znovu vyvolán pomocí

throw e;
Throw e  
raise e

příkaz, úplný zásobník volání není zachován 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 místo implementace vlastní výjimky často použít existující typ výjimky v rozhraní .NET Framework. Za těchto dvou podmínek byste měli použít standardní typ výjimky:

  • Vyvoláte výjimku, která je způsobená chybou použití (to znamená chybou v logikě programu, kterou vytvořil vývojář, který volá vaši metodu). Obvykle byste vyvolali výjimku, například ArgumentException, , ArgumentNullExceptionInvalidOperationExceptionnebo NotSupportedException. Řetězec, který zadáte konstruktoru objektu výjimky při vytvoření instance objektu výjimky, by měl popisovat 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 rozhraní .NET Framework. Měli byste vyvolat nejvýraznější možnou výjimku. Pokud například metoda vyžaduje argument, aby byl platným členem typu výčtu, měli InvalidEnumArgumentException ArgumentExceptionbyste místo .

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 předaný 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í ve vhodné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 není implementována.
NotSupportedException Metoda nebo operace se nepodporuje.
ObjectDisposedException Operace se provádí u objektu, který byl odstraněn.
OverflowException Operace aritmetické, přetypování nebo převodu vede k 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 rozhraní .NET Framework pro zpracování chybového stavu adekvátní:

  • Pokud výjimka odráží jedinečnou chybu programu, která nelze namapovat na existující výjimku rozhraní .NET Framework.

  • Pokud výjimka vyžaduje zpracování, které se liší od zpracování, které je vhodné pro existující výjimku rozhraní .NET Framework, 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 při volání metody použít stejnou výjimku pro chybu, která vede z volajícího k nezadání odpovídajících omezených hodnot.

Třída Exception je základní třídou všech výjimek v rozhraní .NET Framework. Mnoho odvozených tříd spoléhá na zděděné chování členů Exception třídy; nepřepíší členy Exception, ani nedefinují žádné jedinečné členy.

Definování vlastní třídy výjimek:

  1. 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.

  2. 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ů.

  3. Určete, jestli 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. Pokud chcete objekt výjimky serializovat, označte ho atributem SerializableAttribute .

  4. Definujte konstruktory vaší třídy výjimek. Třídy výjimek mají obvykle jeden nebo více z 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 protected konstruktor, který inicializuje nový objekt výjimky ze serializovaných dat. Tento konstruktor byste měli implementovat, pokud jste se rozhodli vytvořit objekt výjimky serializovatelný.

Následující příklad ukazuje použití vlastní třídy výjimek. Definuje NotPrimeException výjimku, která se vyvolá, když se klient pokusí načíst posloupnost prime čísel zadáním počátečního čísla, které není primární. Výjimka definuje novou vlastnost, NonPrimekterá vrátí nenáčinné číslo, které způsobilo výjimku. Kromě implementace chráněného konstruktoru bez parametrů a konstruktoru s SerializationInfo parametry StreamingContext serializace 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 non-prime number. 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 eratosthenes k výpočtu posloupnosti prime čísel od 2 do limitu zadaného klientem ve volání konstruktoru třídy. Metoda GetPrimesFrom vrátí všechna prime čí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 Example
{
   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()
'      --------

prostředí Windows Runtime a rozhraní .NET Framework 4.5.1

V .NET pro aplikace Windows 8.x Store pro Windows 8 se některé informace o výjimce obvykle ztratí, když se výjimka rozšíří prostřednictvím rámců zásobníku non-.NET Framework. Počínaje rozhraním .NET Framework 4.5.1 a Windows 8.1 používá modul CLR (Common Language Runtime) původní Exception objekt, který byl vyvolán, pokud nebyla tato výjimka změněna v rámci zásobníku non-.NET Framework.

Konstruktory

Exception()

Inicializuje novou instanci Exception třídy.

Exception(SerializationInfo, StreamingContext)

Inicializuje novou instanci třídy Exception se serializovanými daty.

Exception(String)

Inicializuje novou instanci Exception třídy se zadanou chybovou zprávou.

Exception(String, Exception)

Inicializuje novou instanci Exception třídy se zadanou chybovou zprávou a odkazem na vnitřní výjimku, která je příčinou této výjimky.

Vlastnosti

Data

Získá kolekci párů klíč/hodnota, které poskytují další uživatelem definované informace o výjimce.

HelpLink

Získá nebo nastaví odkaz na soubor nápovědy přidružený k této výjimce.

HResult

Získá nebo nastaví HRESULT, kódovanou číselnou hodnotu přiřazenou konkrétní výjimce.

InnerException

Exception Získá instanci, která způsobila aktuální výjimku.

Message

Získá zprávu, která popisuje aktuální výjimku.

Source

Získá nebo nastaví název aplikace nebo objektu, který způsobuje chybu.

StackTrace

Získá řetězcové znázornění okamžitých rámců v zásobníku volání.

TargetSite

Získá metodu, která vyvolá aktuální výjimku.

Metody

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.

(Zděděno od Object)
GetBaseException()

Při přepsání v odvozené třídě vrátí Exception hodnotu, která je hlavní příčinou jedné nebo více následných výjimek.

GetHashCode()

Slouží jako výchozí funkce hash.

(Zděděno od Object)
GetObjectData(SerializationInfo, StreamingContext)

Při přepsání v odvozené třídě nastaví s SerializationInfo informacemi o výjimce.

GetType()

Získá typ modulu runtime aktuální instance.

GetType()

Type Získá aktuální instanci.

(Zděděno od Object)
MemberwiseClone()

Vytvoří použádnou kopii aktuálního souboru Object.

(Zděděno od Object)
ToString()

Vytvoří a vrátí řetězcovou reprezentaci aktuální výjimky.

událost

SerializeObjectState
Zastaralé.

Nastane, když je výjimka serializována k vytvoření objektu stavu výjimky, který obsahuje serializovaná data o výjimce.

Platí pro

Viz také