MethodBody.ExceptionHandlingClauses Property

 
System_CAPS_noteNote

The .NET API Reference documentation has a new home. Visit the .NET API Browser on docs.microsoft.com to see the new experience.

Gets a list that includes all the exception-handling clauses in the method body.

Namespace:   System.Reflection
Assembly:  mscorlib (in mscorlib.dll)

public virtual IList<ExceptionHandlingClause> ExceptionHandlingClauses { get; }

Property Value

Type: System.Collections.Generic.IList<ExceptionHandlingClause>

An IList<T> of ExceptionHandlingClause objects representing the exception-handling clauses in the body of the method.

The list includes all clauses from all try blocks in the method body. Each ExceptionHandlingClause object contains information that identifies the try block with which it is associated.

System_CAPS_noteNote

Working with exception-handling clauses requires a thorough understanding of metadata and MSIL instruction formats. Information can be found in the Common Language Infrastructure (CLI) documentation, especially "Partition II: Metadata Definition and Semantics" and "Partition III: CIL Instruction Set". The documentation is available online; see ECMA C# and Common Language Infrastructure Standards on MSDN and Standard ECMA-335 - Common Language Infrastructure (CLI) on the Ecma International Web site.

The following code example defines a test method named MethodBodyExample and displays information about its 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.

System_CAPS_noteNote

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

.NET Framework
Available since 2.0
Return to top
Show: