MethodBase.GetMethodBody Метод

Определение

При переопределении в производном классе возвращает объект MethodBody, который обеспечивает доступ к потоку MSIL, локальным переменным и исключениям для текущего метода.

public:
 virtual System::Reflection::MethodBody ^ GetMethodBody();
public virtual System.Reflection.MethodBody? GetMethodBody ();
public virtual System.Reflection.MethodBody GetMethodBody ();
abstract member GetMethodBody : unit -> System.Reflection.MethodBody
override this.GetMethodBody : unit -> System.Reflection.MethodBody
Public Overridable Function GetMethodBody () As MethodBody

Возвращаемое значение

Объект MethodBody, который обеспечивает доступ к потоку MSIL, локальным переменным и исключениям для текущего метода.

Исключения

Если этот метод не переопределен в производном классе, он является недопустимым.

Примеры

В следующем примере кода определяется метод теста с именем MethodBodyExample и отображаются сведения о локальной переменной и предложения обработки исключений. Метод MethodBase.GetMethodBody используется для получения MethodBody объекта для метода теста.

Свойство LocalVariables используется для получения списка LocalVariableInfo объектов и отображения их типов и порядка индексов. Свойство ExceptionHandlingClauses используется для получения списка предложений обработки исключений.

Примечание

Не все языки компьютеров могут создавать ExceptionHandlingClauseOptions.Filter предложения. В примере Visual Basic показано предложение фильтра с использованием выражения Visual Basic When , которое опущено в примерах для других языков.

#using <System.dll>

using namespace System;
using namespace System::Reflection;

public ref class Example
{
    // 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 == nullptr)
            {
                throw gcnew ArgumentNullException("The argument cannot " +
                    "be null.");
            }
            if (arg->GetType() == String::typeid)
            {
                throw gcnew 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 (ArgumentException^ ex)
        {
            Console::WriteLine("Ordinary exception-handling clause caught:" +
                " {0}", ex->GetType());
        }        
        finally
        {
            var1 = 3033;
            var2 = "Another string.";
        }
    }
};

int main()
{ 
    // Get method body information.
    MethodInfo^ mi = 
        Example::typeid->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();
    for each (LocalVariableInfo^ lvi in mb->LocalVariables)
    {
        Console::WriteLine("Local variable: {0}", lvi);
    }

    // Display exception handling clauses.
    Console::WriteLine();
    for each(ExceptionHandlingClause^ exhc in mb->ExceptionHandlingClauses)
    {
        Console::WriteLine(exhc->Flags.ToString());

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

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

//This code example produces output similar to the following:
//
//Method: Void MethodBodyExample(System.Object)
//    Local variables are initialized: False
//    Maximum number of items on the operand stack: 4
//
//Local variable: System.ArgumentException (0)
//Local variable: System.String (1)
//Local variable: System.Int32 (2)
//Clause
//    Type of exception: System.ArgumentException
//       Handler Length: 29
//       Handler Offset: 78
//     Try Block Length: 65
//     Try Block Offset: 13
//Finally
//       Handler Length: 13
//       Handler Offset: 113
//     Try Block Length: 100
//     Try Block Offset: 13
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
Imports System.Reflection

Public Class Example

    Public Shared Sub Main()

        ' Demonstrate the effect of the Visual Basic When keyword, which
        ' generates a Filter clause in the Try block.
        Dim e As New Example()
        Console.WriteLine()
        e.MethodBodyExample("String argument")
        e.MethodBodyExample(Nothing)

        ' Get method body information.
        Dim mi As MethodInfo = _
            GetType(Example).GetMethod("MethodBodyExample")
        Dim mb As MethodBody = mi.GetMethodBody()
        Console.WriteLine(vbCrLf & "Method: {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()
        For Each lvi As LocalVariableInfo In mb.LocalVariables
            Console.WriteLine("Local variable: {0}", lvi)
        Next

        ' Display exception handling clauses.
        Console.WriteLine()
        For Each ehc As ExceptionHandlingClause 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. 
            Select Case ehc.Flags
                Case ExceptionHandlingClauseOptions.Filter
                    Console.WriteLine("        Filter Offset: {0}", _
                        ehc.FilterOffset)
                Case ExceptionHandlingClauseOptions.Finally
                Case Else
                    Console.WriteLine("    Type of exception: {0}", _
                        ehc.CatchType)
            End Select

            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)
        Next
    End Sub

    ' This test method is executed at the beginning of Main, to show
    ' how the Filter clause works. The Filter clause is generated by 
    ' a Visual Basic When expression. If arg is Nothing, this method
    ' throws ArgumentNullException, which is caught by the filter
    ' clause. If arg is a string, the method throws ArgumentException,
    ' which does not match the filter clause.
    '
    ' Sub Main also contains code to analyze this method, using 
    ' the properties and methods of the MethodBody class.
    Public Sub MethodBodyExample(ByVal arg As Object)

        ' Define some local variables. In addition to these variables,
        ' the local variable list includes the variables scoped to 
        ' the catch clauses.
        Dim var1 As Integer = 42
        Dim var2 As String = "Forty-two"

        Try
            ' Depending on the input value, throw an ArgumentException or 
            ' an ArgumentNullException to test the Catch clauses.
            '
            If arg Is Nothing Then
                Throw New ArgumentNullException("The argument cannot be Nothing.")
            End If
            If arg.GetType() Is GetType(String) Then
                Throw New ArgumentException("The argument cannot be a string.")
            End If
        
        ' The When expression makes this a filter clause. The expression 
        ' selects only exceptions that derive from the ArgumentException
        ' class. Other exceptions, including ArgumentException itself, 
        ' are not handled by this filter clause.
        Catch ex As ArgumentException _
            When ex.GetType().IsSubclassOf(GetType(ArgumentException))

            Console.WriteLine("Filter clause caught: {0}", ex.GetType())
        
        ' This catch clause handles the ArgumentException class, and
        ' any other class derived from Exception.
        Catch ex As Exception
            Console.WriteLine("Ordinary exception-handling clause caught: {0}", _
                ex.GetType())

        Finally
            var1 = 3033
            var2 = "Another string."
        End Try
    End Sub
End Class

' This code example produces output similar to the following:
'
'Ordinary exception-handling clause caught: System.ArgumentException
'Filter clause caught: System.ArgumentNullException
'
'Method: Void MethodBodyExample(System.Object)
'    Local variables are initialized: True
'    Maximum number of items on the operand stack: 3
'
'Local variable: System.Int32 (0)
'Local variable: System.String (1)
'Local variable: System.ArgumentException (2)
'Local variable: System.Exception (3)
'
'Filter
'        Filter Offset: 0
'       Handler Length: 19
'       Handler Offset: 99
'     Try Block Length: 45
'     Try Block Offset: 9
'Clause
'    Type of exception: System.Exception
'       Handler Length: 25
'       Handler Offset: 118
'     Try Block Length: 45
'     Try Block Offset: 9
'Finally
'       Handler Length: 13
'       Handler Offset: 153
'     Try Block Length: 144
'     Try Block Offset: 9

Комментарии

Для его использования не нужно переопределять GetMethodBody . Метод можно вызвать для GetMethodBodyMethodInfo объектов и ConstructorInfo , так как метод переопределен в версиях среды выполнения этих классов. Например, версия MethodInfo среды выполнения класса является производным MethodInfo от класса , который, в свою очередь, является производным MethodBase от класса .

Применяется к