ILGenerator.EmitWriteLine 方法
定义
重要
一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。 对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。
使用不同类型的值发出对 WriteLine() 的调用的 Helper 函数。
重载
| EmitWriteLine(String) |
发出 Microsoft 中间语言 (MSIL) 以用字符串调用 WriteLine。 |
| EmitWriteLine(FieldInfo) |
发出用给定字段调用 WriteLine 所需的 Microsoft 中间语言 (MSIL)。 |
| EmitWriteLine(LocalBuilder) |
发出使用给定本地变量调用 WriteLine 时必需的 Microsoft 中间语言 (MSIL)。 |
EmitWriteLine(String)
- Source:
- ILGenerator.cs
- Source:
- ILGenerator.cs
- Source:
- ILGenerator.cs
发出 Microsoft 中间语言 (MSIL) 以用字符串调用 WriteLine。
public:
virtual void EmitWriteLine(System::String ^ value);public virtual void EmitWriteLine (string value);abstract member EmitWriteLine : string -> unit
override this.EmitWriteLine : string -> unitPublic Overridable Sub EmitWriteLine (value As String)参数
- value
- String
要打印的字符串。
示例
下面的代码示例演示了 在动态方法中将字符串写入控制台的方法的上下文用法 EmitWriteLine 。
using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ CreateDynamicType()
{
array<Type^>^ctorParams = {int::typeid,int::typeid};
AppDomain^ myDomain = Thread::GetDomain();
AssemblyName^ myAsmName = gcnew AssemblyName;
myAsmName->Name = "MyDynamicAssembly";
AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::Run );
ModuleBuilder^ pointModule = myAsmBuilder->DefineDynamicModule( "PointModule", "Point.dll" );
TypeBuilder^ pointTypeBld = pointModule->DefineType( "Point", TypeAttributes::Public );
FieldBuilder^ xField = pointTypeBld->DefineField( "x", int::typeid, FieldAttributes::Public );
FieldBuilder^ yField = pointTypeBld->DefineField( "y", int::typeid, FieldAttributes::Public );
Type^ objType = Type::GetType( "System.Object" );
ConstructorInfo^ objCtor = objType->GetConstructor( gcnew array<Type^>(0) );
ConstructorBuilder^ pointCtor = pointTypeBld->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, ctorParams );
ILGenerator^ ctorIL = pointCtor->GetILGenerator();
// First, you build the constructor.
ctorIL->Emit( OpCodes::Ldarg_0 );
ctorIL->Emit( OpCodes::Call, objCtor );
ctorIL->Emit( OpCodes::Ldarg_0 );
ctorIL->Emit( OpCodes::Ldarg_1 );
ctorIL->Emit( OpCodes::Stfld, xField );
ctorIL->Emit( OpCodes::Ldarg_0 );
ctorIL->Emit( OpCodes::Ldarg_2 );
ctorIL->Emit( OpCodes::Stfld, yField );
ctorIL->Emit( OpCodes::Ret );
// Now, you'll build a method to output some information on the
// inside your dynamic class. This method will have the following
// definition in C#:
// public void WritePoint()
MethodBuilder^ writeStrMthd = pointTypeBld->DefineMethod( "WritePoint", MethodAttributes::Public, void::typeid, nullptr );
ILGenerator^ writeStrIL = writeStrMthd->GetILGenerator();
// The below ILGenerator created demonstrates a few ways to create
// String* output through STDIN.
// ILGenerator::EmitWriteLine(String*) will generate a ldstr and a
// call to WriteLine for you.
writeStrIL->EmitWriteLine( "The value of this current instance is:" );
// Here, you will do the hard work yourself. First, you need to create
// the String* we will be passing and obtain the correct WriteLine overload
// for said String*. In the below case, you are substituting in two values,
// so the chosen overload is Console::WriteLine(String*, Object*, Object*).
String^ inStr = "( {0}, {1})";
array<Type^>^wlParams = {String::typeid,Object::typeid,Object::typeid};
// We need the MethodInfo to pass into EmitCall later.
MethodInfo^ writeLineMI = Console::typeid->GetMethod( "WriteLine", wlParams );
// Push the String* with the substitutions onto the stack.
// This is the first argument for WriteLine - the String* one.
writeStrIL->Emit( OpCodes::Ldstr, inStr );
// Since the second argument is an Object*, and it corresponds to
// to the substitution for the value of our integer field, you
// need to box that field to an Object*. First, push a reference
// to the current instance, and then push the value stored in
// field 'x'. We need the reference to the current instance (stored
// in local argument index 0) so Ldfld can load from the correct
// instance (this one).
writeStrIL->Emit( OpCodes::Ldarg_0 );
writeStrIL->Emit( OpCodes::Ldfld, xField );
// Now, we execute the box opcode, which pops the value of field 'x',
// returning a reference to the integer value boxed as an Object*.
writeStrIL->Emit( OpCodes::Box, int::typeid );
// Atop the stack, you'll find our String* inStr, followed by a reference
// to the boxed value of 'x'. Now, you need to likewise box field 'y'.
writeStrIL->Emit( OpCodes::Ldarg_0 );
writeStrIL->Emit( OpCodes::Ldfld, yField );
writeStrIL->Emit( OpCodes::Box, int::typeid );
// Now, you have all of the arguments for your call to
// Console::WriteLine(String*, Object*, Object*) atop the stack:
// the String* InStr, a reference to the boxed value of 'x', and
// a reference to the boxed value of 'y'.
// Call Console::WriteLine(String*, Object*, Object*) with EmitCall.
writeStrIL->EmitCall( OpCodes::Call, writeLineMI, nullptr );
// Lastly, EmitWriteLine can also output the value of a field
// using the overload EmitWriteLine(FieldInfo).
writeStrIL->EmitWriteLine( "The value of 'x' is:" );
writeStrIL->EmitWriteLine( xField );
writeStrIL->EmitWriteLine( "The value of 'y' is:" );
writeStrIL->EmitWriteLine( yField );
// Since we return no value (void), the ret opcode will not
// return the top stack value.
writeStrIL->Emit( OpCodes::Ret );
return pointTypeBld->CreateType();
}
int main()
{
array<Object^>^ctorParams = gcnew array<Object^>(2);
Console::Write( "Enter a integer value for X: " );
String^ myX = Console::ReadLine();
Console::Write( "Enter a integer value for Y: " );
String^ myY = Console::ReadLine();
Console::WriteLine( "---" );
ctorParams[ 0 ] = Convert::ToInt32( myX );
ctorParams[ 1 ] = Convert::ToInt32( myY );
Type^ ptType = CreateDynamicType();
Object^ ptInstance = Activator::CreateInstance( ptType, ctorParams );
ptType->InvokeMember( "WritePoint", BindingFlags::InvokeMethod, nullptr, ptInstance, gcnew array<Object^>(0) );
}
using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
class EmitWriteLineDemo {
public static Type CreateDynamicType() {
Type[] ctorParams = new Type[] {typeof(int),
typeof(int)};
AppDomain myDomain = Thread.GetDomain();
AssemblyName myAsmName = new AssemblyName();
myAsmName.Name = "MyDynamicAssembly";
AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
myAsmName,
AssemblyBuilderAccess.Run);
ModuleBuilder pointModule = myAsmBuilder.DefineDynamicModule("PointModule",
"Point.dll");
TypeBuilder pointTypeBld = pointModule.DefineType("Point",
TypeAttributes.Public);
FieldBuilder xField = pointTypeBld.DefineField("x", typeof(int),
FieldAttributes.Public);
FieldBuilder yField = pointTypeBld.DefineField("y", typeof(int),
FieldAttributes.Public);
Type objType = Type.GetType("System.Object");
ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);
ConstructorBuilder pointCtor = pointTypeBld.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
ctorParams);
ILGenerator ctorIL = pointCtor.GetILGenerator();
// First, you build the constructor.
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Call, objCtor);
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_1);
ctorIL.Emit(OpCodes.Stfld, xField);
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_2);
ctorIL.Emit(OpCodes.Stfld, yField);
ctorIL.Emit(OpCodes.Ret);
// Now, you'll build a method to output some information on the
// inside your dynamic class. This method will have the following
// definition in C#:
// public void WritePoint()
MethodBuilder writeStrMthd = pointTypeBld.DefineMethod(
"WritePoint",
MethodAttributes.Public,
typeof(void),
null);
ILGenerator writeStrIL = writeStrMthd.GetILGenerator();
// The below ILGenerator created demonstrates a few ways to create
// string output through STDIN.
// ILGenerator.EmitWriteLine(string) will generate a ldstr and a
// call to WriteLine for you.
writeStrIL.EmitWriteLine("The value of this current instance is:");
// Here, you will do the hard work yourself. First, you need to create
// the string we will be passing and obtain the correct WriteLine overload
// for said string. In the below case, you are substituting in two values,
// so the chosen overload is Console.WriteLine(string, object, object).
String inStr = "({0}, {1})";
Type[] wlParams = new Type[] {typeof(string),
typeof(object),
typeof(object)};
// We need the MethodInfo to pass into EmitCall later.
MethodInfo writeLineMI = typeof(Console).GetMethod(
"WriteLine",
wlParams);
// Push the string with the substitutions onto the stack.
// This is the first argument for WriteLine - the string one.
writeStrIL.Emit(OpCodes.Ldstr, inStr);
// Since the second argument is an object, and it corresponds to
// to the substitution for the value of our integer field, you
// need to box that field to an object. First, push a reference
// to the current instance, and then push the value stored in
// field 'x'. We need the reference to the current instance (stored
// in local argument index 0) so Ldfld can load from the correct
// instance (this one).
writeStrIL.Emit(OpCodes.Ldarg_0);
writeStrIL.Emit(OpCodes.Ldfld, xField);
// Now, we execute the box opcode, which pops the value of field 'x',
// returning a reference to the integer value boxed as an object.
writeStrIL.Emit(OpCodes.Box, typeof(int));
// Atop the stack, you'll find our string inStr, followed by a reference
// to the boxed value of 'x'. Now, you need to likewise box field 'y'.
writeStrIL.Emit(OpCodes.Ldarg_0);
writeStrIL.Emit(OpCodes.Ldfld, yField);
writeStrIL.Emit(OpCodes.Box, typeof(int));
// Now, you have all of the arguments for your call to
// Console.WriteLine(string, object, object) atop the stack:
// the string InStr, a reference to the boxed value of 'x', and
// a reference to the boxed value of 'y'.
// Call Console.WriteLine(string, object, object) with EmitCall.
writeStrIL.EmitCall(OpCodes.Call, writeLineMI, null);
// Lastly, EmitWriteLine can also output the value of a field
// using the overload EmitWriteLine(FieldInfo).
writeStrIL.EmitWriteLine("The value of 'x' is:");
writeStrIL.EmitWriteLine(xField);
writeStrIL.EmitWriteLine("The value of 'y' is:");
writeStrIL.EmitWriteLine(yField);
// Since we return no value (void), the ret opcode will not
// return the top stack value.
writeStrIL.Emit(OpCodes.Ret);
return pointTypeBld.CreateType();
}
public static void Main() {
object[] ctorParams = new object[2];
Console.Write("Enter a integer value for X: ");
string myX = Console.ReadLine();
Console.Write("Enter a integer value for Y: ");
string myY = Console.ReadLine();
Console.WriteLine("---");
ctorParams[0] = Convert.ToInt32(myX);
ctorParams[1] = Convert.ToInt32(myY);
Type ptType = CreateDynamicType();
object ptInstance = Activator.CreateInstance(ptType, ctorParams);
ptType.InvokeMember("WritePoint",
BindingFlags.InvokeMethod,
null,
ptInstance,
new object[0]);
}
}
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
_
Class EmitWriteLineDemo
Public Shared Function CreateDynamicType() As Type
Dim ctorParams() As Type = {GetType(Integer), GetType(Integer)}
Dim myDomain As AppDomain = Thread.GetDomain()
Dim myAsmName As New AssemblyName()
myAsmName.Name = "MyDynamicAssembly"
Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave)
Dim pointModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("PointModule", "Point.dll")
Dim pointTypeBld As TypeBuilder = pointModule.DefineType("Point", _
TypeAttributes.Public)
Dim xField As FieldBuilder = pointTypeBld.DefineField("x", _
GetType(Integer), _
FieldAttributes.Public)
Dim yField As FieldBuilder = pointTypeBld.DefineField("y", _
GetType(Integer), _
FieldAttributes.Public)
Dim objType As Type = Type.GetType("System.Object")
Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type(){})
Dim pointCtor As ConstructorBuilder = pointTypeBld.DefineConstructor( _
MethodAttributes.Public, _
CallingConventions.Standard, _
ctorParams)
Dim ctorIL As ILGenerator = pointCtor.GetILGenerator()
' First, you build the constructor.
ctorIL.Emit(OpCodes.Ldarg_0)
ctorIL.Emit(OpCodes.Call, objCtor)
ctorIL.Emit(OpCodes.Ldarg_0)
ctorIL.Emit(OpCodes.Ldarg_1)
ctorIL.Emit(OpCodes.Stfld, xField)
ctorIL.Emit(OpCodes.Ldarg_0)
ctorIL.Emit(OpCodes.Ldarg_2)
ctorIL.Emit(OpCodes.Stfld, yField)
ctorIL.Emit(OpCodes.Ret)
' Now, you'll build a method to output some information on the
' inside your dynamic class. This method will have the following
' definition in C#:
' Public Sub WritePoint()
Dim writeStrMthd As MethodBuilder = pointTypeBld.DefineMethod("WritePoint", _
MethodAttributes.Public, _
Nothing, Nothing)
Dim writeStrIL As ILGenerator = writeStrMthd.GetILGenerator()
' The below ILGenerator created demonstrates a few ways to create
' string output through STDIN.
' ILGenerator.EmitWriteLine(string) will generate a ldstr and a
' call to WriteLine for you.
writeStrIL.EmitWriteLine("The value of this current instance is:")
' Here, you will do the hard work yourself. First, you need to create
' the string we will be passing and obtain the correct WriteLine overload
' for said string. In the below case, you are substituting in two values,
' so the chosen overload is Console.WriteLine(string, object, object).
Dim inStr As [String] = "({0}, {1})"
Dim wlParams() As Type = {GetType(String), GetType(Object), GetType(Object)}
' We need the MethodInfo to pass into EmitCall later.
Dim writeLineMI As MethodInfo = GetType(Console).GetMethod("WriteLine", wlParams)
' Push the string with the substitutions onto the stack.
' This is the first argument for WriteLine - the string one.
writeStrIL.Emit(OpCodes.Ldstr, inStr)
' Since the second argument is an object, and it corresponds to
' to the substitution for the value of our integer field, you
' need to box that field to an object. First, push a reference
' to the current instance, and then push the value stored in
' field 'x'. We need the reference to the current instance (stored
' in local argument index 0) so Ldfld can load from the correct
' instance (this one).
writeStrIL.Emit(OpCodes.Ldarg_0)
writeStrIL.Emit(OpCodes.Ldfld, xField)
' Now, we execute the box opcode, which pops the value of field 'x',
' returning a reference to the integer value boxed as an object.
writeStrIL.Emit(OpCodes.Box, GetType(Integer))
' Atop the stack, you'll find our string inStr, followed by a reference
' to the boxed value of 'x'. Now, you need to likewise box field 'y'.
writeStrIL.Emit(OpCodes.Ldarg_0)
writeStrIL.Emit(OpCodes.Ldfld, yField)
writeStrIL.Emit(OpCodes.Box, GetType(Integer))
' Now, you have all of the arguments for your call to
' Console.WriteLine(string, object, object) atop the stack:
' the string InStr, a reference to the boxed value of 'x', and
' a reference to the boxed value of 'y'.
' Call Console.WriteLine(string, object, object) with EmitCall.
writeStrIL.EmitCall(OpCodes.Call, writeLineMI, Nothing)
' Lastly, EmitWriteLine can also output the value of a field
' using the overload EmitWriteLine(FieldInfo).
writeStrIL.EmitWriteLine("The value of 'x' is:")
writeStrIL.EmitWriteLine(xField)
writeStrIL.EmitWriteLine("The value of 'y' is:")
writeStrIL.EmitWriteLine(yField)
' Since we return no value (void), the ret opcode will not
' return the top stack value.
writeStrIL.Emit(OpCodes.Ret)
Return pointTypeBld.CreateType()
End Function 'CreateDynamicType
Public Shared Sub Main()
Dim ctorParams(1) As Object
Console.Write("Enter a integer value for X: ")
Dim myX As String = Console.ReadLine()
Console.Write("Enter a integer value for Y: ")
Dim myY As String = Console.ReadLine()
Console.WriteLine("---")
ctorParams(0) = Convert.ToInt32(myX)
ctorParams(1) = Convert.ToInt32(myY)
Dim ptType As Type = CreateDynamicType()
Dim ptInstance As Object = Activator.CreateInstance(ptType, ctorParams)
ptType.InvokeMember("WritePoint", _
BindingFlags.InvokeMethod, _
Nothing, ptInstance, Nothing)
End Sub
End Class
注解
字符串必须已定义。
适用于
EmitWriteLine(FieldInfo)
- Source:
- ILGenerator.cs
- Source:
- ILGenerator.cs
- Source:
- ILGenerator.cs
发出用给定字段调用 WriteLine 所需的 Microsoft 中间语言 (MSIL)。
public:
virtual void EmitWriteLine(System::Reflection::FieldInfo ^ fld);public virtual void EmitWriteLine (System.Reflection.FieldInfo fld);abstract member EmitWriteLine : System.Reflection.FieldInfo -> unit
override this.EmitWriteLine : System.Reflection.FieldInfo -> unitPublic Overridable Sub EmitWriteLine (fld As FieldInfo)参数
- fld
- FieldInfo
其值将写入控制台的字段。
例外
不存在接受指定字段类型的 WriteLine 方法重载。
fld 为 null。
字段类型为 TypeBuilder 或 EnumBuilder，这两种类型都不受支持。
示例
下面的代码示例演示如何使用 EmitWriteLine 方法在动态方法中将字符串写入控制台。
using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ CreateDynamicType()
{
array<Type^>^ctorParams = {int::typeid,int::typeid};
AppDomain^ myDomain = Thread::GetDomain();
AssemblyName^ myAsmName = gcnew AssemblyName;
myAsmName->Name = "MyDynamicAssembly";
AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::Run );
ModuleBuilder^ pointModule = myAsmBuilder->DefineDynamicModule( "PointModule", "Point.dll" );
TypeBuilder^ pointTypeBld = pointModule->DefineType( "Point", TypeAttributes::Public );
FieldBuilder^ xField = pointTypeBld->DefineField( "x", int::typeid, FieldAttributes::Public );
FieldBuilder^ yField = pointTypeBld->DefineField( "y", int::typeid, FieldAttributes::Public );
Type^ objType = Type::GetType( "System.Object" );
ConstructorInfo^ objCtor = objType->GetConstructor( gcnew array<Type^>(0) );
ConstructorBuilder^ pointCtor = pointTypeBld->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, ctorParams );
ILGenerator^ ctorIL = pointCtor->GetILGenerator();
// First, you build the constructor.
ctorIL->Emit( OpCodes::Ldarg_0 );
ctorIL->Emit( OpCodes::Call, objCtor );
ctorIL->Emit( OpCodes::Ldarg_0 );
ctorIL->Emit( OpCodes::Ldarg_1 );
ctorIL->Emit( OpCodes::Stfld, xField );
ctorIL->Emit( OpCodes::Ldarg_0 );
ctorIL->Emit( OpCodes::Ldarg_2 );
ctorIL->Emit( OpCodes::Stfld, yField );
ctorIL->Emit( OpCodes::Ret );
// Now, you'll build a method to output some information on the
// inside your dynamic class. This method will have the following
// definition in C#:
// public void WritePoint()
MethodBuilder^ writeStrMthd = pointTypeBld->DefineMethod( "WritePoint", MethodAttributes::Public, void::typeid, nullptr );
ILGenerator^ writeStrIL = writeStrMthd->GetILGenerator();
// The below ILGenerator created demonstrates a few ways to create
// String* output through STDIN.
// ILGenerator::EmitWriteLine(String*) will generate a ldstr and a
// call to WriteLine for you.
writeStrIL->EmitWriteLine( "The value of this current instance is:" );
// Here, you will do the hard work yourself. First, you need to create
// the String* we will be passing and obtain the correct WriteLine overload
// for said String*. In the below case, you are substituting in two values,
// so the chosen overload is Console::WriteLine(String*, Object*, Object*).
String^ inStr = "( {0}, {1})";
array<Type^>^wlParams = {String::typeid,Object::typeid,Object::typeid};
// We need the MethodInfo to pass into EmitCall later.
MethodInfo^ writeLineMI = Console::typeid->GetMethod( "WriteLine", wlParams );
// Push the String* with the substitutions onto the stack.
// This is the first argument for WriteLine - the String* one.
writeStrIL->Emit( OpCodes::Ldstr, inStr );
// Since the second argument is an Object*, and it corresponds to
// to the substitution for the value of our integer field, you
// need to box that field to an Object*. First, push a reference
// to the current instance, and then push the value stored in
// field 'x'. We need the reference to the current instance (stored
// in local argument index 0) so Ldfld can load from the correct
// instance (this one).
writeStrIL->Emit( OpCodes::Ldarg_0 );
writeStrIL->Emit( OpCodes::Ldfld, xField );
// Now, we execute the box opcode, which pops the value of field 'x',
// returning a reference to the integer value boxed as an Object*.
writeStrIL->Emit( OpCodes::Box, int::typeid );
// Atop the stack, you'll find our String* inStr, followed by a reference
// to the boxed value of 'x'. Now, you need to likewise box field 'y'.
writeStrIL->Emit( OpCodes::Ldarg_0 );
writeStrIL->Emit( OpCodes::Ldfld, yField );
writeStrIL->Emit( OpCodes::Box, int::typeid );
// Now, you have all of the arguments for your call to
// Console::WriteLine(String*, Object*, Object*) atop the stack:
// the String* InStr, a reference to the boxed value of 'x', and
// a reference to the boxed value of 'y'.
// Call Console::WriteLine(String*, Object*, Object*) with EmitCall.
writeStrIL->EmitCall( OpCodes::Call, writeLineMI, nullptr );
// Lastly, EmitWriteLine can also output the value of a field
// using the overload EmitWriteLine(FieldInfo).
writeStrIL->EmitWriteLine( "The value of 'x' is:" );
writeStrIL->EmitWriteLine( xField );
writeStrIL->EmitWriteLine( "The value of 'y' is:" );
writeStrIL->EmitWriteLine( yField );
// Since we return no value (void), the ret opcode will not
// return the top stack value.
writeStrIL->Emit( OpCodes::Ret );
return pointTypeBld->CreateType();
}
int main()
{
array<Object^>^ctorParams = gcnew array<Object^>(2);
Console::Write( "Enter a integer value for X: " );
String^ myX = Console::ReadLine();
Console::Write( "Enter a integer value for Y: " );
String^ myY = Console::ReadLine();
Console::WriteLine( "---" );
ctorParams[ 0 ] = Convert::ToInt32( myX );
ctorParams[ 1 ] = Convert::ToInt32( myY );
Type^ ptType = CreateDynamicType();
Object^ ptInstance = Activator::CreateInstance( ptType, ctorParams );
ptType->InvokeMember( "WritePoint", BindingFlags::InvokeMethod, nullptr, ptInstance, gcnew array<Object^>(0) );
}
using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
class EmitWriteLineDemo {
public static Type CreateDynamicType() {
Type[] ctorParams = new Type[] {typeof(int),
typeof(int)};
AppDomain myDomain = Thread.GetDomain();
AssemblyName myAsmName = new AssemblyName();
myAsmName.Name = "MyDynamicAssembly";
AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
myAsmName,
AssemblyBuilderAccess.Run);
ModuleBuilder pointModule = myAsmBuilder.DefineDynamicModule("PointModule",
"Point.dll");
TypeBuilder pointTypeBld = pointModule.DefineType("Point",
TypeAttributes.Public);
FieldBuilder xField = pointTypeBld.DefineField("x", typeof(int),
FieldAttributes.Public);
FieldBuilder yField = pointTypeBld.DefineField("y", typeof(int),
FieldAttributes.Public);
Type objType = Type.GetType("System.Object");
ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);
ConstructorBuilder pointCtor = pointTypeBld.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
ctorParams);
ILGenerator ctorIL = pointCtor.GetILGenerator();
// First, you build the constructor.
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Call, objCtor);
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_1);
ctorIL.Emit(OpCodes.Stfld, xField);
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_2);
ctorIL.Emit(OpCodes.Stfld, yField);
ctorIL.Emit(OpCodes.Ret);
// Now, you'll build a method to output some information on the
// inside your dynamic class. This method will have the following
// definition in C#:
// public void WritePoint()
MethodBuilder writeStrMthd = pointTypeBld.DefineMethod(
"WritePoint",
MethodAttributes.Public,
typeof(void),
null);
ILGenerator writeStrIL = writeStrMthd.GetILGenerator();
// The below ILGenerator created demonstrates a few ways to create
// string output through STDIN.
// ILGenerator.EmitWriteLine(string) will generate a ldstr and a
// call to WriteLine for you.
writeStrIL.EmitWriteLine("The value of this current instance is:");
// Here, you will do the hard work yourself. First, you need to create
// the string we will be passing and obtain the correct WriteLine overload
// for said string. In the below case, you are substituting in two values,
// so the chosen overload is Console.WriteLine(string, object, object).
String inStr = "({0}, {1})";
Type[] wlParams = new Type[] {typeof(string),
typeof(object),
typeof(object)};
// We need the MethodInfo to pass into EmitCall later.
MethodInfo writeLineMI = typeof(Console).GetMethod(
"WriteLine",
wlParams);
// Push the string with the substitutions onto the stack.
// This is the first argument for WriteLine - the string one.
writeStrIL.Emit(OpCodes.Ldstr, inStr);
// Since the second argument is an object, and it corresponds to
// to the substitution for the value of our integer field, you
// need to box that field to an object. First, push a reference
// to the current instance, and then push the value stored in
// field 'x'. We need the reference to the current instance (stored
// in local argument index 0) so Ldfld can load from the correct
// instance (this one).
writeStrIL.Emit(OpCodes.Ldarg_0);
writeStrIL.Emit(OpCodes.Ldfld, xField);
// Now, we execute the box opcode, which pops the value of field 'x',
// returning a reference to the integer value boxed as an object.
writeStrIL.Emit(OpCodes.Box, typeof(int));
// Atop the stack, you'll find our string inStr, followed by a reference
// to the boxed value of 'x'. Now, you need to likewise box field 'y'.
writeStrIL.Emit(OpCodes.Ldarg_0);
writeStrIL.Emit(OpCodes.Ldfld, yField);
writeStrIL.Emit(OpCodes.Box, typeof(int));
// Now, you have all of the arguments for your call to
// Console.WriteLine(string, object, object) atop the stack:
// the string InStr, a reference to the boxed value of 'x', and
// a reference to the boxed value of 'y'.
// Call Console.WriteLine(string, object, object) with EmitCall.
writeStrIL.EmitCall(OpCodes.Call, writeLineMI, null);
// Lastly, EmitWriteLine can also output the value of a field
// using the overload EmitWriteLine(FieldInfo).
writeStrIL.EmitWriteLine("The value of 'x' is:");
writeStrIL.EmitWriteLine(xField);
writeStrIL.EmitWriteLine("The value of 'y' is:");
writeStrIL.EmitWriteLine(yField);
// Since we return no value (void), the ret opcode will not
// return the top stack value.
writeStrIL.Emit(OpCodes.Ret);
return pointTypeBld.CreateType();
}
public static void Main() {
object[] ctorParams = new object[2];
Console.Write("Enter a integer value for X: ");
string myX = Console.ReadLine();
Console.Write("Enter a integer value for Y: ");
string myY = Console.ReadLine();
Console.WriteLine("---");
ctorParams[0] = Convert.ToInt32(myX);
ctorParams[1] = Convert.ToInt32(myY);
Type ptType = CreateDynamicType();
object ptInstance = Activator.CreateInstance(ptType, ctorParams);
ptType.InvokeMember("WritePoint",
BindingFlags.InvokeMethod,
null,
ptInstance,
new object[0]);
}
}
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
_
Class EmitWriteLineDemo
Public Shared Function CreateDynamicType() As Type
Dim ctorParams() As Type = {GetType(Integer), GetType(Integer)}
Dim myDomain As AppDomain = Thread.GetDomain()
Dim myAsmName As New AssemblyName()
myAsmName.Name = "MyDynamicAssembly"
Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave)
Dim pointModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("PointModule", "Point.dll")
Dim pointTypeBld As TypeBuilder = pointModule.DefineType("Point", _
TypeAttributes.Public)
Dim xField As FieldBuilder = pointTypeBld.DefineField("x", _
GetType(Integer), _
FieldAttributes.Public)
Dim yField As FieldBuilder = pointTypeBld.DefineField("y", _
GetType(Integer), _
FieldAttributes.Public)
Dim objType As Type = Type.GetType("System.Object")
Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type(){})
Dim pointCtor As ConstructorBuilder = pointTypeBld.DefineConstructor( _
MethodAttributes.Public, _
CallingConventions.Standard, _
ctorParams)
Dim ctorIL As ILGenerator = pointCtor.GetILGenerator()
' First, you build the constructor.
ctorIL.Emit(OpCodes.Ldarg_0)
ctorIL.Emit(OpCodes.Call, objCtor)
ctorIL.Emit(OpCodes.Ldarg_0)
ctorIL.Emit(OpCodes.Ldarg_1)
ctorIL.Emit(OpCodes.Stfld, xField)
ctorIL.Emit(OpCodes.Ldarg_0)
ctorIL.Emit(OpCodes.Ldarg_2)
ctorIL.Emit(OpCodes.Stfld, yField)
ctorIL.Emit(OpCodes.Ret)
' Now, you'll build a method to output some information on the
' inside your dynamic class. This method will have the following
' definition in C#:
' Public Sub WritePoint()
Dim writeStrMthd As MethodBuilder = pointTypeBld.DefineMethod("WritePoint", _
MethodAttributes.Public, _
Nothing, Nothing)
Dim writeStrIL As ILGenerator = writeStrMthd.GetILGenerator()
' The below ILGenerator created demonstrates a few ways to create
' string output through STDIN.
' ILGenerator.EmitWriteLine(string) will generate a ldstr and a
' call to WriteLine for you.
writeStrIL.EmitWriteLine("The value of this current instance is:")
' Here, you will do the hard work yourself. First, you need to create
' the string we will be passing and obtain the correct WriteLine overload
' for said string. In the below case, you are substituting in two values,
' so the chosen overload is Console.WriteLine(string, object, object).
Dim inStr As [String] = "({0}, {1})"
Dim wlParams() As Type = {GetType(String), GetType(Object), GetType(Object)}
' We need the MethodInfo to pass into EmitCall later.
Dim writeLineMI As MethodInfo = GetType(Console).GetMethod("WriteLine", wlParams)
' Push the string with the substitutions onto the stack.
' This is the first argument for WriteLine - the string one.
writeStrIL.Emit(OpCodes.Ldstr, inStr)
' Since the second argument is an object, and it corresponds to
' to the substitution for the value of our integer field, you
' need to box that field to an object. First, push a reference
' to the current instance, and then push the value stored in
' field 'x'. We need the reference to the current instance (stored
' in local argument index 0) so Ldfld can load from the correct
' instance (this one).
writeStrIL.Emit(OpCodes.Ldarg_0)
writeStrIL.Emit(OpCodes.Ldfld, xField)
' Now, we execute the box opcode, which pops the value of field 'x',
' returning a reference to the integer value boxed as an object.
writeStrIL.Emit(OpCodes.Box, GetType(Integer))
' Atop the stack, you'll find our string inStr, followed by a reference
' to the boxed value of 'x'. Now, you need to likewise box field 'y'.
writeStrIL.Emit(OpCodes.Ldarg_0)
writeStrIL.Emit(OpCodes.Ldfld, yField)
writeStrIL.Emit(OpCodes.Box, GetType(Integer))
' Now, you have all of the arguments for your call to
' Console.WriteLine(string, object, object) atop the stack:
' the string InStr, a reference to the boxed value of 'x', and
' a reference to the boxed value of 'y'.
' Call Console.WriteLine(string, object, object) with EmitCall.
writeStrIL.EmitCall(OpCodes.Call, writeLineMI, Nothing)
' Lastly, EmitWriteLine can also output the value of a field
' using the overload EmitWriteLine(FieldInfo).
writeStrIL.EmitWriteLine("The value of 'x' is:")
writeStrIL.EmitWriteLine(xField)
writeStrIL.EmitWriteLine("The value of 'y' is:")
writeStrIL.EmitWriteLine(yField)
' Since we return no value (void), the ret opcode will not
' return the top stack value.
writeStrIL.Emit(OpCodes.Ret)
Return pointTypeBld.CreateType()
End Function 'CreateDynamicType
Public Shared Sub Main()
Dim ctorParams(1) As Object
Console.Write("Enter a integer value for X: ")
Dim myX As String = Console.ReadLine()
Console.Write("Enter a integer value for Y: ")
Dim myY As String = Console.ReadLine()
Console.WriteLine("---")
ctorParams(0) = Convert.ToInt32(myX)
ctorParams(1) = Convert.ToInt32(myY)
Dim ptType As Type = CreateDynamicType()
Dim ptInstance As Object = Activator.CreateInstance(ptType, ctorParams)
ptType.InvokeMember("WritePoint", _
BindingFlags.InvokeMethod, _
Nothing, ptInstance, Nothing)
End Sub
End Class
注解
的类型 fld 必须与 方法重载 Console.WriteLine 的参数类型匹配。
适用于
EmitWriteLine(LocalBuilder)
- Source:
- ILGenerator.cs
- Source:
- ILGenerator.cs
- Source:
- ILGenerator.cs
发出使用给定本地变量调用 WriteLine 时必需的 Microsoft 中间语言 (MSIL)。
public:
virtual void EmitWriteLine(System::Reflection::Emit::LocalBuilder ^ localBuilder);public virtual void EmitWriteLine (System.Reflection.Emit.LocalBuilder localBuilder);abstract member EmitWriteLine : System.Reflection.Emit.LocalBuilder -> unit
override this.EmitWriteLine : System.Reflection.Emit.LocalBuilder -> unitPublic Overridable Sub EmitWriteLine (localBuilder As LocalBuilder)参数
- localBuilder
- LocalBuilder
其值将写入控制台的本地变量。
例外
localBuilder 为 null。
示例
下面的代码示例演示了 在动态方法中将字符串写入控制台的方法的上下文用法 EmitWriteLine 。
using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ CreateDynamicType()
{
array<Type^>^ctorParams = {int::typeid,int::typeid};
AppDomain^ myDomain = Thread::GetDomain();
AssemblyName^ myAsmName = gcnew AssemblyName;
myAsmName->Name = "MyDynamicAssembly";
AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::Run );
ModuleBuilder^ pointModule = myAsmBuilder->DefineDynamicModule( "PointModule", "Point.dll" );
TypeBuilder^ pointTypeBld = pointModule->DefineType( "Point", TypeAttributes::Public );
FieldBuilder^ xField = pointTypeBld->DefineField( "x", int::typeid, FieldAttributes::Public );
FieldBuilder^ yField = pointTypeBld->DefineField( "y", int::typeid, FieldAttributes::Public );
Type^ objType = Type::GetType( "System.Object" );
ConstructorInfo^ objCtor = objType->GetConstructor( gcnew array<Type^>(0) );
ConstructorBuilder^ pointCtor = pointTypeBld->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, ctorParams );
ILGenerator^ ctorIL = pointCtor->GetILGenerator();
// First, you build the constructor.
ctorIL->Emit( OpCodes::Ldarg_0 );
ctorIL->Emit( OpCodes::Call, objCtor );
ctorIL->Emit( OpCodes::Ldarg_0 );
ctorIL->Emit( OpCodes::Ldarg_1 );
ctorIL->Emit( OpCodes::Stfld, xField );
ctorIL->Emit( OpCodes::Ldarg_0 );
ctorIL->Emit( OpCodes::Ldarg_2 );
ctorIL->Emit( OpCodes::Stfld, yField );
ctorIL->Emit( OpCodes::Ret );
// Now, you'll build a method to output some information on the
// inside your dynamic class. This method will have the following
// definition in C#:
// public void WritePoint()
MethodBuilder^ writeStrMthd = pointTypeBld->DefineMethod( "WritePoint", MethodAttributes::Public, void::typeid, nullptr );
ILGenerator^ writeStrIL = writeStrMthd->GetILGenerator();
// The below ILGenerator created demonstrates a few ways to create
// String* output through STDIN.
// ILGenerator::EmitWriteLine(String*) will generate a ldstr and a
// call to WriteLine for you.
writeStrIL->EmitWriteLine( "The value of this current instance is:" );
// Here, you will do the hard work yourself. First, you need to create
// the String* we will be passing and obtain the correct WriteLine overload
// for said String*. In the below case, you are substituting in two values,
// so the chosen overload is Console::WriteLine(String*, Object*, Object*).
String^ inStr = "( {0}, {1})";
array<Type^>^wlParams = {String::typeid,Object::typeid,Object::typeid};
// We need the MethodInfo to pass into EmitCall later.
MethodInfo^ writeLineMI = Console::typeid->GetMethod( "WriteLine", wlParams );
// Push the String* with the substitutions onto the stack.
// This is the first argument for WriteLine - the String* one.
writeStrIL->Emit( OpCodes::Ldstr, inStr );
// Since the second argument is an Object*, and it corresponds to
// to the substitution for the value of our integer field, you
// need to box that field to an Object*. First, push a reference
// to the current instance, and then push the value stored in
// field 'x'. We need the reference to the current instance (stored
// in local argument index 0) so Ldfld can load from the correct
// instance (this one).
writeStrIL->Emit( OpCodes::Ldarg_0 );
writeStrIL->Emit( OpCodes::Ldfld, xField );
// Now, we execute the box opcode, which pops the value of field 'x',
// returning a reference to the integer value boxed as an Object*.
writeStrIL->Emit( OpCodes::Box, int::typeid );
// Atop the stack, you'll find our String* inStr, followed by a reference
// to the boxed value of 'x'. Now, you need to likewise box field 'y'.
writeStrIL->Emit( OpCodes::Ldarg_0 );
writeStrIL->Emit( OpCodes::Ldfld, yField );
writeStrIL->Emit( OpCodes::Box, int::typeid );
// Now, you have all of the arguments for your call to
// Console::WriteLine(String*, Object*, Object*) atop the stack:
// the String* InStr, a reference to the boxed value of 'x', and
// a reference to the boxed value of 'y'.
// Call Console::WriteLine(String*, Object*, Object*) with EmitCall.
writeStrIL->EmitCall( OpCodes::Call, writeLineMI, nullptr );
// Lastly, EmitWriteLine can also output the value of a field
// using the overload EmitWriteLine(FieldInfo).
writeStrIL->EmitWriteLine( "The value of 'x' is:" );
writeStrIL->EmitWriteLine( xField );
writeStrIL->EmitWriteLine( "The value of 'y' is:" );
writeStrIL->EmitWriteLine( yField );
// Since we return no value (void), the ret opcode will not
// return the top stack value.
writeStrIL->Emit( OpCodes::Ret );
return pointTypeBld->CreateType();
}
int main()
{
array<Object^>^ctorParams = gcnew array<Object^>(2);
Console::Write( "Enter a integer value for X: " );
String^ myX = Console::ReadLine();
Console::Write( "Enter a integer value for Y: " );
String^ myY = Console::ReadLine();
Console::WriteLine( "---" );
ctorParams[ 0 ] = Convert::ToInt32( myX );
ctorParams[ 1 ] = Convert::ToInt32( myY );
Type^ ptType = CreateDynamicType();
Object^ ptInstance = Activator::CreateInstance( ptType, ctorParams );
ptType->InvokeMember( "WritePoint", BindingFlags::InvokeMethod, nullptr, ptInstance, gcnew array<Object^>(0) );
}
using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
class EmitWriteLineDemo {
public static Type CreateDynamicType() {
Type[] ctorParams = new Type[] {typeof(int),
typeof(int)};
AppDomain myDomain = Thread.GetDomain();
AssemblyName myAsmName = new AssemblyName();
myAsmName.Name = "MyDynamicAssembly";
AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
myAsmName,
AssemblyBuilderAccess.Run);
ModuleBuilder pointModule = myAsmBuilder.DefineDynamicModule("PointModule",
"Point.dll");
TypeBuilder pointTypeBld = pointModule.DefineType("Point",
TypeAttributes.Public);
FieldBuilder xField = pointTypeBld.DefineField("x", typeof(int),
FieldAttributes.Public);
FieldBuilder yField = pointTypeBld.DefineField("y", typeof(int),
FieldAttributes.Public);
Type objType = Type.GetType("System.Object");
ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);
ConstructorBuilder pointCtor = pointTypeBld.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
ctorParams);
ILGenerator ctorIL = pointCtor.GetILGenerator();
// First, you build the constructor.
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Call, objCtor);
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_1);
ctorIL.Emit(OpCodes.Stfld, xField);
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_2);
ctorIL.Emit(OpCodes.Stfld, yField);
ctorIL.Emit(OpCodes.Ret);
// Now, you'll build a method to output some information on the
// inside your dynamic class. This method will have the following
// definition in C#:
// public void WritePoint()
MethodBuilder writeStrMthd = pointTypeBld.DefineMethod(
"WritePoint",
MethodAttributes.Public,
typeof(void),
null);
ILGenerator writeStrIL = writeStrMthd.GetILGenerator();
// The below ILGenerator created demonstrates a few ways to create
// string output through STDIN.
// ILGenerator.EmitWriteLine(string) will generate a ldstr and a
// call to WriteLine for you.
writeStrIL.EmitWriteLine("The value of this current instance is:");
// Here, you will do the hard work yourself. First, you need to create
// the string we will be passing and obtain the correct WriteLine overload
// for said string. In the below case, you are substituting in two values,
// so the chosen overload is Console.WriteLine(string, object, object).
String inStr = "({0}, {1})";
Type[] wlParams = new Type[] {typeof(string),
typeof(object),
typeof(object)};
// We need the MethodInfo to pass into EmitCall later.
MethodInfo writeLineMI = typeof(Console).GetMethod(
"WriteLine",
wlParams);
// Push the string with the substitutions onto the stack.
// This is the first argument for WriteLine - the string one.
writeStrIL.Emit(OpCodes.Ldstr, inStr);
// Since the second argument is an object, and it corresponds to
// to the substitution for the value of our integer field, you
// need to box that field to an object. First, push a reference
// to the current instance, and then push the value stored in
// field 'x'. We need the reference to the current instance (stored
// in local argument index 0) so Ldfld can load from the correct
// instance (this one).
writeStrIL.Emit(OpCodes.Ldarg_0);
writeStrIL.Emit(OpCodes.Ldfld, xField);
// Now, we execute the box opcode, which pops the value of field 'x',
// returning a reference to the integer value boxed as an object.
writeStrIL.Emit(OpCodes.Box, typeof(int));
// Atop the stack, you'll find our string inStr, followed by a reference
// to the boxed value of 'x'. Now, you need to likewise box field 'y'.
writeStrIL.Emit(OpCodes.Ldarg_0);
writeStrIL.Emit(OpCodes.Ldfld, yField);
writeStrIL.Emit(OpCodes.Box, typeof(int));
// Now, you have all of the arguments for your call to
// Console.WriteLine(string, object, object) atop the stack:
// the string InStr, a reference to the boxed value of 'x', and
// a reference to the boxed value of 'y'.
// Call Console.WriteLine(string, object, object) with EmitCall.
writeStrIL.EmitCall(OpCodes.Call, writeLineMI, null);
// Lastly, EmitWriteLine can also output the value of a field
// using the overload EmitWriteLine(FieldInfo).
writeStrIL.EmitWriteLine("The value of 'x' is:");
writeStrIL.EmitWriteLine(xField);
writeStrIL.EmitWriteLine("The value of 'y' is:");
writeStrIL.EmitWriteLine(yField);
// Since we return no value (void), the ret opcode will not
// return the top stack value.
writeStrIL.Emit(OpCodes.Ret);
return pointTypeBld.CreateType();
}
public static void Main() {
object[] ctorParams = new object[2];
Console.Write("Enter a integer value for X: ");
string myX = Console.ReadLine();
Console.Write("Enter a integer value for Y: ");
string myY = Console.ReadLine();
Console.WriteLine("---");
ctorParams[0] = Convert.ToInt32(myX);
ctorParams[1] = Convert.ToInt32(myY);
Type ptType = CreateDynamicType();
object ptInstance = Activator.CreateInstance(ptType, ctorParams);
ptType.InvokeMember("WritePoint",
BindingFlags.InvokeMethod,
null,
ptInstance,
new object[0]);
}
}
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
_
Class EmitWriteLineDemo
Public Shared Function CreateDynamicType() As Type
Dim ctorParams() As Type = {GetType(Integer), GetType(Integer)}
Dim myDomain As AppDomain = Thread.GetDomain()
Dim myAsmName As New AssemblyName()
myAsmName.Name = "MyDynamicAssembly"
Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave)
Dim pointModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("PointModule", "Point.dll")
Dim pointTypeBld As TypeBuilder = pointModule.DefineType("Point", _
TypeAttributes.Public)
Dim xField As FieldBuilder = pointTypeBld.DefineField("x", _
GetType(Integer), _
FieldAttributes.Public)
Dim yField As FieldBuilder = pointTypeBld.DefineField("y", _
GetType(Integer), _
FieldAttributes.Public)
Dim objType As Type = Type.GetType("System.Object")
Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type(){})
Dim pointCtor As ConstructorBuilder = pointTypeBld.DefineConstructor( _
MethodAttributes.Public, _
CallingConventions.Standard, _
ctorParams)
Dim ctorIL As ILGenerator = pointCtor.GetILGenerator()
' First, you build the constructor.
ctorIL.Emit(OpCodes.Ldarg_0)
ctorIL.Emit(OpCodes.Call, objCtor)
ctorIL.Emit(OpCodes.Ldarg_0)
ctorIL.Emit(OpCodes.Ldarg_1)
ctorIL.Emit(OpCodes.Stfld, xField)
ctorIL.Emit(OpCodes.Ldarg_0)
ctorIL.Emit(OpCodes.Ldarg_2)
ctorIL.Emit(OpCodes.Stfld, yField)
ctorIL.Emit(OpCodes.Ret)
' Now, you'll build a method to output some information on the
' inside your dynamic class. This method will have the following
' definition in C#:
' Public Sub WritePoint()
Dim writeStrMthd As MethodBuilder = pointTypeBld.DefineMethod("WritePoint", _
MethodAttributes.Public, _
Nothing, Nothing)
Dim writeStrIL As ILGenerator = writeStrMthd.GetILGenerator()
' The below ILGenerator created demonstrates a few ways to create
' string output through STDIN.
' ILGenerator.EmitWriteLine(string) will generate a ldstr and a
' call to WriteLine for you.
writeStrIL.EmitWriteLine("The value of this current instance is:")
' Here, you will do the hard work yourself. First, you need to create
' the string we will be passing and obtain the correct WriteLine overload
' for said string. In the below case, you are substituting in two values,
' so the chosen overload is Console.WriteLine(string, object, object).
Dim inStr As [String] = "({0}, {1})"
Dim wlParams() As Type = {GetType(String), GetType(Object), GetType(Object)}
' We need the MethodInfo to pass into EmitCall later.
Dim writeLineMI As MethodInfo = GetType(Console).GetMethod("WriteLine", wlParams)
' Push the string with the substitutions onto the stack.
' This is the first argument for WriteLine - the string one.
writeStrIL.Emit(OpCodes.Ldstr, inStr)
' Since the second argument is an object, and it corresponds to
' to the substitution for the value of our integer field, you
' need to box that field to an object. First, push a reference
' to the current instance, and then push the value stored in
' field 'x'. We need the reference to the current instance (stored
' in local argument index 0) so Ldfld can load from the correct
' instance (this one).
writeStrIL.Emit(OpCodes.Ldarg_0)
writeStrIL.Emit(OpCodes.Ldfld, xField)
' Now, we execute the box opcode, which pops the value of field 'x',
' returning a reference to the integer value boxed as an object.
writeStrIL.Emit(OpCodes.Box, GetType(Integer))
' Atop the stack, you'll find our string inStr, followed by a reference
' to the boxed value of 'x'. Now, you need to likewise box field 'y'.
writeStrIL.Emit(OpCodes.Ldarg_0)
writeStrIL.Emit(OpCodes.Ldfld, yField)
writeStrIL.Emit(OpCodes.Box, GetType(Integer))
' Now, you have all of the arguments for your call to
' Console.WriteLine(string, object, object) atop the stack:
' the string InStr, a reference to the boxed value of 'x', and
' a reference to the boxed value of 'y'.
' Call Console.WriteLine(string, object, object) with EmitCall.
writeStrIL.EmitCall(OpCodes.Call, writeLineMI, Nothing)
' Lastly, EmitWriteLine can also output the value of a field
' using the overload EmitWriteLine(FieldInfo).
writeStrIL.EmitWriteLine("The value of 'x' is:")
writeStrIL.EmitWriteLine(xField)
writeStrIL.EmitWriteLine("The value of 'y' is:")
writeStrIL.EmitWriteLine(yField)
' Since we return no value (void), the ret opcode will not
' return the top stack value.
writeStrIL.Emit(OpCodes.Ret)
Return pointTypeBld.CreateType()
End Function 'CreateDynamicType
Public Shared Sub Main()
Dim ctorParams(1) As Object
Console.Write("Enter a integer value for X: ")
Dim myX As String = Console.ReadLine()
Console.Write("Enter a integer value for Y: ")
Dim myY As String = Console.ReadLine()
Console.WriteLine("---")
ctorParams(0) = Convert.ToInt32(myX)
ctorParams(1) = Convert.ToInt32(myY)
Dim ptType As Type = CreateDynamicType()
Dim ptInstance As Object = Activator.CreateInstance(ptType, ctorParams)
ptType.InvokeMember("WritePoint", _
BindingFlags.InvokeMethod, _
Nothing, ptInstance, Nothing)
End Sub
End Class
注解
的类型 localBuilder 必须与 方法重载 Console.WriteLine 的参数类型匹配。
适用于
反馈
即将发布：在整个 2024 年，我们将逐步淘汰作为内容反馈机制的“GitHub 问题”，并将其取代为新的反馈系统。 有关详细信息，请参阅：https://aka.ms/ContentUserFeedback。
提交和查看相关反馈