static bool DoLdelem ()
{
DynamicMethod dm = new DynamicMethod ("EmittedLdelem", typeof (int), null, typeof (Testcase));
ILGenerator il = dm.GetILGenerator ();
il.Emit (OpCodes.Ldsfld, ArrayFI);
il.Emit (OpCodes.Ldc_I4_1);
il.Emit (OpCodes.Ldelem, typeof (int));
il.Emit (OpCodes.Ret);
int i = (int) dm.Invoke (null, null);
return (i == 2);
}
internal static Task RaiseEventAsync <TSender, TEventArgs>(string eventName, TSender sender, TEventArgs eventArgs, Dictionary <string, List <DelegateWrapper> > delegateWrapperDict) where TSender : class where TEventArgs : class
{
if (!delegateWrapperDict.TryGetValue(eventName, out List <DelegateWrapper> wrappers))
{
return(Task.CompletedTask);
}
List <DelegateWrapper> toRemoves = new List <DelegateWrapper>();
List <(object, MethodInfo)> toRaises = new List <(object, MethodInfo)>();
foreach (DelegateWrapper wrapper in wrappers)
{
object caller = wrapper.CallerWeakReference?.Target;
if (wrapper.CallerWeakReference != null && caller == null)
{
toRemoves.Add(wrapper);
}
else
{
toRaises.Add((caller, wrapper.Handler));
}
}
//clean
toRemoves.ForEach(w => wrappers.Remove(w));
List <Task> tasks = new List <Task>();
//Invoke
for (int i = 0; i < toRaises.Count; ++i)
{
(object caller, MethodInfo methodInfo) = toRaises[i];
object rtObj;
if (methodInfo.IsLightweightMethod())
{
DynamicMethod dynamicMethodInfo = TryGetDynamicMethod(methodInfo);
rtObj = dynamicMethodInfo?.Invoke(caller, new object[] { sender, eventArgs });
}
else
{
rtObj = methodInfo.Invoke(caller, new object[] { sender, eventArgs });
}
Task task = (Task)rtObj;
tasks.Add(task);
}
return(Task.WhenAll(tasks));
}
static bool DoStelem ()
{
DynamicMethod dm = new DynamicMethod ("EmittedStelem", null, null, typeof (Testcase));
ILGenerator il = dm.GetILGenerator ();
il.Emit (OpCodes.Ldsfld, ArrayFI);
il.Emit (OpCodes.Ldc_I4_0);
il.Emit (OpCodes.Ldc_I4_0);
il.Emit (OpCodes.Stelem, typeof (int));
il.Emit (OpCodes.Ret);
dm.Invoke (null, null);
return (Array [0] == 0);
}
public static int Main()
{
DynamicMethod method_builder = new DynamicMethod ("WriteHello" , typeof (int), new Type[] {typeof (Driver)}, typeof (Driver));
ILGenerator ilg = method_builder.GetILGenerator ();
ilg.Emit (OpCodes.Ldarg_0);
ilg.Emit (OpCodes.Call, typeof (Driver).GetMethod ("Foo"));
ilg.Emit (OpCodes.Ret);
int res = (int) method_builder.Invoke (null, new object[] {new Driver()});
return res == -99 ? 0 : 1;
}
public static int Main()
{
DynamicMethod
method_builder
=
new
DynamicMethod
("ThrowException"
,
typeof
(void),
new
Type[0],
typeof
(Driver));
ILGenerator
ilg
=
method_builder.GetILGenerator
();
ilg.Emit
(OpCodes.Newobj,
typeof
(MyException).GetConstructor
(new
Type[0]));
ilg.Emit
(OpCodes.Throw);
try
{
method_builder.Invoke
(null,
null);
return
2;
}
catch
(TargetInvocationException
tie)
{
if(!
(tie.InnerException
is
MyException))
return
3;
}
return
0;
}
static void M1()
{
DynamicMethod dm = new DynamicMethod("HelloWorld", typeof(void), new Type[] { }, typeof(Program), false);
ILGenerator il = dm.GetILGenerator();
TestShowVisualizer(dm);
il.Emit(OpCodes.Ldstr, "hello, world");
TestShowVisualizer(dm);
il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }));
TestShowVisualizer(dm);
il.Emit(OpCodes.Ret);
TestShowVisualizer(dm);
dm.Invoke(null, null);
}
[Test] // bug #78253
public void DynamicMethodReference()
{
DynamicMethod hello = new DynamicMethod("Hello",
typeof(int),
new Type[] { typeof(string) },
typeof(DynamicMethodTest).Module);
Assert.IsNull(hello.DeclaringType, "#1");
DynamicMethod write = new DynamicMethod("Write",
typeof(int),
new Type[] { typeof(string) },
typeof(DynamicMethodTest));
Assert.IsNull(hello.DeclaringType, "#2");
MethodInfo invokeWrite = write.GetBaseDefinition();
ILGenerator helloIL = hello.GetILGenerator();
helloIL.Emit(OpCodes.Ldarg_0);
helloIL.EmitCall(OpCodes.Call, invokeWrite, null);
helloIL.Emit(OpCodes.Ret);
ILGenerator writeIL = write.GetILGenerator();
writeIL.Emit(OpCodes.Ldc_I4_2);
writeIL.Emit(OpCodes.Ret);
HelloInvoker hi =
(HelloInvoker)hello.CreateDelegate(typeof(HelloInvoker));
int ret = hi("Hello, World!");
Assert.AreEqual(2, ret, "#3");
object[] invokeArgs = { "Hello, World!" };
object objRet = hello.Invoke(null, invokeArgs);
Assert.AreEqual(2, objRet, "#4");
}
static void Main(string[] args)
{
var dynMethod = new DynamicMethod("HelloMethod", null, null);
ILGenerator gen = dynMethod.GetILGenerator();
gen.EmitWriteLine("Hello world");
gen.Emit(OpCodes.Ret);
dynMethod.Invoke(null, null);
AssemblyName name = new AssemblyName("DynamicAssembly");
//AssemblyBuilder assemblyBuilder= AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.RunAndSave);
AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run);
//ModuleBuilder moduleBuilder= assemblyBuilder.DefineDynamicModule("DynamicModule", "DynamicAssembly.dll");
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("DynamicModule");
TypeBuilder tb = moduleBuilder.DefineType("HelloClass", TypeAttributes.Class | TypeAttributes.Public);
MethodBuilder mb = tb.DefineMethod("PrintHello", MethodAttributes.Public, null, new Type[] { typeof(string) });
ILGenerator myMethodIL = mb.GetILGenerator();
myMethodIL.Emit(OpCodes.Ldstr, "Hello ");
myMethodIL.Emit(OpCodes.Ldarg_1);
MethodInfo concatMethod = typeof(String).GetMethod("Concat", new Type[] { typeof(string), typeof(string) });
myMethodIL.Emit(OpCodes.Call, concatMethod);
MethodInfo writeMethod = typeof(Console).GetMethod("Write", new Type[] { typeof(string) });
myMethodIL.Emit(OpCodes.Call, writeMethod);
myMethodIL.Emit(OpCodes.Ret);
Type helloType = tb.CreateType();
object helloObj = Activator.CreateInstance(helloType);
MethodInfo helloInstanceMethod = helloType.GetMethod("PrintHello", new Type[] { typeof(string) });
helloInstanceMethod.Invoke(helloObj, new object[] { "Antonio" });
//assemblyBuilder.Save("DynamicAssembly.dll");
}
public void GetTokenFor_CtorMethodAndField_Success()
{
DynamicMethod dynamicMethod = new DynamicMethod(nameof(Mock), typeof(Person), new Type[] { }, typeof(DynamicILInfoTests), false);
DynamicILInfo dynamicILInfo = dynamicMethod.GetDynamicILInfo();
SignatureHelper sigHelper = SignatureHelper.GetLocalVarSigHelper();
sigHelper.AddArgument(typeof(Person), false);
sigHelper.AddArgument(typeof(Person), false);
dynamicILInfo.SetLocalSignature(sigHelper.GetSignature());
byte[] code =
{
0x00, 0x72, 0x49, 0x00, 0x00, 0x70, 0x1f, 0x32, 0x22, 0x00, 0x60, 0xea, 0x46, 0x73, 0x0f, 0x00,
0x00, 0x06, 0x0a, 0x06, 0x72, 0x53, 0x00, 0x00, 0x70, 0x7d, 0x04, 0x00, 0x00, 0x04, 0x06, 0x25,
0x6f, 0x0c, 0x00, 0x00, 0x06, 0x17, 0x58, 0x6f, 0x0d, 0x00, 0x00, 0x06, 0x00, 0x06, 0x22, 0x00,
0x00, 0x96, 0x43, 0x6f, 0x10, 0x00, 0x00, 0x06, 0x00, 0x06, 0x0b, 0x2b, 0x00, 0x07, 0x2a
};
int token0 = dynamicILInfo.GetTokenFor("Bill");
int token1 = dynamicILInfo.GetTokenFor(typeof(Person).GetConstructor(new Type[] { typeof(string), typeof(int), typeof(float) }).MethodHandle);
int token2 = dynamicILInfo.GetTokenFor("Bill Gates");
int token3 = dynamicILInfo.GetTokenFor(typeof(Person).GetField("m_name").FieldHandle);
int token4 = dynamicILInfo.GetTokenFor(typeof(Person).GetMethod("get_Age").MethodHandle);
int token5 = dynamicILInfo.GetTokenFor(typeof(Person).GetMethod("set_Age").MethodHandle);
int token6 = dynamicILInfo.GetTokenFor(typeof(Person).GetMethod("IncSalary").MethodHandle);
PutInteger4(token0, 0x0002, code);
PutInteger4(token1, 0x000e, code);
PutInteger4(token2, 0x0015, code);
PutInteger4(token3, 0x001a, code);
PutInteger4(token4, 0x0021, code);
PutInteger4(token5, 0x0028, code);
PutInteger4(token6, 0x0034, code);
dynamicILInfo.SetCode(code, 4);
Person ret = (Person)dynamicMethod.Invoke(null, null);
Assert.Equal(ret, Mock());
}
public void ReturnType_Null()
{
DynamicMethod hello = new DynamicMethod("Hello",
null,
new Type[] { typeof(string) },
typeof(DynamicMethodTest).Module, true);
Assert.AreEqual(typeof(void), hello.ReturnType, "#1");
ILGenerator helloIL = hello.GetILGenerator();
helloIL.Emit(OpCodes.Ret);
DoNothing dn = (DoNothing)hello.CreateDelegate(typeof(DoNothing));
dn("whatever");
object[] invokeArgs = { "Hello, World!" };
object objRet = hello.Invoke(null, invokeArgs);
Assert.IsNull(objRet, "#2");
}
public void TestCalliGenerationIntInt()
{
int callCount = 0;
int setVal = 0;
TakeReturn1Int vvct = (i) =>
{
callCount++;
setVal = i;
return(i + 1);
};
var fp = Marshal.GetFunctionPointerForDelegate(vvct);
CalliILGenerator generator = new CalliILGenerator();
DynamicMethod method = new DynamicMethod("MyFunc", typeof(int), new Type[] { typeof(int) });
generator.GenerateMethod(method.GetILGenerator(), method.ReturnType, new Type[] { typeof(int) }, fp);
var ret = method.Invoke(null, new object[] { 5 });
Assert.Equal(1, callCount);
Assert.Equal(5, setVal);
Assert.Equal(6, ret);
}
/// <summary>
/// Maps objects using IL emitting.
/// </summary>
/// <typeparam name="TSource"> Type of source object. </typeparam>
/// <typeparam name="TDestination"> Type of destination object. </typeparam>
/// <param name="sourceObject"> Source object. </param>
/// <returns> Returns destination object. </returns>
private TDestination MapUsingIL_Emitting <TSource, TDestination>(TSource sourceObject)
{
//dynamic method
var dynamicMethod = new DynamicMethod("IL_Map", typeof(void),
new [] { typeof(TSource), typeof(TDestination) }, typeof(Mapper).Module);
//getting IL generator
var ilGen = dynamicMethod.GetILGenerator();
//getting properties
var properties = typeof(TSource).GetProperties();
//creating destination object
var destObject = Activator.CreateInstance <TDestination>();
//constructing dynamic method
foreach (var propertyInfo in properties)
{
//emitting arguments
ilGen.Emit(OpCodes.Ldarg_1);
ilGen.Emit(OpCodes.Ldarg_0);
//getting destination object property
var destProp = typeof(TDestination).GetProperty(propertyInfo.Name);
//emitting calls
ilGen.EmitCall(OpCodes.Callvirt, propertyInfo.GetGetMethod(), null);
ilGen.EmitCall(OpCodes.Callvirt, destProp.GetSetMethod(), null);
}
//emitting return statement
ilGen.Emit(OpCodes.Ret);
//invoking dynamic method
dynamicMethod.Invoke(null, new object [] { sourceObject, destObject });
//returning destination object
return(destObject);
}
private static object BaseCall(this object self, string methodName, Type returnType, object defaultReturn, object[] parameters)
{
var parameterTypes = parameters.Select(p => p.GetType()).ToArray();
if (self.GetType().BaseType == null)
{
return(null);
}
var method = self.GetType().BaseType.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, parameterTypes, null);
if (method == null || method.IsAbstract)
{
return(defaultReturn);
}
var dm = new DynamicMethod(methodName, returnType, new Type[] { self.GetType() }.Concat(parameterTypes).ToArray(), self.GetType());
var il = dm.GetILGenerator();
PushParameters(il, parameterTypes.Length);
il.Emit(OpCodes.Call, method);
il.Emit(OpCodes.Ret);
return(dm.Invoke(null, new object[] { self }.Concat(parameters).ToArray()));
}
public void CanEmitSerializerWithCustomDateFormat()
{
NullableDateTimeConverter converter = new NullableDateTimeConverter();
DateTime? date = new DateTime(2019, 5, 4, 3, 2, 1);
CsvColumnAttribute attribute = new CsvColumnAttribute("Date")
{
DateFormat = "yyyy/MMM/dd H:mm:ss"
};
DynamicMethod serialize = new DynamicMethod("Serialize", typeof(string), new Type[] { typeof(DateTime?), typeof(IFormatProvider), typeof(char) }, typeof(DateTimeConverterTests));
serialize.GetILGenerator()
.DeclareLocal <DateTime?>(out LocalBuilder nullableLocal)
.DeclareLocal <DateTime>(out LocalBuilder local)
.Newobj <StringBuilder>()
.Ldarg_0()
.Emit(gen => converter.EmitAppendToStringBuilder(gen, nullableLocal, local, attribute))
.Callvirt <StringBuilder>("ToString")
.Ret();
string serialized = (string)serialize.Invoke(null, new object?[] { date, CultureInfo.InvariantCulture, ',' }) !;
serialized.Should().Be("2019/May/04 3:02:01");
}
public T EvaluateExpression <T>()
{
var evaluator = new DynamicMethod("eval", typeof(T), new Type[] {});
var ilGen = evaluator.GetILGenerator();
var parts = _scheme.ParseInstructions();
foreach (var part in parts)
{
if (part.Value == null)
{
ilGen.Emit(part.Code);
}
else
{
ilGen.Emit(part.Code, part.Value);
}
}
ilGen.Emit(System.Reflection.Emit.OpCodes.Ret);
return((T)evaluator.Invoke(null, new object[] {}));
}
/// <summary>
/// Gets the pointer to the method table for the array type.
/// </summary>
/// <remarks>
/// The generated function is basically...
/// <code>
/// private static IntPtr GetMethodTablePointer_T(T[] array)
/// {
/// fixed(T* p = array)
/// {
/// return ((IntPtr*) p)[_methodTableOffset];
/// }
/// }
/// </code>
/// </remarks>
private static IntPtr GetMethodTablePointer(Type baseType, Type arrayType, Type refType, object oneElemArray)
{
var mname = "GetMethodTablePointer_" + baseType.Name;
var method = new DynamicMethod(mname, typeof(IntPtr), new[] { arrayType }, MyModule);
var il = method.GetILGenerator();
il.DeclareLocal(refType, true);
il.Emit(OpCodes.Ldarg_0); // Load the array
il.Emit(OpCodes.Ldc_I4_0); // Push a 0 offset
il.Emit(OpCodes.Ldelema, baseType); // Get address of array data
il.Emit(OpCodes.Stloc_0); // Pin array
il.Emit(OpCodes.Ldloc_0); // Load pinned (the store/load here is required for pinning)
il.Emit(OpCodes.Conv_I); // Convert to IntPtr
il.Emit(OpCodes.Ldc_I4, MethodTableOffset); // Load offset of method table pointer
il.Emit(OpCodes.Conv_I); // Convert that to a ptrdiff_t
il.Emit(OpCodes.Sizeof, typeof(IntPtr)); // Load sizeof(size_t)
il.Emit(OpCodes.Mul); // Multiply offset * sizeof(size_t) to get offset in bytes
il.Emit(OpCodes.Add); // Add that to the array data offset
il.Emit(OpCodes.Ldind_I); // Get element at that address
il.Emit(OpCodes.Ret); // Return it
return((IntPtr)method.Invoke(null, new[] { oneElemArray }));
}
//reflect+emit调用
private void DynamicEmitInvoke <T>(Type eventType, Delegate ihandler, T message) where T : MessageBase
{
var handler = ihandler.DynamicInvoke();
var concreteType = typeof(IProcessMessage <>).MakeGenericType(eventType);
var dynamicMethod = new DynamicMethod(concreteType.Name + ihandler.GetType().Name, null, new Type[] { concreteType, typeof(T) });
var method = concreteType.GetMethod("ProcessMsg");
//方法IL
ILGenerator il = dynamicMethod.GetILGenerator();
il.Emit(OpCodes.Ldarg_0); //put IProcessMessage<> arg into stack
il.Emit(OpCodes.Ldarg_1); //put T : MessageBase arg into stack
if (eventType == method.DeclaringType) //call IProcessMessage.ProcessMsg
{
il.Emit(OpCodes.Call, method);
}
else
{
il.Emit(OpCodes.Callvirt, method);
}
il.Emit(OpCodes.Ret); //return
dynamicMethod.Invoke(new object(), new object[] { handler, message }); //动态调用Delegate ihandler中的PROCESSMSG，参数是paras[0]
}
private void GeneratePrefixForVoidDispatcherWorks()
{
// Generate prefix for SingleArg
MethodInfo method = AccessTools.Method(typeof(Foo), nameof(Foo.SingleArg));
MethodInfo dispatcher = AccessTools.Method(
typeof(MethodPatchFactory_Test),
nameof(DispatcherVoid));
MethodAccess access = new MethodAccess(method);
DynamicMethod prefix = MethodPatchFactory.GeneratePrefix(
access,
dispatcher,
EPatchBehaviour.AlwaysCallOriginal);
// Call
object ret = prefix.Invoke(m_Foo, new object[] { m_Foo, 42 });
Assert.IsType <bool>(ret);
Assert.True((bool)ret); // AlwaysCallOriginal
Assert.Single(m_DispatcherCalls);
Assert.NotNull(m_DispatcherCalls[0]);
Assert.Same(access, m_DispatcherCalls[0]);
}
public static bool performToolAction_Prefix(ref Tree __instance, Tool t, int explosion, Vector2 tileLocation, GameLocation location, ref bool __result)
{
// Gotta have the original method available for mattock stand-ins.
if (performToolActionOriginal == null)
{
return(true);
}
// If the tool is a mattock and this object is one that requires a specific type of tool that is supported,
// run the function with a stand-in tool instead.
if (t is Mattock mattock && !mattock.struckFeatures.Contains(__instance))
{
// Treat the mattock as an axe for stumps.
Axe standinAxe = mattock.asAxe();
mattock.struckFeatures.Add(__instance);
__result = (bool)performToolActionOriginal.Invoke(__instance, new object[] { __instance, standinAxe, explosion, tileLocation, location });
return(false);
}
// Otherwise, just do the default functionality.
return(true);
}
static double ExecuteExpression(string expression, Dictionary <string, NumberType> variables, out IList <Token> lexics)
{
lexics = LexicalParser.Parse(expression).ToList();
SyntaxTree syntaxTree = SyntaxParser.Parse(lexics);
DynamicMethod method = ArithmeticTreeCompiler.Compile(syntaxTree);
var undefinedVariables = syntaxTree.VariableNames.Except(variables.Keys).ToList();
if (undefinedVariables.Count != 0)
{
throw new ArgumentException($"Undefined variables found: {string.Join(", ", undefinedVariables)}");
}
object[] args =
syntaxTree.VariableNames
.OrderBy(i => i)
.Select(i => variables[i])
.Cast <object>()
.ToArray();
return((double)method.Invoke(null, args));
}
public override EmulationResult Emulate(Context ctx)
{
if (!(ctx.Instruction.Operand is IType iType))
{
throw new InvalidILException(ctx.Instruction.ToString());
}
var type = ctx.Emulator.DynamicContext.LookupMember <Type>(iType.MDToken.ToInt32());
if (!_typeSizeCache.TryGetValue(type, out int size))
{
var dynamicMethod = new DynamicMethod(string.Empty, typeof(int), Type.EmptyTypes);
var ilGenerator = dynamicMethod.GetILGenerator();
ilGenerator.Emit(SRE.OpCodes.Sizeof, type);
ilGenerator.Emit(SRE.OpCodes.Ret);
size = (int)dynamicMethod.Invoke(null, new object[0]);
_typeSizeCache.Add(type, size);
}
ctx.Stack.Push(new I4Value(size));
return(new NormalResult());
}
private Dictionary <string, object> GetExceptionFieldValues(Exception value)
{
// Obtain the unoverrided version of Message
Type exceptionType = Globals.TypeOfException;
PropertyInfo messageProperty = exceptionType.GetProperty("Message");
MethodInfo messageGetter = messageProperty.GetMethod;
#if !NET_NATIVE
DynamicMethod baseMessageImpl = new DynamicMethod("NonVirtual_Message", typeof(string), new Type[] { Globals.TypeOfException }, Globals.TypeOfException);
ILGenerator gen = baseMessageImpl.GetILGenerator();
gen.Emit(OpCodes.Ldarg, messageGetter.GetParameters().Length);
gen.EmitCall(OpCodes.Call, messageGetter, null);
gen.Emit(OpCodes.Ret);
string messageValue = (string)baseMessageImpl.Invoke(null, new object[] { value });
#else
string messageValue = string.Empty;
#endif
// Populate the values for the necessary System.Exception private fields.
Dictionary <string, object> fieldToValueDictionary = new Dictionary <string, object>();
fieldToValueDictionary.Add("_className", value.GetType().ToString());
fieldToValueDictionary.Add("_message", messageValue); //Thick framework retrieves the System.Exception implementation of message
fieldToValueDictionary.Add("_data", value.Data);
fieldToValueDictionary.Add("_innerException", value.InnerException);
fieldToValueDictionary.Add("_helpURL", value.HelpLink);
fieldToValueDictionary.Add("_stackTraceString", value.StackTrace);
fieldToValueDictionary.Add("_remoteStackTraceString", null);
fieldToValueDictionary.Add("_remoteStackIndex", 0);
fieldToValueDictionary.Add("_exceptionMethodString", null);
fieldToValueDictionary.Add("_HResult", value.HResult);
fieldToValueDictionary.Add("_source", null); //value.source caused transparency error on build.
fieldToValueDictionary.Add("_watsonBuckets", null);
return(fieldToValueDictionary);
}
public void While()
{
DynamicMethod method = new DynamicMethod("temp", typeof(int), Type.EmptyTypes);
MethodGenerator g = new MethodGenerator(method);
const int maxNumber = 15;
var num = g.Declare(0);
var max = g.Declare(maxNumber);
g.While(() =>
{
g.Load(num);
g.Load(max);
return(LogicOperator.LessThan);
}, () =>
{
g.Increment(num);
});
g.Load(num);
g.Return();
int result = (int)method.Invoke(null, new object[] { });
Assert.AreEqual(maxNumber, result);
}
private Func <object, object, object> GenerateOpMethod(OpCode op, Type returnType)
{
var method = new DynamicMethod(Guid.NewGuid().ToString(), returnType, new[] { Type, Type });
var gen = method.GetILGenerator();
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldarg_1);
gen.Emit(op);
gen.Emit(OpCodes.Ret);
return((o0, o1) =>
{
try
{
return method.Invoke(null, new[] { o0, o1 });
}
catch (TargetInvocationException ex)
{
throw ex.InnerException;
}
});
}
public void TestDynamicMethodEmitCalliNonBlittable()
{
string input = "Test string!", result = "!gnirts tseT";
Type returnType = typeof(string);
var dynamicMethod = new DynamicMethod("F", returnType, new Type[] { typeof(IntPtr), typeof(string) });
ILGenerator il = dynamicMethod.GetILGenerator();
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldarg_0);
il.EmitCalli(OpCodes.Calli, CallingConvention.Cdecl, returnType, new Type[] { typeof(string) });
il.Emit(OpCodes.Ret);
IntPtr funcPtr = Marshal.GetFunctionPointerForDelegate(new StringReverseCdecl(StringReverse));
object resultValue = dynamicMethod
.Invoke(null, new object[] { funcPtr, input });
Assert.IsType(returnType, resultValue);
Assert.Equal(result, resultValue);
}
static void IlGenerator()
{
var myMethod = new DynamicMethod("DividerMethod",
typeof(double),
new[] { typeof(int), typeof(int) },
typeof(Program).Module);
var il = myMethod.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Div); // 2 pop and one push from/into the evaluation stack
il.Emit(OpCodes.Ret);
var result = myMethod.Invoke(null, new object[] { 10, 2 });
Console.WriteLine(result);
var method = (DivideDelegate)myMethod.CreateDelegate(typeof(DivideDelegate));
var result2 = method(6, 2);
Console.WriteLine(result2);
}
private static void SetValue <TObject>(ref TObject o, FieldInfo field, object value)
{
Debug.Assert(o != null);
Debug.Assert(value != null);
Debug.Assert(field != null);
Debug.Assert(field.FieldType == value.GetType());
Debug.Assert(field.DeclaringType == typeof(TObject));
var method = new DynamicMethod("", returnType: typeof(object),
parameterTypes: new[] { typeof(object), typeof(object) },
owner: field.DeclaringType);
var generator = method.GetILGenerator();
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Dup);
generator.Emit(field.DeclaringType.IsValueType ? OpCodes.Unbox : OpCodes.Castclass, field.DeclaringType);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Unbox_Any, field.FieldType);
generator.Emit(OpCodes.Stfld, field);
generator.Emit(OpCodes.Ret);
o = (TObject)method.Invoke(o, new[] { o, value });
}
public void TestDynamicMethodEmitCalliBlittable()
{
int a = 1, b = 1, result = 2;
Type returnType = typeof(int);
var dynamicMethod = new DynamicMethod("F", returnType, new Type[] { typeof(IntPtr), typeof(int), typeof(int) });
ILGenerator il = dynamicMethod.GetILGenerator();
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldarg_0);
il.EmitCalli(OpCodes.Calli, CallingConvention.StdCall, returnType, new Type[] { typeof(int), typeof(int) });
il.Emit(OpCodes.Ret);
IntPtr funcPtr = Marshal.GetFunctionPointerForDelegate(new Int32SumStdCall(Int32Sum));
object resultValue = dynamicMethod
.Invoke(null, new object[] { funcPtr, a, b });
Assert.IsType(returnType, resultValue);
Assert.Equal(result, resultValue);
}
public void Execute()
{
ConsoleTester.ClearAndStartCapturing();
DynamicMethodGen dmg = DynamicMethodGen.Static(typeof(DynamicMethodTest)).Method(typeof(string), new TypeMapper())
.Parameter(typeof(string), "name")
.Parameter(typeof(string), "other");
CodeGen g = dmg.GetCode();
{
g.Try();
{
var name = g.Local(typeof(string), g.Arg("name"));
g.WriteLine("Hello " + name + "!");
}
g.CatchAll();
{
g.WriteLine("Error");
}
g.End();
g.Return(dmg.StaticFactory.Invoke(typeof(DynamicMethodTest), nameof(CallMe), g.Arg("other"), 2));
}
DynamicMethod dm = dmg.GetCompletedDynamicMethod(true);
// reflection-style invocation
Assert.That(dm.Invoke(null, new object[] { "Dynamic Method", "first1" }), Is.EqualTo("test240"));
// delegate invocation
Func <string, string, string> hello = (Func <string, string, string>)dm.CreateDelegate(typeof(Func <string, string, string>));
Assert.That(hello("Delegate", "first1"), Is.EqualTo("test240"));
ConsoleTester.AssertAndClear(@"Hello Dynamic Method!
Hello Delegate!
");
}
public static int Main()
{
DynamicMethod method_builder = new DynamicMethod("ThrowException", typeof(void), new Type[0], typeof(Driver));
ILGenerator ilg = method_builder.GetILGenerator();
ilg.Emit(OpCodes.Newobj, typeof(MyException).GetConstructor(new Type[0]));
ilg.Emit(OpCodes.Throw);
try
{
method_builder.Invoke(null, null);
return(2);
}
catch (TargetInvocationException tie)
{
if (!(tie.InnerException is MyException))
{
return(3);
}
}
return(0);
}
public static T2 MyMapTo <T2>(this object t)
{
if (t == null)
{
return(default(T2));
}
var type = t.GetType();
var key = type.GetHashCode() ^ typeof(T2).GetHashCode();
if (methodInfo == null)
{
DynamicMethod dynamicMethod = new DynamicMethod($"__{key}", typeof(T2), new[] { type });
var generator = dynamicMethod.GetILGenerator();
generator.Emit(OpCodes.Ldarg_0);
var method = AllMethods["map-single"].MakeGenericMethod(type, typeof(T2));
generator.Emit(OpCodes.Call, method);
generator.Emit(OpCodes.Ret);
methodInfo = dynamicMethod;
}
return((T2)methodInfo.Invoke(null, new object[] { t }));
}
public static void Invoker()
{
var info = Assembly.GetExecutingAssembly().GetType("Chapter19.Fanshe").GetMethod("Invoker");
//typeof(int).GetTypeInfo().DeclaredMethods
//var types = typeof(Console).Attributes;
//var ms = MethodInfo.GetCurrentMethod().Attributes;
//Console.WriteLine(types + "\r\n" + ms);
//ResolveEventHandler handler = (object sender, ResolveEventArgs args) => Assembly.ReflectionOnlyLoad(args.Name);
//AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += handler;
//AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve -= handler;
//Attribute.GetCustomAttributes()
{
//var dyMothod = new DynamicMethod("Foo", null, null, typeof(Fanshe));
//ILGenerator gen = dyMothod.GetILGenerator();
//gen.EmitWriteLine("Hello world");
//gen.Emit(OpCodes.Ret);
//dyMothod.Invoke(null, null);
//int x = 2;
//int y = 3;
//x *= y;
//Console.WriteLine(x);
var dymethod = new DynamicMethod("TEST", null, null, typeof(void));
ILGenerator gen = dymethod.GetILGenerator();
LocalBuilder localX = gen.DeclareLocal(typeof(int));
LocalBuilder localY = gen.DeclareLocal(typeof(int));
gen.Emit(OpCodes.Ldc_I4, 2);
gen.Emit(OpCodes.Stloc, localX);
gen.Emit(OpCodes.Ldc_I4, 3);
gen.Emit(OpCodes.Stloc, localY);
gen.Emit(OpCodes.Ldloc, localX);
gen.Emit(OpCodes.Localloc, localY);
gen.Emit(OpCodes.Mul);
gen.Emit(OpCodes.Stloc, localX);
gen.EmitWriteLine(localX);
gen.Emit(OpCodes.Ret);
//dymethod.Invoke(null, null);
}
{
//int x = 5;
//while (x<=10)
//{
// Console.WriteLine(x++);
//}
//动态生成代码
var dymethod = new DynamicMethod("Foo", null, null, typeof(void));
var gen = dymethod.GetILGenerator();
//设置分支目标
Label startLoop = gen.DefineLabel();
Label endLoop = gen.DefineLabel();
//声明本地变量x
LocalBuilder x = gen.DeclareLocal(typeof(int));
//将参数推入评估栈
gen.Emit(OpCodes.Ldc_I4, 5);
//相当于 int x=5
gen.Emit(OpCodes.Stloc, x);
//标记标签位置 {
gen.MarkLabel(startLoop);
gen.Emit(OpCodes.Ldc_I4, 10);
gen.Emit(OpCodes.Ldloc, x);
// 如果第一个值小于第二个值就分支 if(x>10)
//如果 x>10 结束标签，循环结束
gen.Emit(OpCodes.Blt, endLoop);
//Console.WriteLine(x);
gen.EmitWriteLine(x);
//++x;
gen.Emit(OpCodes.Ldloc, x);
gen.Emit(OpCodes.Ldc_I4, 1);
gen.Emit(OpCodes.Add);
gen.Emit(OpCodes.Stloc, x);
gen.Emit(OpCodes.Br, startLoop);
gen.MarkLabel(endLoop);
gen.Emit(OpCodes.Ret);
dymethod.Invoke(null, null);
}
}
public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture) => m_owner.Invoke(obj, invokeAttr, binder, parameters, culture);
public override int GetHashCode()
{
return(num + (int)GRANDPARENT_GET_HASH_CODE.Invoke(null, new object[] { this }));
}
public static void Main()
{
// Create an array that specifies the types of the parameters
// of the dynamic method. This dynamic method has a String
// parameter and an Integer parameter.
Type[] helloArgs = {typeof(string), typeof(int), typeof(int)};
// Create a dynamic method with the name "Hello", a return type
// of Integer, and two parameters whose types are specified by
// the array helloArgs. Create the method in the module that
// defines the String class.
DynamicMethod hello = new DynamicMethod("Hello",
typeof(int),
helloArgs,
typeof(string).Module);
// Create an array that specifies the parameter types of the
// overload of Console.WriteLine to be used in Hello.
Type[] writeStringArgs = {typeof(string)};
// Get the overload of Console.WriteLine that has one
// String parameter.
MethodInfo writeString = typeof(Console).GetMethod("WriteLine",
writeStringArgs);
// Get an ILGenerator and emit a body for the dynamic method,
// using a stream size larger than the IL that will be
// emitted.
ILGenerator il = hello.GetILGenerator(256);
// Load the first argument, which is a string, onto the stack.
il.Emit(OpCodes.Ldarg_0);
// Call the overload of Console.WriteLine that prints a string.
il.EmitCall(OpCodes.Call, writeString, null);
// The Hello method returns the value of the second argument;
// to do this, load the onto the stack and return.
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldc_I4_X, 1337);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Ret);
// Add parameter information to the dynamic method. (This is not
// necessary, but can be useful for debugging.) For each parameter,
// identified by position, supply the parameter attributes and a
// parameter name.
hello.DefineParameter(1, ParameterAttributes.In, "message");
hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn");
// Create a delegate that represents the dynamic method. This
// action completes the method. Any further attempts to
// change the method are ignored.
HelloDelegate hi =
(HelloDelegate) hello.CreateDelegate(typeof(HelloDelegate));
// Use the delegate to execute the dynamic method.
Console.WriteLine("\r\nUse the delegate to execute the dynamic method:");
int retval = hi("\r\nHello, World!", 42, 30);
Console.WriteLine("Invoking delegate hi(\"Hello, World!\", 42, 30) returned: " + retval);
// Execute it again, with different arguments.
retval = hi("\r\nHi, Mom!", 5280, 37);
Console.WriteLine("Invoking delegate hi(\"Hi, Mom!\", 5280, 37) returned: " + retval);
Console.WriteLine("\r\nUse the Invoke method to execute the dynamic method:");
// Create an array of arguments to use with the Invoke method.
object[] invokeArgs = {"\r\nHello, World!", 42, 30};
// Invoke the dynamic method using the arguments. This is much
// slower than using the delegate, because you must create an
// array to contain the arguments, and value-type arguments
// must be boxed.
object objRet = hello.Invoke(null, BindingFlags.ExactBinding, null, invokeArgs, new CultureInfo("en-us"));
Console.WriteLine("hello.Invoke returned: " + objRet);
Console.WriteLine("\r\n ----- Display information about the dynamic method -----");
// Display MethodAttributes for the dynamic method, set when
// the dynamic method was created.
Console.WriteLine("\r\nMethod Attributes: {0}", hello.Attributes);
// Display the calling convention of the dynamic method, set when the
// dynamic method was created.
Console.WriteLine("\r\nCalling convention: {0}", hello.CallingConvention);
// Display the declaring type, which is always null for dynamic
// methods.
if (hello.DeclaringType == null)
{
Console.WriteLine("\r\nDeclaringType is always null for dynamic methods.");
}
else
{
Console.WriteLine("DeclaringType: {0}", hello.DeclaringType);
}
// Display the default value for InitLocals.
if (hello.InitLocals)
{
Console.Write("\r\nThis method contains verifiable code.");
}
else
{
Console.Write("\r\nThis method contains unverifiable code.");
}
Console.WriteLine(" (InitLocals = {0})", hello.InitLocals);
// Display the module specified when the dynamic method was created.
Console.WriteLine("\r\nModule: {0}", hello.Module);
// Display the name specified when the dynamic method was created.
// Note that the name can be blank.
Console.WriteLine("\r\nName: {0}", hello.Name);
// For dynamic methods, the reflected type is always null.
if (hello.ReflectedType == null)
{
Console.WriteLine("\r\nReflectedType is null.");
}
else
{
Console.WriteLine("\r\nReflectedType: {0}", hello.ReflectedType);
}
//beyond scope of project
// if (hello.ReturnParameter == null)
// {
// Console.WriteLine("\r\nMethod has no return parameter.");
// }
// else
// {
// Console.WriteLine("\r\nReturn parameter: {0}", hello.ReturnParameter);
// }
// If the method has no return type, ReturnType is System.Void.
Console.WriteLine("\r\nReturn type: {0}", hello.ReturnType);
// ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
// that can be used to enumerate the custom attributes of the
// return value. At present, there is no way to set such custom
// attributes, so the list is empty.
//beyond scope of project
// if (hello.ReturnType == typeof(void))
// {
// Console.WriteLine("The method has no return type.");
// }
// else
// {
// ICustomAttributeProvider caProvider = hello.ReturnTypeCustomAttributes;
// object[] returnAttributes = caProvider.GetCustomAttributes(true);
// if (returnAttributes.Length == 0)
// {
// Console.WriteLine("\r\nThe return type has no custom attributes.");
// }
// else
// {
// Console.WriteLine("\r\nThe return type has the following custom attributes:");
// foreach( object attr in returnAttributes )
// {
// Console.WriteLine("\t{0}", attr.ToString());
// }
// }
// }
Console.WriteLine("\r\nToString: {0}", hello.ToString());
Console.WriteLine("\r\nToString: {0}", hello.ToString());
// Display parameter information.
ParameterInfo[] parameters = hello.GetParameters();
Console.WriteLine("\r\nParameters: name, type, ParameterAttributes");
foreach( ParameterInfo p in parameters )
{
Console.WriteLine("\t{0}, {1}, {2}",
p.Name, p.ParameterType, p.Attributes);
}
Console.WriteLine("array assignment");
Type[] paramTypes = { typeof(uint), typeof(string), typeof(string), typeof(uint) };
Console.WriteLine(paramTypes[1]);
}
public static void Main()
{
// Create an array that specifies the types of the parameters
// of the dynamic method. This method has a string parameter
// and an int parameter.
Type[] helloArgs = { typeof(string), typeof(int) };
// Create a dynamic method with the name "Hello", a return type
// of int, and two parameters whose types are specified by the
// array helloArgs. Create the method in the module that
// defines the Test class.
DynamicMethod hello = new DynamicMethod("Hello",
typeof(int),
helloArgs,
typeof(Test).Module);
// <Snippet2>
// Create an array that specifies the parameter types of the
// overload of Console.WriteLine to be used in Hello.
Type[] writeStringArgs = { typeof(string) };
// Get the overload of Console.WriteLine that has one
// String parameter.
MethodInfo writeString =
typeof(Console).GetMethod("WriteLine", writeStringArgs);
// Get an ILGenerator and emit a body for the dynamic method.
ILGenerator il = hello.GetILGenerator();
// Load the first argument, which is a string, onto the stack.
il.Emit(OpCodes.Ldarg_0);
// Call the overload of Console.WriteLine that prints a string.
il.EmitCall(OpCodes.Call, writeString, null);
// The Hello method returns the value of the second argument;
// to do this, load the onto the stack and return.
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ret);
// </Snippet2>
// <Snippet3>
// Create a delegate that represents the dynamic method. This
// action completes the method, and any further attempts to
// change the method will cause an exception.
HelloInvoker hi =
(HelloInvoker)hello.CreateDelegate(typeof(HelloInvoker));
// </Snippet3>
// Use the delegate to execute the dynamic method. Save and
// print the return value.
int retval = hi("\r\nHello, World!", 42);
Console.WriteLine("Executing delegate hi(\"Hello, World!\", 42) returned {0}",
retval);
// Do it again, with different arguments.
retval = hi("\r\nHi, Mom!", 5280);
Console.WriteLine("Executing delegate hi(\"Hi, Mom!\", 5280) returned {0}",
retval);
// <Snippet4>
// Create an array of arguments to use with the Invoke method.
object[] invokeArgs = { "\r\nHello, World!", 42 };
// Invoke the dynamic method using the arguments. This is much
// slower than using the delegate, because you must create an
// array to contain the arguments, and ValueType arguments
// must be boxed.
object objRet = hello.Invoke(null, invokeArgs);
Console.WriteLine("hello.Invoke returned {0}", objRet);
// </Snippet4>
}
