ExceptionHandlingClause Klasa

Definicja

Przestrzeń nazw:

System.Reflection

Zestawy:

netstandard.dll, System.Runtime.dll

Źródło:

ExceptionHandlingClause.cs

Reprezentuje klauzulę w bloku obsługi wyjątków ustrukturyzowanych.

C#

public class ExceptionHandlingClause

Dziedziczenie

Object

ExceptionHandlingClause

Przykłady

Poniższy przykład kodu definiuje metodę testową o nazwie MethodBodyExamplei wyświetla informacje o zmiennej lokalnej oraz klauzule obsługi wyjątków. Metoda MethodBase.GetMethodBody służy do uzyskiwania MethodBody obiektu dla metody testowej. Właściwość ExceptionHandlingClauses służy do uzyskiwania listy obiektów i wyświetlania ExceptionHandlingClause ich właściwości.

Możesz użyć Ildasm.exe do zbadania MSIL dla skompilowanego przykładu kodu, aby zobaczyć, jak są obliczane przesunięcia i długości.

Ten kod jest częścią większego przykładu znajdującego się w temacie MethodBody klasy.

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

Uwagi

Klasa ExceptionHandlingClause zawiera informacje o klauzulach w try...catch... finally blokuj (Try...Catch...Finally w visual basic). Aby uzyskać listę klauzul obsługi wyjątków w metodzie, uzyskaj metodę reprezentującą MethodInfo metodę . GetMethodBody Użyj metody , aby uzyskać MethodBody obiekt, a następnie użyj ExceptionHandlingClauses właściwości , aby uzyskać listę klauzul.

Uwaga

Praca z klauzulami obsługi wyjątków wymaga dokładnego zrozumienia metadanych i formatów instrukcji języka pośrednich firmy Microsoft (MSIL). Informacje można znaleźć w dokumentacji infrastruktury języka wspólnego (CLI), zwłaszcza "Partition II: Metadata Definition and Semantics" (Partycja II: definicja metadanych i semantyka).

Konstruktory

ExceptionHandlingClause()

Inicjuje nowe wystąpienie klasy ExceptionHandlingClause.

Właściwości

CatchType	Pobiera typ wyjątku obsługiwanego przez tę klauzulę.
FilterOffset	Pobiera przesunięcie w treści metody w bajtach kodu filtru dostarczonego przez użytkownika.
Flags	Pobiera wartość wskazującą, czy ta klauzula obsługi wyjątków jest klauzulą w końcu, klauzulą filtrowaną typu lub klauzulą filtrowaną przez użytkownika.
HandlerLength	Pobiera długość treści tej klauzuli obsługi wyjątków w bajtach.
HandlerOffset	Pobiera przesunięcie w treści metody w bajtach tej klauzuli obsługi wyjątków.
TryLength	Łączna długość w bajtach bloku try, który zawiera tę klauzulę obsługi wyjątków.
TryOffset	Przesunięcie w metodzie w bajtach bloku try, który zawiera tę klauzulę obsługi wyjątków.

Metody

Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetType()	Type Pobiera bieżące wystąpienie. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
ToString()	Ciąg reprezentujący klauzulę obsługi wyjątków.

Dotyczy

Zobacz też

• MethodBody
• ExceptionHandlingClauses
• ExceptionHandlingClauseOptions