LocalBuilder 類別

定義

命名空間:

System.Reflection.Emit

組件:

System.Reflection.Emit.ILGeneration.dll

來源:

LocalBuilder.cs

表示方法或建構函式 (Constructor) 中的區域變數。

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

範例

下列範例會在 static Visual Basic) 中建立方法 (SharedFunction1 ，這個方法會傳回字串，且具有 類型的 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

備註

LocalBuilder您可以使用 方法來定義 DeclareLocal 物件。

屬性

IsPinned	取得值，指出是否在記憶體中 Pin 區域變數參考的物件。
LocalIndex	取得方法主體內區域變數之以零起始的索引。
LocalType	取得區域變數的型別。

方法

Equals(Object)	判斷指定的物件是否等於目前的物件。 (繼承來源 Object)
GetHashCode()	做為預設雜湊函式。 (繼承來源 Object)
GetType()	取得目前執行個體的 Type。 (繼承來源 Object)
MemberwiseClone()	建立目前 Object 的淺層複製。 (繼承來源 Object)
ToString()	傳回描述區域變數的使用者可讀字串。 (繼承來源 LocalVariableInfo)