Exception-Klasse

Stellt Fehler dar, die beim Ausführen einer Anwendung auftreten.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
<ClassInterfaceAttribute(ClassInterfaceType.None)> _
Public Class Exception
    Implements ISerializable, _Exception
'Usage
Dim instance As Exception

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[ClassInterfaceAttribute(ClassInterfaceType.None)] 
public class Exception : ISerializable, _Exception

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[ClassInterfaceAttribute(ClassInterfaceType::None)] 
public ref class Exception : ISerializable, _Exception

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.None) */ 
public class Exception implements ISerializable, _Exception

SerializableAttribute 
ComVisibleAttribute(true) 
ClassInterfaceAttribute(ClassInterfaceType.None) 
public class Exception implements ISerializable, _Exception

Hinweise

Diese Klasse ist die Basisklasse für alle Ausnahmen. Wenn ein Fehler auftritt, wird dieser entweder vom System oder von der aktuell ausgeführten Anwendung durch Auslösen einer Ausnahme angezeigt, die Informationen über den Fehler enthält. Eine ausgelöste Ausnahme wird von der Anwendung oder vom Standardausnahmehandler behandelt.

Die Common Language Runtime stellt ein Modell zur Ausnahmebehandlung bereit, das auf der Darstellung von Ereignissen als Objekt und auf der Trennung von Programmcode und Code zur Ausnahmebehandlung in try-Blöcke bzw. in catch-Blöcke beruht. Es kann mehrere catch-Blöcke geben, von denen jeder zur Behandlung eines speziellen Ausnahmetyps bestimmt ist oder von denen ein Block zur Behandlung von genauer definierten Ausnahmen bestimmt ist.

Wenn in einer Anwendung Ausnahmen behandelt werden sollen, die beim Ausführen eines Anwendungscodeblocks auftreten, muss sich dieser Code innerhalb einer try-Anweisung befinden. Anwendungscode in einer try-Anweisung ist ein try-Block. Anwendungscode, der in einem try-Block ausgelöste Ausnahmen behandelt, wird in einer catch-Anweisung platziert und als catch-Block bezeichnet. Einem try-Block sind 0 oder mehr catch-Blöcke zugeordnet. Jeder catch-Block enthält einen Typfilter, der die Typen der von ihm behandelten Ausnahmen festlegt.

Wenn in einem try-Block eine Ausnahme ausgelöst wird, durchsucht das System die zugeordneten catch-Blöcke in der Reihenfolge, in der sie im Anwendungscode auftreten, bis ein catch-Block gefunden wird, der die Ausnahme behandelt. Ein catch-Block behandelt Ausnahmen vom Typ T, wenn der Typfilter des catch-Blocks T oder einen Typ angibt, von dem T abgeleitet ist. Wenn der erste catch-Block gefunden wird, der die Ausnahme behandelt, beendet das System die Suche. Aus diesem Grunde muss ein catch-Block, der einen Typ behandelt, im Anwendungscode vor einem catch-Block stehen, der seine Basistypen behandelt. Dies wird im Beispiel am Ende dieses Abschnitts veranschaulicht. Ein catch-Block, der System.Exception behandelt, wird zuletzt angegeben.

Wenn keiner der dem aktuellen try-Block zugeordneten catch-Blöcke die Ausnahme behandelt und der aktuelle try-Block beim aktuellen Aufruf in anderen try-Blöcken geschachtelt ist, werden die catch-Blöcke durchsucht, die dem nächsten umschließenden try-Block zugeordnet sind. Wenn kein catch-Block für die Ausnahme gefunden wird, durchsucht das System höhere Schachtelungsebenen im aktuellen Aufruf. Wenn für die Ausnahme im aktuellen Aufruf kein catch-Block gefunden wird, wird die Ausnahme gemäß der Aufrufliste weitergegeben, und der vorige Stapelrahmen wird nach einem catch-Block durchsucht, der die Ausnahme behandelt. Das Durchsuchen der Aufrufliste wird fortgesetzt, bis die Ausnahme behandelt wird oder in der Aufrufliste kein Stapelrahmen mehr vorhanden ist. Wenn der Anfang der Aufrufliste erreicht ist, ohne einen catch-Block für die Behandlung der Ausnahme zu finden, wird der Standardausnahmehandler aufgerufen, und die Anwendung wird beendet.

Die Ausnahmetypen unterstützen die folgenden Features:

• Fehlerbeschreibungen im Klartext. Beim Auftreten einer Ausnahme stellt die Common Language Runtime eine Textmeldung bereit, die den Benutzer über die Art des Fehlers informiert und Wege zur Lösung des Problems vorschlägt. Diese Textmeldung befindet sich in der Message-Eigenschaft des Ausnahmeobjekts. Beim Erstellen des Ausnahmeobjekts kann eine Zeichenfolge an den Konstruktor übergeben werden, in der die Einzelheiten dieser bestimmten Ausnahme beschrieben werden. Wenn kein Argument für die Fehlermeldung übergeben wird, wird die Standardfehlermeldung verwendet.

• Der Zustand der Aufrufliste beim Auslösen der Ausnahme. Die StackTrace-Eigenschaft enthält eine Stapelüberwachung, mit der die Stelle im Code bestimmt werden kann, an der der Fehler auftritt. Die Stapelüberwachung führt alle aufgerufenen Methoden und die Zeilennummern der Quelldatei auf, in der die Aufrufe stattfinden.

Für die Exception-Basisklasse sind zwei Ausnahmekategorien vorhanden:

• Die vordefinierten, von SystemException abgeleiteten Ausnahmeklassen der Common Language Runtime.

• Die benutzerdefinierten, von ApplicationException abgeleiteten Ausnahmeklassen der Anwendung.

Exception besitzt eine Anzahl von Eigenschaften, mit der Codeposition, Typ, Hilfedatei und Ursache für eine Ausnahme ermittelt werden können: StackTrace, InnerException, Message, HelpLink, HResult, Source, TargetSite und Data.

Wenn zwischen zwei oder mehr Ausnahmen eine kausale Beziehung besteht, wird dies durch die InnerException-Eigenschaft wiedergegeben. Die äußere Ausnahme wird als Reaktion auf diese innere Ausnahme ausgelöst. Der Code, der die äußere Ausnahme behandelt, kann den Fehler anhand der Informationen über die innere Ausnahme auf geeignetere Weise behandeln. Zusätzliche Informationen über die Ausnahme können in der Data-Eigenschaft gespeichert werden.

Die Fehlermeldungszeichenfolge, die dem Konstruktor beim Erstellen des Ausnahmeobjekts übergeben wird, sollte lokalisiert sein und kann über den ResourceManager einer Ressourcendatei entnommen werden. Weitere Informationen über lokalisierte Ressourcen finden Sie in der Übersicht über den System.Resources-Namespace und unter Verpacken und Bereitstellen von Ressourcen .

Die HelpLink-Eigenschaft kann einen URL (oder URN) für eine Hilfedatei enthalten, um dem Benutzer ausführliche Informationen über die Ursache der Ausnahme zur Verfügung zu stellen.

Exception verwendet HRESULT COR_E_EXCEPTION mit dem Wert 0x80131500.

Eine Liste der anfänglichen Eigenschaftenwerte für eine Instanz von Exception finden Sie unter den Exception-Konstruktoren.

Überlegungen zur Leistung

Das Auslösen und Behandeln einer Ausnahme beansprucht einen beträchtlichen Anteil an Systemressourcen und Ausführungszeit. Ausnahmen sollten nur zum Behandeln von wirklich außergewöhnlichen Bedingungen eingesetzt werden, nicht für die Behandlung von vorhersagbaren Ereignissen oder für die Ablaufsteuerung. So ist es beispielsweise gerechtfertigt, eine Ausnahme auszulösen, wenn ein Argument für eine Methode unzulässig ist, weil erwartet werden kann, dass die Methode mit gültigen Parametern aufgerufen wird. Ein ungültiges Argument für eine Methode bedeutet, dass etwas Außergewöhnliches aufgetreten ist. Auf der anderen Seite sollte keine Ausnahme ausgelöst werden, wenn Benutzereingaben ungültig sind, weil erwartet werden kann, dass Benutzer gelegentlich ungültige Daten eingeben. Stellen Sie in solch einem Fall ein Wiederholmechanismus bereit, damit Benutzer gültige Eingaben vornehmen können.

Lösen Sie nur in außergewöhnlichen Bedingungen Ausnahmen aus, und fangen Sie die Ausnahmen in einem allgemeinen Ausnahmehandler ab, der für einen Großteil Ihrer Anwendung anwendbar ist, nicht in einem Handler, der nur für eine spezifische Ausnahme gilt. Diesem Ansatz liegt folgende Überlegung zugrunde: Die meisten Fehler können durch Validierung und Fehlerbehandlungscode im unmittelbaren Umfeld des Fehlers behandelt werden, es müssen also keine Ausnahmen ausgelöst oder abgefangen werden. Der allgemeine Ausnahmehandler fängt wirklich außergewöhnliche Ausnahmen ab, die an einer beliebigen Stelle in der Anwendung ausgelöst wurden.

Lösen Sie außerdem keine Ausnahme aus, wenn ein Rückgabecode ausreichen würde, konvertieren Sie keinen Rückgabecode in eine Ausnahme, und fangen Sie nicht routinemäßig Ausnahmen ab, sondern ignorieren Sie sie, und fahren Sie mit der Verarbeitung fort.

Beispiel

Im folgenden Codebeispiel wird ein catch-Block veranschaulicht, der zur Behandlung von ArithmeticException-Fehlern definiert wird. Dieser catch-Block fängt auch DivideByZeroException-Fehler ab, da DivideByZeroException von ArithmeticException abgeleitet ist und kein explizit für DivideByZeroException-Fehler definierter catch-Block vorhanden ist.

Imports System

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 'Main
End Class 'ExceptionTestClass

using System;

class ExceptionTestClass 
{
public static void Main() 
{
   int x = 0;
      try 
      {
         int y = 100/x;
      }
         catch (ArithmeticException e) 
         {
         Console.WriteLine("ArithmeticException Handler: {0}", e.ToString());
         }
            catch (Exception e) 
            {
            Console.WriteLine("Generic Exception Handler: {0}", e.ToString());
            }
      } 
}

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 );
   }

}

import System.*;

class ExceptionTestClass
{
    public static void main(String[] args)
    {
        int x = 0;
        try {
            int y = 100 / x;
        }
        catch (ArithmeticException e) {
            Console.WriteLine("ArithmeticException Handler: {0}", e.ToString());
        }
        catch (System.Exception e) {
            Console.WriteLine("Generic Exception Handler: {0}", e.ToString());
        }
    } //main
} //ExceptionTestClass

Dieser C#-Code erzeugt die folgende Ausgabe:

ArithmeticException Handler: System.DivideByZeroException: Attempted to divide by zero. at ExceptionTestClass.Main()

Der Visual Basic-Code erzeugt die folgende Ausgabe:

ArithmeticException Handler: System.OverflowException: Exception of type System.OverflowException was thrown. at ExceptionTestClass.Main()

Vererbungshierarchie

System.Object
  System.Exception
     Abgeleitete Klassen

Threadsicherheit

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

Exception-Member
System-Namespace
SystemException
ApplicationException-Klasse

Weitere Ressourcen

Behandeln und Auslösen von Ausnahmen
Verpacken und Bereitstellen von Ressourcen