LocalBuilder 类

定义

命名空间:

System.Reflection.Emit

程序集:

System.Reflection.Emit.ILGeneration.dll

Source:

LocalBuilder.cs

表示方法或构造函数中的局部变量。

public ref class LocalBuilder sealed : System::Reflection::LocalVariableInfo

public sealed class LocalBuilder : System.Reflection.LocalVariableInfo

type LocalBuilder = class
    inherit LocalVariableInfo

Public NotInheritable Class LocalBuilder
Inherits LocalVariableInfo

继承

Object

LocalVariableInfo

LocalBuilder

示例

以下示例创建一个名为 Function1 的 static 方法（在 Visual Basic 中Shared），该方法返回一个字符串，并具有 Int32类型的参数。 在方法的正文中，代码示例创建表示两个局部变量的 LocalBuilder 对象，并设置局部变量的符号信息。 该方法不执行任何重要操作，但方法正文演示将参数存储到局部变量、将文本字符串存储到局部变量以及加载局部变量。

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Threading;
int main()
{
    // Create an assembly.
    AssemblyName^ myAssemblyName = gcnew AssemblyName;
    myAssemblyName->Name = "SampleAssembly";
    AssemblyBuilder^ myAssembly = Thread::GetDomain()->DefineDynamicAssembly( 
        myAssemblyName, AssemblyBuilderAccess::RunAndSave );

    // Create a module. For a single-file assembly the module
    // name is usually the same as the assembly name.
    ModuleBuilder^ myModule = myAssembly->DefineDynamicModule( 
        myAssemblyName->Name, myAssemblyName->Name + ".dll", true );

    // Define a public class 'Example'.
    TypeBuilder^ myTypeBuilder = myModule->DefineType( "Example", TypeAttributes::Public );

    // Create the 'Function1' public method, which takes an integer
    // and returns a string.
    MethodBuilder^ myMethod = myTypeBuilder->DefineMethod( "Function1", 
        MethodAttributes::Public | MethodAttributes::Static, String::typeid, 
        gcnew array<Type^> { int::typeid } );

    // Generate IL for 'Function1'. The function body demonstrates
    // assigning an argument to a local variable, assigning a 
    // constant string to a local variable, and putting the contents
    // of local variables on the stack.
    ILGenerator^ myMethodIL = myMethod->GetILGenerator();

    // Create local variables named myString and myInt.
    LocalBuilder^ myLB1 = myMethodIL->DeclareLocal( String::typeid );
    myLB1->SetLocalSymInfo( "myString" );
    Console::WriteLine( "local 'myString' type is: {0}", myLB1->LocalType );

    LocalBuilder^ myLB2 = myMethodIL->DeclareLocal( int::typeid );
    myLB2->SetLocalSymInfo( "myInt", 1, 2 );
    Console::WriteLine( "local 'myInt' type is: {0}", myLB2->LocalType );

    // Store the function argument in myInt.
    myMethodIL->Emit( OpCodes::Ldarg_0 );
    myMethodIL->Emit( OpCodes::Stloc_1 );

    // Store a literal value in myString, and return the value.
    myMethodIL->Emit( OpCodes::Ldstr, "string value"  );
    myMethodIL->Emit( OpCodes::Stloc_0 );
    myMethodIL->Emit( OpCodes::Ldloc_0 );
    myMethodIL->Emit( OpCodes::Ret );

    // Create "Example" class.
    Type^ myType1 = myTypeBuilder->CreateType();
    Console::WriteLine( "'Example' is created." );

    myAssembly->Save(myAssemblyName->Name + ".dll");
    Console::WriteLine( "'{0}' is created.", myAssemblyName->Name + ".dll" );

    // Invoke 'Function1' method of 'Example', passing the value 42.
    Object^ myObject2 = myType1->InvokeMember( "Function1", 
        BindingFlags::InvokeMethod, nullptr, nullptr, 
        gcnew array<Object^> { 42 } );

    Console::WriteLine( "Example::Function1 returned: {0}", myObject2 );
}
/* This code example produces the following output:

local 'myString' type is: System.String
local 'myInt' type is: System.Int32
'Example' is created.
'SampleAssembly.dll' is created.
Example::Function1 returned: string value
 */

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;

class LocalBuilder_Sample
{
    public static void Main()
    {
        // Create an assembly.
        AssemblyName myAssemblyName = new AssemblyName();
        myAssemblyName.Name = "SampleAssembly";

        AssemblyBuilder myAssembly =
           Thread.GetDomain().DefineDynamicAssembly(myAssemblyName,
               AssemblyBuilderAccess.RunAndSave);

        // Create a module. For a single-file assembly the module
        // name is usually the same as the assembly name.
        ModuleBuilder myModule =
            myAssembly.DefineDynamicModule(myAssemblyName.Name,
                myAssemblyName.Name + ".dll", true);

        // Define a public class 'Example'.
        TypeBuilder myTypeBuilder =
            myModule.DefineType("Example", TypeAttributes.Public);

        // Create the 'Function1' public method, which takes an integer
        // and returns a string.
        MethodBuilder myMethod = myTypeBuilder.DefineMethod("Function1",
           MethodAttributes.Public | MethodAttributes.Static,
           typeof(String), new Type[] { typeof(int) });

        // Generate IL for 'Function1'. The function body demonstrates
        // assigning an argument to a local variable, assigning a
        // constant string to a local variable, and putting the contents
        // of local variables on the stack.
        ILGenerator myMethodIL = myMethod.GetILGenerator();

        // Create local variables named myString and myInt.
        LocalBuilder myLB1 = myMethodIL.DeclareLocal(typeof(string));
        myLB1.SetLocalSymInfo("myString");
        Console.WriteLine("local 'myString' type is: {0}", myLB1.LocalType);

        LocalBuilder myLB2 = myMethodIL.DeclareLocal(typeof(int));
        myLB2.SetLocalSymInfo("myInt", 1, 2);
        Console.WriteLine("local 'myInt' type is: {0}", myLB2.LocalType);

        // Store the function argument in myInt.
        myMethodIL.Emit(OpCodes.Ldarg_0 );
        myMethodIL.Emit(OpCodes.Stloc_1 );

        // Store a literal value in myString, and return the value.
        myMethodIL.Emit(OpCodes.Ldstr, "string value"  );
        myMethodIL.Emit(OpCodes.Stloc_0 );
        myMethodIL.Emit(OpCodes.Ldloc_0 );
        myMethodIL.Emit(OpCodes.Ret );

        // Create "Example" class.
        Type myType1 = myTypeBuilder.CreateType();
        Console.WriteLine("'Example' is created.");

        myAssembly.Save(myAssemblyName.Name + ".dll");
        Console.WriteLine( "'{0}' is created.", myAssemblyName.Name + ".dll" );

        // Invoke 'Function1' method of 'Example', passing the value 42.
        Object myObject2 = myType1.InvokeMember("Function1",
            BindingFlags.InvokeMethod, null, null, new Object[] { 42 });

        Console.WriteLine("Example.Function1 returned: {0}", myObject2);
    }
}
/* This code example produces the following output:

local 'myString' type is: System.String
local 'myInt' type is: System.Int32
'Example' is created.
'SampleAssembly.dll' is created.
Example.Function1 returned: string value
 */

Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Threading

Class LocalBuilder_Sample

    Public Shared Sub Main()

        ' Create an assembly.
        Dim myAssemblyName As New AssemblyName()
        myAssemblyName.Name = "SampleAssembly"

        Dim myAssembly As AssemblyBuilder = _
            Thread.GetDomain().DefineDynamicAssembly( myAssemblyName, _
                             AssemblyBuilderAccess.RunAndSave )

        ' Create a module. For a single-file assembly the module
        ' name is usually the same as the assembly name.
        Dim myModule As ModuleBuilder = _
            myAssembly.DefineDynamicModule(myAssemblyName.Name, _
                myAssemblyName.Name & ".dll", True)

        ' Define a public class 'Example'.
        Dim myTypeBuilder As TypeBuilder = _
            myModule.DefineType("Example", TypeAttributes.Public)

        ' Create the 'Function1' public method, which takes an Integer
        ' and returns a string.
        Dim myMethod As MethodBuilder = myTypeBuilder.DefineMethod("Function1", _
            MethodAttributes.Public Or MethodAttributes.Static, _
            GetType(String), New Type() { GetType(Integer) })

        ' Generate IL for 'Function1'. The function body demonstrates
        ' assigning an argument to a local variable, assigning a 
        ' constant string to a local variable, and putting the contents
        ' of local variables on the stack.
        Dim myMethodIL As ILGenerator = myMethod.GetILGenerator()

        ' Create local variables named myString and myInt.
        Dim myLB1 As LocalBuilder = myMethodIL.DeclareLocal(GetType(String))
        myLB1.SetLocalSymInfo("myString")
        Console.WriteLine("local 'myString' type is: {0}", myLB1.LocalType)

        Dim myLB2 As LocalBuilder = myMethodIL.DeclareLocal(GetType(Integer))
        myLB2.SetLocalSymInfo("myInt", 1, 2)
        Console.WriteLine("local 'myInt' type is: {0}", myLB2.LocalType)

        ' Store the function argument in myInt.
        myMethodIL.Emit(OpCodes.Ldarg_0 )
        myMethodIL.Emit(OpCodes.Stloc_1 )

        ' Store a literal value in myString, and return the value.
        myMethodIL.Emit(OpCodes.Ldstr, "string value"  )
        myMethodIL.Emit(OpCodes.Stloc_0 )
        myMethodIL.Emit(OpCodes.Ldloc_0 )
        myMethodIL.Emit(OpCodes.Ret )

        ' Create "Example" class.
        Dim myType1 As Type = myTypeBuilder.CreateType()
        Console.WriteLine("'Example' is created.")

        myAssembly.Save(myAssemblyName.Name & ".dll")
        Console.WriteLine( "'{0}' is created.", myAssemblyName.Name & ".dll" )

        ' Invoke 'Function1' method of 'Example', passing the value 42.
        Dim myObject2 As Object = myType1.InvokeMember("Function1", _
            BindingFlags.InvokeMethod, Nothing, Nothing, New Object() { 42 })

        Console.WriteLine("Example.Function1 returned: {0}", myObject2)

   End Sub 
End Class 

' This code example produces the following output:
'
'local 'myString' type is: System.String
'local 'myInt' type is: System.Int32
''Example' is created.
''SampleAssembly.dll' is created.
'Example.Function1 returned: string value

注解

可以使用 DeclareLocal 方法定义 LocalBuilder 对象。

属性

IsPinned	获取一个值，该值指示本地变量引用的对象是否固定在内存中。
LocalIndex	获取方法正文中局部变量的从零开始的索引。
LocalType	获取局部变量的类型。

方法

Equals(Object)	确定指定的对象是否等于当前对象。 (继承自 Object)
GetHashCode()	用作默认哈希函数。 (继承自 Object)
GetType()	获取当前实例的 Type。 (继承自 Object)
MemberwiseClone()	创建当前 Object的浅表副本。 (继承自 Object)
ToString()	返回描述局部变量的用户可读字符串。 (继承自 LocalVariableInfo)