MethodBase.GetMethodBody 方法

定义

命名空间:

System.Reflection

程序集:

netstandard.dll, System.Runtime.dll

Source:

MethodBase.cs

在派生类中重写后，获取 MethodBody 对象，该对象提供对 MSIL 流、局部变量和当前方法的异常的访问。

C#

public virtual System.Reflection.MethodBody? GetMethodBody();

返回

MethodBody

MethodBody 对象，提供对 MSIL 流、局部变量和当前方法的异常的访问。

例外

InvalidOperationException

除非在派生类中重写，否则此方法无效。

示例

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

属性 LocalVariables 用于获取对象列表 LocalVariableInfo 并显示其类型和索引顺序。 属性 ExceptionHandlingClauses 用于获取异常处理子句的列表。

备注

并非所有计算机语言都可以生成 ExceptionHandlingClauseOptions.Filter 子句。 Visual Basic 示例演示了一个使用 Visual Basic When 表达式的 filter 子句，该子句在其他语言的示例中省略了该子句。

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

        // Display information about the local variables in the
        // method body.
        Console.WriteLine();
        foreach (LocalVariableInfo lvi in mb.LocalVariables)
        {
            Console.WriteLine("Local variable: {0}", lvi);
        }

        // 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
//
//Local variable: System.Int32 (0)
//Local variable: System.String (1)
//Local variable: System.Exception (2)
//Local variable: System.Boolean (3)
//
//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

注解

无需重写 GetMethodBody 即可使用它。 可以在 和 ConstructorInfo 对象上MethodInfo调用 GetMethodBody 方法，因为方法在这些类的运行时版本中被重写。 例如，类的 MethodInfo 运行时版本派生自 MethodInfo 类，类又派生自 类 MethodBase 。

适用于