using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.InteropServices;
public class Example
{
// 下面的构造函数和公有属性用于将动态方法绑定到对象实例时使用
public int Test;
public Example(int test)
{
this.Test = test;
}
// 下面的代理(delegate)用于调用动态方法
private delegate long Square(int input);
private delegate int Bound(int input);
private delegate int Unbound(Example target, int input);
/// <summary>
/// 动态方法简单调用
/// </summary>
/// <param name="outputBlock"></param>
public static void Demo1(System.Windows.Controls.TextBlock outputBlock)
{
outputBlock.Text += "例子 1 : 动态方法简单调用\n\n";
// 例子 1: 简单的动态方法
// 创建一个动态方法所使用的参数类型数组,因为当前例子中只有一个参数(int 类型),所
// 以数组中将会只有一个类型
Type[] methodArgs = { typeof(int) };
// 创建一个动态方法（DynamicMethod）。
// 在这个例子中, 方法名称为SquareIt(平方运算).
// 另外,动态方法名称不是必填项. 因为系统不会按方法名称来调用动态方法(而是采用delegate).
// 还有就是两个动态方法可以使用同一个方法名称.不过,这个方法名称会在调用堆栈(calls stacks)
// 中出现,这样便于进行调试
//
// 在这个例中,动态方法的返回类型是Long [如下typeof(long)].
System.Reflection.Emit.DynamicMethod squareIt = new System.Reflection.Emit.DynamicMethod(
"SquareIt",
typeof(long),
methodArgs
);
// 下面是SquareIt(平方运算)的函数内容.
// 在这个例子中, 使用ILGenerator生成 MSIL(MS中间语言).
// DynamicMethod has an associated type DynamicILInfo that can be used in conjunction with
// unmanaged code generators.
//
// MSIL 加载该参数(Integer)到堆栈上 , 并将其转换成为Long 类型. duplicates(复制) 栈顶元素.
// 然后将栈顶的两个元素的乘积(平方运算)压入堆栈(返回结果时使用)
ILGenerator il = squareIt.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Conv_I8);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Mul);
il.Emit(OpCodes.Ret);
// 为上面的方法创建一个代码并将其绑定到Square的实例上.
// Creating the delegate completes the method, and any further
// attempts to change the method (for example, by adding more
// MSIL) are ignored.
//
Square invokeSquareIt =
(Square)squareIt.CreateDelegate(typeof(Square));
// 下面的代码显示了如使用 Square delegate,
outputBlock.Text += String.Format("123456789 squared = {0}\n",
invokeSquareIt(123456789));
// 当然绑定代理也可以使用 Func (能生成带单一参数且有返回类型的泛型代理),如下:
Func<int, long> invokeGeneric =
(Func<int, long>)squareIt.CreateDelegate(typeof(Func<int, long>));
outputBlock.Text += String.Format("987654321 squared = {0}\n",
invokeGeneric(987654321));
}
/// <summary>
/// 对象实例绑定调用
/// </summary>
/// <param name="outputBlock"></param>
public static void Demo2(System.Windows.Controls.TextBlock outputBlock)
{
outputBlock.Text += "\n例子 2: 对象实例绑定调用\n\n";
// 例子 2: 将动态方法绑定到实例上.
//
// 下面语句将会创建一个指定参数类型的数组,以便将其绑定的动态方法上
// 如要将方法(method)代理绑定到对象上,那么第一个参数应匹配代理要绑定的对象类型
// 在下面代码中,要绑定的是Example类型的对象
Type[] methodArgs2 = { typeof(Example), typeof(int) };
// 创建动态方法, 在这个例子中, 该(动态)方法没有指定名称(为""),
// 返回值类型为Integer. 这个方法将会访问Example类的公有成员(Test)
//
System.Reflection.Emit.DynamicMethod multiplyTestField = new System.Reflection.Emit.DynamicMethod(
"",
typeof(int),
methodArgs2
);
// 在这个例子中, 使用ILGenerator生成 MSIL(MS中间语言).
//
// MSIL 加载第一个参数(Example类的一个实例), 然后使用这个实例来访问公有成员(Test)
ILGenerator ilMP = multiplyTestField.GetILGenerator();
ilMP.Emit(OpCodes.Ldarg_0);
FieldInfo testInfo = typeof(Example).GetField("Test",
BindingFlags.Public | BindingFlags.Instance);
// 加载第二个参数, 然后这两个数字会被相乘,如果返回值比INT大,则会执行截取操作,并将结果返回.
ilMP.Emit(OpCodes.Ldfld, testInfo);
ilMP.Emit(OpCodes.Ldarg_1);
ilMP.Emit(OpCodes.Mul);
ilMP.Emit(OpCodes.Ret);
#region Bound1
// 创建上面动态方法的代理.
// Creating the delegate completes the method, and any further
// attempts to change the method for example, by adding more
// MSIL are ignored.
//
// 下面代码会将上面的动态方法绑定到Example 类的一个新实例上,同时将该实例的Test属性设置成42.
// 这样每次代理运行时,都会调用同一个Example实例.另外这个代理将不再使用类型Example作为参数,
// 因为Example的实例已绑定到了代理的Target参数上(如下面的((Example)invoke.Target).Test调用)
// 因为下面的方法调用就像是隐藏了方法的第一个参数一样.
//
// 下面代理被执行了两次,分别使用了不同的参数值(分别为3, 5)
Bound invoke = (Bound)multiplyTestField.CreateDelegate(
typeof(Bound), new Example(42));
outputBlock.Text += String.Format(
"Example.Test = {0}; {1} * Example.Test = {2}\n",
((Example)invoke.Target).Test, 3, invoke(3));
outputBlock.Text += String.Format(
"Example.Test = {0}; {1} * Example.Test = {2}\n",
((Example)invoke.Target).Test, 5, invoke(5));
//修改当前实例的Test字段(42*2=84)
((Example)invoke.Target).Test *= 2;
outputBlock.Text += String.Format(
"Example.Test = {0}; {1} * Example.Test = {2}\n\n",
((Example)invoke.Target).Test, 5, invoke(5));
#endregion
#region Bound2
// 下面的Example实例将会被绑定到一个Bound代理上, 然后这个代理会运行两次,
// 其间对 Example的Test值进行加1操作(类似上面的*2操作)
Example ex = new Example(5280);
Bound another =
(Bound)multiplyTestField.CreateDelegate(typeof(Bound), ex);
outputBlock.Text += String.Format(
"Example.Test = {0}; {1} * Example.Test = {2}\n",
ex.Test, 3, another(3));
ex.Test += 1;
outputBlock.Text += String.Format(
"Example.Test = {0}; {1} * Example.Test = {2}\n\n",
ex.Test, 3, another(3));
#endregion
#region Unbound
// 最后,创建一个类型Unbound的代理.而它有两个参数,一个是Example的实例,另一个是一个Integer型数据.
// 下面的代理(Unbound) 将会绑定不带Example实例的方法,实相应的实例参数将会在代理执行过程中进行加载
Unbound notBound =
(Unbound)multiplyTestField.CreateDelegate(typeof(Unbound));
outputBlock.Text += String.Format("{0} * Example.Test(42) = {1}\n",
10, notBound(new Example(42), 10));
outputBlock.Text += String.Format("{0} * Example.Test(56) = {1}\n",
10, notBound(new Example(56), 10));
#endregion
}
}
