MethodBody Classe

Définition

Espace de noms:

System.Reflection

Assembly:

System.Runtime.dll

Source:

MethodBody.cs

Fournit un accès aux métadonnées et MSIL pour le corps d'une méthode.

C#

public class MethodBody

Héritage

Object

MethodBody

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 une liste de clauses de gestion des exceptions.

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

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 constitue le corps de la méthode.

Vous pouvez utiliser les méthodes de résolution de jetons de la classe de module, telles que ResolveType, ResolveMethodet ResolveType, pour résoudre les jetons dans le corps de la méthode en Type objets, MethodInfo objets et FieldInfo objets qui fournissent des informations détaillées sur les types, méthodes et champs auxquels le MSIL accède dans le corps de la méthode.

Note

L’analyse des corps de méthode nécessite une compréhension approfondie des métadonnées et des formats d’instructions 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)

S’applique à