ExceptionHandlingClause 类

定义

表示结构化异常处理块中的子句。

public class ExceptionHandlingClause
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ExceptionHandlingClause
[System.Runtime.InteropServices.ComVisible(true)]
public class ExceptionHandlingClause
继承
ExceptionHandlingClause
属性

示例

下面的代码示例定义名为 MethodBodyExample的测试方法,并显示其本地变量信息和异常处理子句。 方法 MethodBase.GetMethodBody 用于获取 MethodBody 测试方法的对象。 属性 ExceptionHandlingClauses 用于获取对象列表 ExceptionHandlingClause 并显示其属性。

可以使用 Ildasm.exe 检查已编译代码示例的 MSIL,以查看偏移量和长度的计算方式。

此代码是类主题中较大示例的 MethodBody 一部分。

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

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

注解

ExceptionHandlingClause 提供有关 ... 中的 try子句的信息。catch... finally 块 (Try...Catch...Finally 在 Visual Basic) 中。 若要在方法中获取异常处理子句的列表,请获取 MethodInfo 表示 该方法的 。 GetMethodBody使用 方法获取 MethodBody 对象,然后使用 ExceptionHandlingClauses 属性获取子句列表。

备注

使用异常处理子句需要全面了解元数据和 Microsoft 中间语言 (MSIL) 指令格式。 可以在 公共语言基础结构 (CLI) 文档中找到信息,尤其是“分区 II:元数据定义和语义”。

构造函数

ExceptionHandlingClause()

初始化 ExceptionHandlingClause 类的新实例。

属性

CatchType

获取由此子句处理的异常类型。

FilterOffset

获取用户提供的筛选代码在方法体内的偏移量(以字节为单位)。

Flags

获取一个值,该值指示此异常处理子句是 finally 子句、类型筛选的子句还是用户筛选的子句。

HandlerLength

获取此异常处理子句的主体的长度(以字节为单位)。

HandlerOffset

获取此异常处理子句在方法体内的偏移量(以字节为单位)。

TryLength

包括此异常处理子句的 try 块的总长度(以字节为单位)。

TryOffset

包括此异常处理子句的 try 块在方法内的偏移量(以字节为单位)。

方法

Equals(Object)

确定指定对象是否等于当前对象。

(继承自 Object)
GetHashCode()

作为默认哈希函数。

(继承自 Object)
GetType()

获取当前实例的 Type

(继承自 Object)
MemberwiseClone()

创建当前 Object 的浅表副本。

(继承自 Object)
ToString()

异常处理子句的字符串表示形式。

适用于

产品 版本
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1

另请参阅