ExceptionHandlingClauseOptions Enumerazione

Definizione

Spazio dei nomi:

System.Reflection

Assembly:

System.Runtime.dll

Identifica i tipi di clausola di gestione delle eccezioni.

Questa enumerazione supporta una combinazione bit per bit dei rispettivi valori dei membri.

C#

[System.Flags]
public enum ExceptionHandlingClauseOptions

Ereditarietà

Object

ValueType

Enum

ExceptionHandlingClauseOptions

Attributi

FlagsAttribute

Campi

Nome	Valore	Descrizione
Clause	0	La clausola accetta tutte le eccezioni che derivano da un tipo specificato.
Fault	4	La clausola viene eseguita se si verifica un'eccezione ma non al termine di un normale flusso di controllo.
Filter	1	La 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.
Finally	2	La 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.

Esempio

Nell'esempio di codice seguente viene definito un metodo di test denominato MethodBodyExamplee vengono visualizzate le informazioni sulle variabili locali e le clausole di gestione delle eccezioni. Il MethodBase.GetMethodBody metodo viene utilizzato per ottenere un MethodBody oggetto per il metodo di test. La ExceptionHandlingClauses proprietà viene utilizzata per ottenere un elenco di ExceptionHandlingClause oggetti e visualizzare le relative proprietà.

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

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);

C#

// 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);
}

C#

    }

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

C#

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

Commenti

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

Nota

L'uso delle clausole di gestione delle eccezioni richiede una conoscenza approfondita dei metadati e dei formati di istruzioni MSIL (Microsoft Intermediate Language). Le informazioni sono disponibili nella documentazione di Common Language Infrastructure (CLI), in particolare "Partition II: Metadata Definition and Semantics".

Si applica a

Vedi anche

• MethodBody
• ExceptionHandlingClause