Exporter (0) Imprimer
Développer tout

MethodBody, classe

Remarque : cette classe est nouvelle dans le .NET Framework version 2.0.

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

Espace de noms : System.Reflection
Assembly : mscorlib (dans mscorlib.dll)

[ComVisibleAttribute(true)] 
public sealed class MethodBody
/** @attribute ComVisibleAttribute(true) */ 
public final class MethodBody
ComVisibleAttribute(true) 
public final class MethodBody

La classe MethodBody fournit un accès aux informations à propos des variables locales et des clauses de gestion des exceptions dans un corps de méthode, ainsi qu'un accès au langage intermédiaire Microsoft (MSIL) 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, afin de résoudre les jetons du corps de méthode en objets Type, en objets MethodInfo et en objets FieldInfo qui fournissent des informations détaillées sur des types, méthodes et champs auxquels le MSIL accède dans le corps de méthode.

RemarqueRemarque

L'analyse du corps d'une méthode requiert une connaissance approfondie des formats de métadonnées et d'instructions MSIL. Vous trouverez des informations dans la documentation relative à l'infrastructure du langage commun (CLI), plus précisément dans « Partition II: Metadata Definition and Semantics » et « Partition III: CIL Instruction Set ». La documentation est disponible en ligne à l'adresse http://msdn.microsoft.com/net/ecma/ et http://www.ecma-international.org/publications/standards/Ecma-335.htm.

Pour obtenir un objet MethodBody pour une méthode donnée, obtenez d'abord un objet MethodInfo pour la méthode, puis appelez la méthode GetMethodBody de l'objet MethodInfo.

L'exemple de code suivant définit une méthode de test nommée MethodBodyExample et affiche ses informations de variable locale ainsi que ses clauses de gestion des exceptions. La méthode MethodBase.GetMethodBody est utilisée pour obtenir un objet MethodBody pour la méthode test.

L'exemple utilise la propriété LocalVariables pour obtenir une liste d'objets LocalVariableInfo, puis il affiche leurs types et leur ordre d'index. La propriété ExceptionHandlingClauses permet d'obtenir la liste des clauses de gestion des exceptions.

RemarqueRemarque

Tous les langages informatiques ne peuvent pas générer de clauses ExceptionHandlingClauseOptions.Filter. L'exemple Visual Basic montre une clause de filtre, utilisant une expression When Visual Basic, qui est omise des exemples relatifs aux autres langages.

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

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

System.Object
  System.Reflection.MethodBody

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

Le .NET Framework ne prend pas en charge toutes les versions de chaque plate-forme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise.

.NET Framework

Prise en charge dans : 2.0

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft