Questa documentazione è stata archiviata e non viene gestita.

Enumerazione ExceptionHandlingClauseOptions

Identifica i tipi di clausola di gestione delle eccezioni.

Questa enumerazione ha un attributo FlagsAttribute che consente una combinazione bit per bit dei valori dei membri.

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

[ComVisibleAttribute(true)] 
[FlagsAttribute] 
public enum ExceptionHandlingClauseOptions
/** @attribute ComVisibleAttribute(true) */ 
/** @attribute FlagsAttribute() */ 
public enum ExceptionHandlingClauseOptions
ComVisibleAttribute(true) 
FlagsAttribute 
public enum ExceptionHandlingClauseOptions

 Nome membroDescrizione
ClauseLa clausola accetta tutte le eccezioni che derivano da un tipo specificato. 
FaultLa clausola viene eseguita se si verifica un'eccezione ma non al termine di un normale flusso di controllo. 
FilterLa clausola contiene istruzioni specificate dall'utente che determinano se l'eccezione deve essere ignorata (ovvero se deve essere ripresa la normale esecuzione), se deve essere gestita dal gestore associato o se deve essere passata alla clausola successiva. 
FinallyLa clausola viene eseguita ogni volta che il blocco try viene chiuso, sia in seguito al normale flusso di controllo che a causa di un'eccezione non gestita. 

Per esaminare le clausole di gestione delle eccezioni in un metodo, ottenere un oggetto MethodInfo e chiamare il metodo GetMethodBody per ottenere il corpo del metodo. Utilizzare la proprietà ExceptionHandlingClauses per ottenere un elenco di oggetti ExceptionHandlingClause.

NotaNota:

Per utilizzare le clausole di gestione delle eccezioni è necessaria una conoscenza approfondita del formato di metadati e istruzioni MSIL (Microsoft Intermediate Language). 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.

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. La proprietà ExceptionHandlingClauses è utilizzata per ottenere un elenco di oggetti ExceptionHandlingClause e per visualizzarne le proprietà.

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.

Questo codice fa parte di un esempio più esaustivo fornito per la classe MethodBody.

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 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
...

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

Windows 98, Windows Server 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

Microsoft .NET Framework 3.0 è supportato in Windows Vista, Microsoft Windows XP SP2 e Windows Server 2003 SP1.

.NET Framework

Supportato in:
Mostra: