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 obj argument 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: {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 Module
  

  Výjimku NullReferenceException, která vzniká, když obj je null, lze odstranit úpravou zdrojového kódu tak, aby se explicitně testovalo na null před voláním přepsání Object.Equals a následným opětovným zkompilováním. Následující příklad obsahuje opravený zdrojový kód, který zpracovává null argument.

  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: {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 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: False
  

  Místo použití zpracování výjimek pro chyby použití můžete použít metodu Debug.Assert k identifikaci chyb použití v ladicích sestaveních a metodu Trace.Assert k identifikaci chyb použití v ladicích i produkčních sestaveních. Další informace naleznete v tématu Kontrolní výrazy ve spravovaném kódu.

• Chyby programu. Chyba programu je chyba modulu runtime, 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ě může pokus o otevření souboru vytvořením instance StreamReader objektu nebo voláním Open metody 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 je AppDomain.UnhandledException, a zavolat 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 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é catch k bloku nula nebo více try 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 T, pokud filtr typu bloku catch určuje T nebo jakýkoli typ, ze kterého je T odvozen. 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ý blok catch pro výjimku, 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 propaguje nahoru po zásobníku volání a v předchozím rámci zásobníku se hledá catch blok, který by tuto výjimku zpracoval. 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 vyvolaná výjimka porovnána vzorem pomocí jediného with bloku. Jelikož se jedná o výraz, nikoli o příkaz, musí všechny cesty vracet stejný typ. Další informace naleznete v části try...with Expression.

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 ve vlastnosti Message.

• Stav zásobníku volání při vyvolání výjimky. Vlastnost StackTrace obsahuje sledování zásobníku, které lze použít k určení, kde v kódu došlo k chybě. Výpis zásobníku obsahuje seznam všech volaných metod a čísel řádků ve zdrojovém souboru, kde k voláním dochází.

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, 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ána 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 použijte výrazy assert k identifikaci a opravě chyb použití.

Kromě toho nevyvolávejte výjimku, pokud je dostatečný návratový kód; nepřeveďte návratový kód na výjimku; a rutinně nezachycujte výjimku, ignorujte ji a pokračujte ve zpracování.

Opětovné vyvolání výjimky

V mnoha případech má zpracovatel výjimky za úkol jednoduše 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. To zajišťuje, že při předávání výjimky volajícímu jsou zachovány všechny informace o zásobníku volání. Následující příklad to ilustruje. Metoda rozšíření řetězce FindOccurrences zabalí jedno nebo více volání String.IndexOf(String, Int32) bez předchozího ověření argumentů.

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í FindOccurrences volající předá null jako hledaný řetězec, což způsobí, že metoda String.IndexOf(String, Int32) 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 ({e.GetType().Name}) occurred.");
            Console.WriteLine($"Message:{Environment.NewLine}   {e.Message}{Environment.NewLine}");
            Console.WriteLine($"Stack Trace:{Environment.NewLine}   {e.StackTrace}{Environment.NewLine}");
        }
    }

    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, jestliže je výjimka znovu vyvolána pomocí tohoto příkazu:

throw e;

Throw e

raise e

... pak není celý zásobník volání 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 ({e.GetType().Name}) occurred.");
    Console.WriteLine($"   Message:{Environment.NewLine}{e.Message}");
    Console.WriteLine($"   Stack Trace:{Environment.NewLine}   {e.StackTrace}");
    Exception ie = e.InnerException;
    if (ie != null)
    {
        Console.WriteLine("   The Inner Exception:");
        Console.WriteLine($"      Exception Name: {ie.GetType().Name}");
        Console.WriteLine($"      Message: {ie.Message}{Environment.NewLine}");
        Console.WriteLine($"      Stack Trace:{Environment.NewLine}   {ie.StackTrace}{Environment.NewLine}");
    }
}
// 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 ve vlastnosti Message.

• Zpracováváte chybu, kterou lze volajícímu sdělit pomocí existující výjimky .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 byste vyvolat InvalidEnumArgumentException (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é nebo Decimal dělicí operaci 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:

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 tříd Exception nezmění chování zděděných členů.

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

4. 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 protected konstruktor, 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čísel zadáním počátečního čísla, které není prvočíslem. 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 při zachování hodnoty neprvočí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á Eratosthenovo síto k výpočtu posloupnosti prvočísel od 2 do limitu určeného klientem ve volání konstruktoru jeho 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í metody GetPrimesFrom se složenými čísly, z nichž jedno překračuje hranice aplikační domény. 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 {start} prime numbers from {limit} to {2}");
        }
        catch (NotPrimeException e)
        {
            Console.WriteLine($"{e.NonPrime} is not prime");
            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($"{e.NonPrime} is not prime");
            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 je odvozen od ArithmeticException a 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()
'