MethodBody Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Fournit un accès aux métadonnées et MSIL pour le corps d'une méthode.
public ref class MethodBodypublic ref class MethodBody sealedpublic class MethodBody[System.Runtime.InteropServices.ComVisible(true)]
public sealed class MethodBody[System.Runtime.InteropServices.ComVisible(true)]
public class MethodBodytype MethodBody = class[<System.Runtime.InteropServices.ComVisible(true)>]
type MethodBody = classPublic Class MethodBodyPublic NotInheritable Class MethodBody- Héritage
-
MethodBody
- Attributs
Exemples
L’exemple de code suivant définit une méthode de test nommée MethodBodyExample et affiche ses informations de variable locale et ses clauses de gestion des exceptions. La MethodBase.GetMethodBody méthode est utilisée pour obtenir un MethodBody objet pour la méthode de test.
L’exemple utilise la LocalVariables propriété pour obtenir une liste d’objets LocalVariableInfo , puis affiche leurs types et leur ordre d’index. La ExceptionHandlingClauses propriété est utilisée pour obtenir la liste des clauses de gestion des exceptions.
#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
Remarques
La MethodBody classe fournit l’accès aux informations sur les variables locales et les clauses de gestion des exceptions dans un corps de méthode, ainsi qu’au langage MSIL (Microsoft Intermediate Language) qui compose le corps de la méthode.
Vous pouvez utiliser les méthodes de résolution de jeton de la classe de module, telles que ResolveType, ResolveMethodet ResolveType, pour résoudre les jetons du corps de la méthode en objets, MethodInfo objets et FieldInfo objets qui fournissent des informations détaillées sur les types, méthodes et champs accessibles par MSIL dans le corps Type de la méthode.
Notes
L’analyse des corps de méthode nécessite une compréhension approfondie des métadonnées et des formats d’instruction MSIL. Vous trouverez des informations dans la documentation CLI (Common Language Infrastructure), en particulier « Partition II : Définition et sémantique des métadonnées ».
Pour obtenir un MethodBody objet pour une méthode donnée, commencez par obtenir un MethodInfo objet pour la méthode, puis appelez la méthode de GetMethodBody l’objetMethodInfo.
Constructeurs
| MethodBody() |
Initialise une nouvelle instance de la classe MethodBody. |
Propriétés
| ExceptionHandlingClauses |
Obtient une liste qui inclut toutes les clauses de gestion des exceptions dans le corps de la méthode. |
| InitLocals |
Obtient une valeur indiquant si les variables locales du corps de méthode sont initialisées aux valeurs par défaut pour leurs types. |
| LocalSignatureMetadataToken |
Obtient un jeton de métadonnées pour la signature qui décrit les variables locales pour la méthode dans les métadonnées. |
| LocalVariables |
Obtient la liste des variables locales déclarées dans le corps de méthode. |
| MaxStackSize |
Obtient le nombre maximal d'éléments sur le tas d'opérandes lorsque la méthode s'exécute. |
Méthodes
| Equals(Object) |
Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object) |
| GetHashCode() |
Fait office de fonction de hachage par défaut. (Hérité de Object) |
| GetILAsByteArray() |
Retourne le MSIL pour le corps de méthode, sous forme de tableau d'octets. |
| GetType() |
Obtient le Type de l'instance actuelle. (Hérité de Object) |
| MemberwiseClone() |
Crée une copie superficielle du Object actuel. (Hérité de Object) |
| ToString() |
Retourne une chaîne qui représente l'objet actuel. (Hérité de Object) |