Lire en anglais

Partager via


ExceptionHandlingClause Classe

Définition

Représente une clause dans un bloc de gestion des exceptions structuré.

C#
public class ExceptionHandlingClause
C#
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ExceptionHandlingClause
C#
[System.Runtime.InteropServices.ComVisible(true)]
public class ExceptionHandlingClause
Héritage
ExceptionHandlingClause
Attributs

Exemples

L’exemple de code suivant définit une méthode de test nommée MethodBodyExampleet affiche ses informations de variable locale et ses clauses de gestion des exceptions. La MethodBase.GetMethodBody méthode est utilisée pour obtenir un MethodBody objet pour la méthode de test. La ExceptionHandlingClauses propriété est utilisée pour obtenir une liste d’objets ExceptionHandlingClause et afficher leurs propriétés.

Vous pouvez utiliser Ildasm.exe pour examiner le MSIL à la recherche de l’exemple de code compilé, afin de voir comment les décalages et les longueurs sont calculés.

Ce code fait partie d’un exemple plus large situé dans la rubrique de classe MethodBody .

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

Remarques

La ExceptionHandlingClause classe fournit des informations sur les clauses d’un try...catch... finally bloquer (Try...Catch...Finally en Visual Basic). Pour obtenir la liste des clauses de gestion des exceptions dans une méthode, obtenez un MethodInfo qui représente la méthode . Utilisez la GetMethodBody méthode pour obtenir un MethodBody objet, puis utilisez la ExceptionHandlingClauses propriété pour obtenir la liste des clauses.

Note

L’utilisation de clauses de gestion des exceptions nécessite une compréhension approfondie des métadonnées et des formats d’instructions MSIL (Microsoft Intermediate Language). Vous trouverez des informations dans la documentation cli (Common Language Infrastructure), en particulier « Partition II : Définition et sémantique des métadonnées ».

Constructeurs

ExceptionHandlingClause()

Initialise une nouvelle instance de la classe ExceptionHandlingClause.

Propriétés

CatchType

Obtient le type d'exception géré par cette clause.

FilterOffset

Obtient l'offset dans le corps de méthode, en octets, du code de filtre fourni par l'utilisateur.

Flags

Obtient une valeur indiquant si cette clause de gestion des exceptions est une clause finally, une clause filtrée par type ou une clause filtrée par utilisateur.

HandlerLength

Obtient la longueur, en octets, du corps de cette clause de gestion des exceptions.

HandlerOffset

Obtient l'offset dans le corps de méthode, en octets, de cette clause de gestion des exceptions.

TryLength

Longueur totale, en octets, du bloc try qui inclut cette clause de gestion des exceptions.

TryOffset

Offset dans la méthode, en octets, du bloc try qui inclut cette clause de gestion des exceptions.

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ToString()

Représentation sous forme de chaîne de la clause de gestion des exceptions.

S’applique à

Produit Versions
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1

Voir aussi