Exportar (0) Imprimir
Expandir Tudo
Expandir Minimizar
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original
Este tópico ainda não foi avaliado como - Avalie este tópico

ExceptionHandlingClauseOptions Enumeração

Identifica tipos de cláusulas de tratamento de exceção.

Essa enumeração tem um atributo FlagsAttribute que permite uma combinação de seus valores membro bit a bit.

Namespace:  System.Reflection
Assembly:  mscorlib (em mscorlib. dll)
[FlagsAttribute]
[ComVisibleAttribute(true)]
public enum ExceptionHandlingClauseOptions
Nome do membroDescrição
ClauseThe cláusula accepts Tudo Exceptions that derive From a specified tipo.
FilterA cláusula contém instruções especificado pelo usuário que determinam se a exceção deve ser ignorada (isto é, se deve continuar a execução normal), ser tratado pelo manipulador de associado ou ser passado para a Avançar cláusula.
FinallyIs the cláusula executado whenever the Bloquear try exits, whether through normal Controlar fluxo or because of an não manipulado exceção.
FaultA cláusula é executada se ocorrer uma exceção, mas não na conclusão de fluxo de Controlarar normal.

To examine the exception-handling clauses in a method, obtain a MethodInfo object and call the GetMethodBody method to obtain the method body.Use the ExceptionHandlingClauses property to obtain a list of ExceptionHandlingClause objects.

ObservaçãoObservação:

Trabalhando com cláusulas de tratamento de exceção requer uma compreensão completa de metadados e formatos de instrução Idioma intermediária (MSIL) Microsoft.Informações podem ser encontradas na documentação de infra-estrutura de idioma comum (CLI), especialmente " partição II: Os metadados de definição e semântica partição "e" iii: Definir Instruções CIL".The documentation is available online at http://msdn.microsoft.com/net/ecma/ and http://www.ecma-international.org/publications/standards/Ecma-335.htm.

The following code example defines a test method named MethodBodyExample, and displays its local variable information and exception-handling clauses.The MethodBase.GetMethodBody method is used to obtain a MethodBody object for the test method.The ExceptionHandlingClauses property is used to obtain a list of ExceptionHandlingClause objects and display their properties.

ObservaçãoObservação:

Not all computer languages can generate ExceptionHandlingClauseOptions.Filter clauses.The Visual Basic example shows a filter clause, using a Visual Basic When expression, which is omitted from the examples for other languages.

This code is part of a larger example provided for the MethodBody class.

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


Isso foi útil para você?
(1500 caracteres restantes)
Agradecemos os seus comentários

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft. Todos os direitos reservados.