(0) exportieren Drucken
Alle erweitern
Erweitern Minimieren

ExceptionHandlingClauseOptions-Enumeration

Hinweis: Diese Enumeration ist neu in .NET Framework, Version 2.0.

Identifiziert Arten von Klauseln für die Ausnahmebehandlung.

Diese Enumeration verfügt über ein FlagsAttribute -Attribut, das die bitweise Kombination der Memberwerte zulässt.

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

[ComVisibleAttribute(true)] 
[FlagsAttribute] 
public enum ExceptionHandlingClauseOptions
/** @attribute ComVisibleAttribute(true) */ 
/** @attribute FlagsAttribute() */ 
public enum ExceptionHandlingClauseOptions
ComVisibleAttribute(true) 
FlagsAttribute 
public enum ExceptionHandlingClauseOptions

 MembernameBeschreibung
ClauseDie Klausel akzeptiert alle Ausnahmen, die von einem angegebenen Typ abgeleitet sind. 
FaultDie Klausel wird ausgeführt, wenn eine Ausnahme auftritt, nicht aber bei Vervollständigung einer normalen Ablaufsteuerung. 
FilterDie Klausel enthält benutzerdefinierte Anweisungen, die bestimmen, ob die Ausnahme ignoriert werden soll (das heißt, dass die normale Ausführung fortgesetzt wird), ob sie durch den zugeordneten Handler behandelt werden soll, oder ob sie an die nächste Klausel übergeben werden soll. 
FinallyDie Klausel wird immer dann ausgeführt, wenn der try-Block beendet wird, sei es durch normale Ablaufsteuerung oder aufgrund einer nicht behandelten Ausnahme. 

Wenn Sie die Klauseln für die Ausnahmebehandlung in einer Methode überprüfen möchten, rufen Sie ein MethodInfo-Objekt ab, und rufen Sie die GetMethodBody-Methode auf, um den Methodentext zu erhalten. Mit der ExceptionHandlingClauses-Eigenschaft können Sie eine Liste von ExceptionHandlingClause-Objekten abrufen.

HinweisHinweis

Das Arbeiten mit Klauseln für die Ausnahmebehandlung erfordert ein tiefgreifendes Verständnis für Metadaten und für MSIL-Anweisungsformate (Microsoft Intermediate Language). Informationen finden Sie in der CLI-Dokumentation (Common Language Infrastructure), insbesondere in "Partition II: Metadata Definition and Semantics" und "Partition III: CIL Instruction Set". Die Dokumentation steht online unter http://msdn.microsoft.com/net/ecma/ und http://www.ecma-international.org/publications/standards/Ecma-335.htm zur Verfügung (nur auf Englisch verfügbar).

Im folgenden Codebeispiel wird die Testmethode MethodBodyExample definiert. Außerdem werden ihre lokalen Variableninformationen sowie ihre Klauseln bei Ausnahmebehandlung angezeigt. Die MethodBase.GetMethodBody-Methode wird verwendet, um ein MethodBody-Objekt für die Testmethode abzurufen. Die ExceptionHandlingClauses-Eigenschaft wird zum Abrufen einer Liste mit ExceptionHandlingClause-Objekten und zum Anzeigen ihrer Eigenschaften verwendet.

HinweisHinweis

Nicht in allen Computersprachen können ExceptionHandlingClauseOptions.Filter-Klauseln generiert werden. Im Visual Basic-Beispiel wird eine Filterklausel veranschaulicht, die einen When-Ausdruck aus Visual Basic verwendet, der bei den Beispielen für andere Sprachen ausgelassen wird.

Dieser Code ist Teil eines umfangreicheren Beispiels für die MethodBody-Klasse.

using System;
using System.Reflection;

public class Example
{
    public static void Main()
    {
        // Get method body information.
        MethodInfo mi = typeof(Example).GetMethod("MethodBodyExample");
        MethodBody mb = mi.GetMethodBody();
        Console.WriteLine("\r\nMethod: {0}", mi);

        // Display the general information included in the 
        // MethodBody object.
        Console.WriteLine("    Local variables are initialized: {0}", 
            mb.InitLocals);
        Console.WriteLine("    Maximum number of items on the operand stack: {0}", 
            mb.MaxStackSize);
...
        // Display exception handling clauses.
        Console.WriteLine();
        foreach (ExceptionHandlingClause ehc in mb.ExceptionHandlingClauses)
        {
            Console.WriteLine(ehc.Flags.ToString());

            // The FilterOffset property is meaningful only for Filter
            // clauses. The CatchType property is not meaningful for 
            // Filter or Finally clauses. 
            switch (ehc.Flags)
            {
                case ExceptionHandlingClauseOptions.Filter:
                    Console.WriteLine("        Filter Offset: {0}", 
                        ehc.FilterOffset);
                    break;
                case ExceptionHandlingClauseOptions.Finally:
                    break;
                default:
                    Console.WriteLine("    Type of exception: {0}", 
                        ehc.CatchType);
                    break;
            }

            Console.WriteLine("       Handler Length: {0}", ehc.HandlerLength);
            Console.WriteLine("       Handler Offset: {0}", ehc.HandlerOffset);
            Console.WriteLine("     Try Block Length: {0}", ehc.TryLength);
            Console.WriteLine("     Try Block Offset: {0}", ehc.TryOffset);
        }
...    }

    // The Main method contains code to analyze this method, using
    // the properties and methods of the MethodBody class.
    public void MethodBodyExample(object arg)
    {
        // Define some local variables. In addition to these variables,
        // the local variable list includes the variables scoped to 
        // the catch clauses.
        int var1 = 42;
        string var2 = "Forty-two";

        try
        {
            // Depending on the input value, throw an ArgumentException or 
            // an ArgumentNullException to test the Catch clauses.
            if (arg == null)
            {
                throw new ArgumentNullException("The argument cannot be null.");
            }
            if (arg.GetType() == typeof(string))
            {
                throw new ArgumentException("The argument cannot be a string.");
            }        
        }

        // There is no Filter clause in this code example. See the Visual 
        // Basic code for an example of a Filter clause.

        // This catch clause handles the ArgumentException class, and
        // any other class derived from Exception.
        catch(Exception ex)
        {
            Console.WriteLine("Ordinary exception-handling clause caught: {0}", 
                ex.GetType());
        }        
        finally
        {
            var1 = 3033;
            var2 = "Another string.";
        }
    }
}

// This code example produces output similar to the following:
//
//Method: Void MethodBodyExample(System.Object)
//    Local variables are initialized: True
//    Maximum number of items on the operand stack: 2
...//
//Clause
//    Type of exception: System.Exception
//       Handler Length: 21
//       Handler Offset: 70
//     Try Block Length: 61
//     Try Block Offset: 9
//Finally
//       Handler Length: 14
//       Handler Offset: 94
//     Try Block Length: 85
//     Try Block Offset: 9

Windows 98, Windows 2000 SP4, Windows Millennium Edition, 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.

.NET Framework

Unterstützt in: 2.0
Anzeigen:
© 2014 Microsoft