Esporta (0) Stampa
Espandi tutto
Questo argomento non è stato ancora valutato - Valuta questo argomento

Classe MethodBody

Nota: questa classe è stata introdotta con .NET Framework versione 2.0.

Fornisce l'accesso ai metadati e al linguaggio MSIL (Microsoft Intermediate Language) relativi al corpo di un metodo.

Spazio dei nomi: System.Reflection
Assembly: mscorlib (in mscorlib.dll)

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

La classe MethodBody fornisce l'accesso a informazioni sulle variabili locali e le clausole di gestione delle eccezioni e al linguaggio MSIL che costituisce il corpo del metodo.

È possibile utilizzare i metodi di risoluzione dei token della classe del modulo, ad esempio ResolveType, ResolveMethod e ResolveType, per risolvere i token nel corpo del metodo per oggetti Type, MethodInfo e FieldInfo contenenti le informazioni dettagliate sui tipi, i metodi e i campi nel corpo del metodo a cui il linguaggio MSIL ha eseguito l'accesso.

NotaNota

Per eseguire l'analisi del corpo di un metodo è necessaria una conoscenza approfondita del formato di metadati e istruzioni MSIL. Per informazioni è possibile consultare la documentazione relativa a CLI (Common Language Infrastructure), in particolare le sezioni "Partition II: Metadata Definition and Semantics" e "Partition III: CIL Instruction Set". La documentazione è disponibile in linea agli indirizzi http://msdn.microsoft.com/net/ecma/ e http://www.ecma-international.org/publications/standards/Ecma-335.htm.

Per ottenere un oggetto MethodBody per un metodo specificato, ottenere prima un oggetto MethodInfo per il metodo, quindi chiamare il metodo GetMethodBody dell'oggetto MethodInfo.

Nell'esempio di codice riportato di seguito viene definito un metodo di prova con nome MethodBodyExample e ne vengono visualizzate le informazioni sulle variabili locali e le clausole di gestione delle eccezioni. Il metodo MethodBase.GetMethodBody viene utilizzato per ottenere un oggetto MethodBody per il metodo di prova.

Nell'esempio la proprietà LocalVariables è utilizzata per ottenere un elenco di oggetti LocalVariableInfo e per visualizzarne i tipi e l'ordine dell'indice. La proprietà ExceptionHandlingClauses viene utilizzata per ottenere un elenco di clausole di gestione delle eccezioni.

NotaNota

Non in tutti i linguaggi di computer è possibile generare clausole ExceptionHandlingClauseOptions.Filter. Nell'esempio di Visual Basic viene illustrata una clausola di filtro mediante un'espressione When di Visual Basic che viene omessa negli esempi relativi ad altri linguaggi.

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
I membri statici pubblici (Shared in Visual Basic) di questo tipo sono validi per le operazioni multithreading. I membri di istanza non sono garantiti come thread safe.

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema.

.NET Framework

Supportato in: 2.0
Il documento è risultato utile?
(1500 caratteri rimanenti)
Grazie per i commenti inviati.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft. Tutti i diritti riservati.