MethodBody.InitLocals Propriété

Définition

Espace de noms:

System.Reflection

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

MethodBody.cs

Obtient une valeur indiquant si les variables locales du corps de méthode sont initialisées aux valeurs par défaut pour leurs types.

C#

public virtual bool InitLocals { get; }

Valeur de propriété

Boolean

true si le corps de méthode contient du code pour affecter aux variables locales la valeur null pour les types référence, ou la valeur initialisée à zéro pour les types valeur ; sinon, false.

Exemples

L’exemple de code suivant définit une méthode de test nommée MethodBodyExample et 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. Les MaxStackSize propriétés et InitLocals sont affichées.

Cet exemple de code fait partie d’un exemple plus grand fourni pour 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#

    }

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

Remarques

La InitLocals propriété fait référence à des variables qui ne sont pas explicitement initialisées, c’est-à-dire des variables déclarées avec une syntaxe, par int x; exemple en C# ou Dim x As Integer en Visual Basic.

Les variables de null référence sont initialisées à par défaut. Les variables numériques sont initialisées à zéro.

S’applique à