ExceptionHandlingClauseOptions Enumeration

Definition

Namespace:

System.Reflection

Assembly:

System.Runtime.dll

Identifiziert Arten von Klauseln für die Ausnahmebehandlung.

Diese Enumeration unterstützt eine bitweise Kombination ihrer Memberwerte.

C#

[System.Flags]
public enum ExceptionHandlingClauseOptions

Vererbung

Object

ValueType

Enum

ExceptionHandlingClauseOptions

Attribute

FlagsAttribute

Felder

Name	Wert	Beschreibung
Clause	0	Die Klausel akzeptiert alle Ausnahmen, die von einem angegebenen Typ abgeleitet sind.
Fault	4	Die Klausel wird ausgeführt, wenn eine Ausnahme auftritt, nicht aber bei Vervollständigung einer normalen Ablaufsteuerung.
Filter	1	Die 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.
Finally	2	Die Klausel wird immer dann ausgeführt, wenn der try-Block beendet wird, sei es durch normale Ablaufsteuerung oder aufgrund einer nicht behandelten Ausnahme.

Beispiele

Im folgenden Codebeispiel wird eine Testmethode mit dem Namen MethodBodyExampledefiniert und ihre lokalen Variableninformationen und Ausnahmebehandlungsklauseln angezeigt. Die MethodBase.GetMethodBody -Methode wird verwendet, um ein MethodBody Objekt für die Testmethode abzurufen. Die ExceptionHandlingClauses -Eigenschaft wird verwendet, um eine Liste von ExceptionHandlingClause Objekten abzurufen und deren Eigenschaften anzuzeigen.

Dieser Code ist Teil eines größeren Beispiels für die MethodBody -Klasse.

C#

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

C#

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

C#

    }

    // 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.");
            }
        }

        // This filter clause selects only exceptions that derive
        // from the ArgumentException class.
        // Other exceptions, including ArgumentException itself,
        // are not handled by this filter clause.
        catch (ArgumentException ex) when (ex.GetType().IsSubclassOf(typeof(ArgumentException)))
        {
            Console.WriteLine("Filter clause caught: {0}", ex.GetType());
        }

        // 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

C#

//
//Filter
//      Filter Offset: 71
//      Handler Length: 23
//      Handler Offset: 116
//      Try Block Length: 61
//      Try Block Offset: 10
//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

Hinweise

Um die Ausnahmebehandlungsklauseln in einer -Methode zu untersuchen, rufen Sie ein -Objekt ab MethodInfo , und rufen Sie die GetMethodBody -Methode auf, um den Methodentext abzurufen. Verwenden Sie die ExceptionHandlingClauses -Eigenschaft, um eine Liste von ExceptionHandlingClause Objekten abzurufen.

Hinweis

Das Arbeiten mit Ausnahmebehandlungsklauseln erfordert ein gründliches Verständnis der Metadaten und MSIL-Anweisungsformate (Microsoft Intermediate Language). Informationen finden Sie in der Dokumentation zur Common Language Infrastructure (CLI), insbesondere "Partition II: Metadatendefinition und Semantik".

Gilt für:

Weitere Informationen

• MethodBody
• ExceptionHandlingClause