public void InvalidFilterBlock1()
{
DefineBasicMethod();
ILGenerator il = il_gen;
il.BeginExceptionBlock();
il.BeginExceptFilterBlock();
il.EndExceptionBlock();
}
/// <summary>
/// Aspect code to inject at the beginning of weaved method
/// </summary>
/// <param name="typeBuilder">Type Builder</param>
/// <param name="method">Method</param>
/// <param name="parameter">Parameter</param>
/// <param name="il">ILGenerator</param>
internal void BeginAspectBlock(TypeBuilder typeBuilder, MethodBase method, ParameterInfo parameter, ILGenerator il)
{
var meth = method as MethodInfo;
var returnType = meth.ReturnType;
exLocal = returnType != typeof(void) ? il.DeclareLocal(returnType) : null;
il.BeginExceptionBlock();
}
public void BeginExceptionBlock()
{
TypeBuilder type = Helpers.DynamicType(TypeAttributes.NotPublic);
MethodBuilder method = type.DefineMethod("TestMethod", MethodAttributes.Public | MethodAttributes.Static);
ILGenerator generator = method.GetILGenerator();
generator.BeginExceptionBlock();
VerifyDeclareLocal(generator);
}
public void TestExceptionEmitCalls()
{
AssemblyName myAsmName = new AssemblyName("AdderExceptionAsm");
AssemblyBuilder myAsmBldr = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
ModuleBuilder myModBldr = TestLibrary.Utilities.GetModuleBuilder(myAsmBldr, "Module1");
TypeBuilder myTypeBldr = myModBldr.DefineType("Adder");
MethodBuilder methodBuilder = myTypeBldr.DefineMethod("DoThrow",
MethodAttributes.Public |
MethodAttributes.Static,
typeof(int), new Type[] { typeof(bool) });
ILGenerator ilgen = methodBuilder.GetILGenerator();
Type overflow = typeof(OverflowException);
LocalBuilder tmp1 = ilgen.DeclareLocal(typeof(int));
Label dontThrow = ilgen.DefineLabel();
// Begin the try block.
Label exBlock = ilgen.BeginExceptionBlock();
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Brfalse_S, dontThrow);
// Throw the exception now on the stack.
ilgen.ThrowException(overflow);
ilgen.MarkLabel(dontThrow);
// Start the catch block for OverflowException.
ilgen.BeginCatchBlock(overflow);
// Since our function has to return an integer value, we'll load -1 onto
// the stack to indicate an error, and store it in local variable tmp1.
//
ilgen.Emit(OpCodes.Ldc_I4_M1);
ilgen.Emit(OpCodes.Stloc_S, tmp1);
// End the exception handling block.
ilgen.EndExceptionBlock();
// Return
ilgen.Emit(OpCodes.Ldloc_S, tmp1);
ilgen.Emit(OpCodes.Ret);
Type createdType = myTypeBldr.CreateTypeInfo().AsType();
MethodInfo md = createdType.GetMethod("DoThrow");
// Throw
int ret = (int)md.Invoke(null, new object[] { true });
Assert.Equal(-1, ret);
// Don't Throw
ret = (int)md.Invoke(null, new object[] { false });
Assert.Equal(0, ret);
}
public static void EmitTryFinally(this ILGenerator il, Action tryBody, Action finallyBody)
{
var block = il.BeginExceptionBlock();
tryBody();
il.Emit(OpCodes.Leave_S, block);
il.BeginFinallyBlock();
finallyBody();
il.EndExceptionBlock();
}
[Test] // bug #81431
public void FilterAndCatchBlock()
{
DefineBasicMethod();
ILGenerator il = il_gen;
il.BeginExceptionBlock();
il.BeginExceptFilterBlock();
il.BeginCatchBlock(null);
il.BeginCatchBlock(typeof(SystemException));
}
public override CodeNode VisitTryFinallyNode(TryFinallyNode node)
{
ILGen.BeginExceptionBlock();
Visit(node.TryNode);
ILGen.BeginFinallyBlock();
Visit(node.FinallyNode);
ILGen.EndExceptionBlock();
return(node);
}
internal static void EmitExceptionBlock(ILGenerator il, CodeInstruction ci)
{
if (ci.startException > 0)
{
for (int i = 0; i < ci.startException; i++)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("try {\n");
}
il.BeginExceptionBlock();
}
}
if (ci.endException > 0)
{
for (int i = 0; i < ci.endException; i++)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("}\n");
}
il.EndExceptionBlock();
}
}
if (ci.isStartCatch)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("} // try");
String catchLog = "catch ";
if (ci.catchType != null)
{
catchLog += "(" + ci.catchType.ToString() + ")";
}
FileLog.Log(catchLog + " {");
}
il.BeginCatchBlock(ci.catchType);
}
else if (ci.isStartFinally)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("} // try");
FileLog.Log("finally { ");
}
il.BeginFinallyBlock();
}
}
private void InitSerializePropertiesDelegate(Type type)
{
Dictionary <string, MemberInfo> properties = HproseHelper.GetProperties(type);
DynamicMethod dynamicMethod = new DynamicMethod("$SerializeProperties",
typeofVoid,
typeofArgs,
type,
true);
ILGenerator gen = dynamicMethod.GetILGenerator();
LocalBuilder value = gen.DeclareLocal(typeofObject);
LocalBuilder e = gen.DeclareLocal(typeofException);
foreach (KeyValuePair <string, MemberInfo> property in properties)
{
PropertyInfo propertyInfo = (PropertyInfo)property.Value;
Label exTryCatch = gen.BeginExceptionBlock();
if (type.IsValueType)
{
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Unbox, type);
}
else
{
gen.Emit(OpCodes.Ldarg_0);
}
MethodInfo getMethod = propertyInfo.GetGetMethod();
if (getMethod.IsVirtual)
{
gen.Emit(OpCodes.Callvirt, getMethod);
}
else
{
gen.Emit(OpCodes.Call, getMethod);
}
if (propertyInfo.PropertyType.IsValueType)
{
gen.Emit(OpCodes.Box, propertyInfo.PropertyType);
}
gen.Emit(OpCodes.Stloc_S, value);
gen.Emit(OpCodes.Leave_S, exTryCatch);
gen.BeginCatchBlock(typeofException);
gen.Emit(OpCodes.Stloc_S, e);
gen.Emit(OpCodes.Ldstr, "The property value can\'t be serialized.");
gen.Emit(OpCodes.Ldloc_S, e);
gen.Emit(OpCodes.Newobj, hproseExceptionCtor);
gen.Emit(OpCodes.Throw);
gen.Emit(OpCodes.Leave_S, exTryCatch);
gen.EndExceptionBlock();
gen.Emit(OpCodes.Ldarg_1);
gen.Emit(OpCodes.Ldloc_S, value);
gen.Emit(OpCodes.Call, serializeMethod);
}
gen.Emit(OpCodes.Ret);
serializePropertiesDelegate = (SerializeDelegate)dynamicMethod.CreateDelegate(typeofSerializeDelegate);
}
/// <summary>
/// Generate the contents of the method. This will generate:
/// ...
/// try
/// {
/// return Proxy.MethodName(arg1, arg2);
/// }
/// catch
/// {
/// CloseProxyBecauseOfException();
/// throw;
/// }
/// ...
/// </summary>
/// <param name="method"></param>
/// <param name="parameterTypes"></param>
/// <param name="iLGenerator"></param>
protected override void GenerateMethodImpl(MethodInfo method, Type[] parameterTypes, ILGenerator iLGenerator)
{
bool hasReturn = !IsVoidMethod(method);
if (hasReturn)
{
// declare a variable to contain the return type
// string returnValue;
iLGenerator.DeclareLocal(method.ReturnType);
}
// try {
Label tryLabel = iLGenerator.BeginExceptionBlock();
{
// this
iLGenerator.Emit(OpCodes.Ldarg_0);
// Get the details Property of the ClientBase
MethodInfo proxyProperty = GetMethodFromBaseClass("get_Proxy");
// Get the channel: "base.Channel<TInterface>."
iLGenerator.EmitCall(OpCodes.Call, proxyProperty, null);
// Prepare the parameters for the call
ParameterInfo[] parameters = method.GetParameters();
for (int index = 0; index < parameterTypes.Length; index++)
{
iLGenerator.Emit(OpCodes.Ldarg, (((short)index) + 1));
}
// Call the Proxy via the interface
iLGenerator.Emit(OpCodes.Callvirt, method);
if (hasReturn)
{
// returnValue = result of the function call
iLGenerator.Emit(OpCodes.Stloc_0);
}
}
// catch {
{
GenerateStandardCatch(iLGenerator);
}
// }
iLGenerator.EndExceptionBlock();
if (hasReturn)
{
// return returnValue;
iLGenerator.Emit(OpCodes.Ldloc_0);
}
// Thanks, all done
iLGenerator.Emit(OpCodes.Ret);
}
private void EmitMethod(TypeBuilder typeBuilder)
{
MethodBuilder mapMethod = typeBuilder.DefineMethod("Map", MethodAttributes.Public | MethodAttributes.Virtual, typeof(void), new[] { typeof(IEnumerable) });
ILGenerator il = mapMethod.GetILGenerator();
LocalBuilder result = il.DeclareLocal(typeof(List <int>)); //0
LocalBuilder item = il.DeclareLocal(typeof(object)); //1
LocalBuilder enumeartor = il.DeclareLocal(typeof(IEnumerator)); //2
LocalBuilder dispose = il.DeclareLocal(typeof(IDisposable)); //3
Label labelWhile = il.DefineLabel();
Label labelReturn = il.DefineLabel();
Label labelMoveNext = il.DefineLabel();
Label labelEndFinally = il.DefineLabel();
//Create result List
ConstructorInfo constructorInfo = (typeof(List <int>).GetConstructor(Type.EmptyTypes));
il.Emit(OpCodes.Newobj, constructorInfo);
il.Emit(OpCodes.Stloc_0, result);
il.Emit(OpCodes.Ldarg_1);
il.EmitCall(OpCodes.Callvirt, typeof(IEnumerable).GetMethod("GetEnumerator"), Type.EmptyTypes);
il.Emit(OpCodes.Stloc_2, enumeartor);
il.BeginExceptionBlock();
il.Emit(OpCodes.Br_S, labelMoveNext);
il.MarkLabel(labelWhile);
il.Emit(OpCodes.Ldloc_2);
il.EmitCall(OpCodes.Callvirt, typeof(IEnumerator).GetProperty("Current").GetGetMethod(), Type.EmptyTypes);
il.Emit(OpCodes.Stloc_1, item);
il.MarkLabel(labelMoveNext);
il.Emit(OpCodes.Ldloc_2);
il.EmitCall(OpCodes.Callvirt, typeof(IEnumerator).GetMethod("MoveNext"), Type.EmptyTypes);
il.Emit(OpCodes.Brtrue_S, labelWhile);
il.BeginFinallyBlock();
il.Emit(OpCodes.Ldloc_2);
il.Emit(OpCodes.Isinst, typeof(IDisposable));
il.Emit(OpCodes.Stloc_3, dispose);
il.Emit(OpCodes.Ldloc_3);
il.Emit(OpCodes.Brfalse_S, labelEndFinally);
il.Emit(OpCodes.Ldloc_3);
il.EmitCall(OpCodes.Callvirt, typeof(IDisposable).GetMethod("Dispose"), Type.EmptyTypes);
il.MarkLabel(labelEndFinally);
il.EndExceptionBlock();
il.MarkLabel(labelReturn);
il.Emit(OpCodes.Ret);
}
private static void BuildAssembly(string sourceCode, string assemblyFilePath)
{
AssemblyName assemblyName = new AssemblyName("Temp");
AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Save, Path.GetDirectoryName(assemblyFilePath));
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name, Path.GetFileName(assemblyFilePath));
TypeBuilder typeBuilder = moduleBuilder.DefineType("Application", TypeAttributes.NotPublic | TypeAttributes.Sealed);
MethodBuilder methodBuilder = typeBuilder.DefineMethod("Main", MethodAttributes.Private | MethodAttributes.Static, typeof(void), Type.EmptyTypes);
ILGenerator generator = methodBuilder.GetILGenerator();
generator.BeginExceptionBlock();
using (StringReader reader = new StringReader(sourceCode))
{
MagnetoCompiler.Compile(MagnetoApplication.Current.ModuleManager, reader, generator);
}
generator.BeginCatchBlock(typeof(Exception));
generator.Emit(OpCodes.Callvirt, exceptionMessageGetter);
generator.Emit(OpCodes.Ldc_I4, (int)ConsoleColor.Red);
generator.Emit(OpCodes.Call, foregroundColorSetter);
generator.Emit(OpCodes.Ldstr, "");
generator.Emit(OpCodes.Call, consoleWriteLineMethod);
generator.Emit(OpCodes.Call, consoleWriteLineMethod);
generator.BeginFinallyBlock();
generator.Emit(OpCodes.Ldc_I4, (int)ConsoleColor.Cyan);
generator.Emit(OpCodes.Call, foregroundColorSetter);
generator.Emit(OpCodes.Ldstr, "");
generator.Emit(OpCodes.Call, consoleWriteLineMethod);
generator.Emit(OpCodes.Ldstr, "Finished: press <Enter> to exit.");
generator.Emit(OpCodes.Call, consoleWriteLineMethod);
generator.Emit(OpCodes.Call, consoleReadLineMethod);
generator.EndExceptionBlock();
generator.Emit(OpCodes.Ret);
// Generated code:
// try
// {
// // compiled application code
// }
// catch(Exception lException)
// {
// Console.ForegroundColor = ConsoleColor.Red;
// Console.WriteLine("");
// Console.WriteLine(lException.Message);
// }
// finally
// {
// Console.ForegroundColor = ConsoleColor.Cyan;
// Console.WriteLine("");
// Console.WriteLine("Finished: press <Enter> to exit.");
// Console.ReadLine();
// }
typeBuilder.CreateType();
assemblyBuilder.SetEntryPoint(methodBuilder, PEFileKinds.ConsoleApplication);
assemblyBuilder.Save(Path.GetFileName(assemblyFilePath));
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
//This assumes that rtype == Void.class
this.context.EmitLineInfo(il);
Globals.ScopeStack.Push(new WithObject(Globals.ScopeStack.Peek(), new JSObject(null, false)));
bool savedInsideProtectedRegion = compilerGlobals.InsideProtectedRegion;
compilerGlobals.InsideProtectedRegion = true;
Label lab = il.DefineLabel();
compilerGlobals.BreakLabelStack.Push(lab);
compilerGlobals.ContinueLabelStack.Push(lab);
this.obj.TranslateToIL(il, Typeob.Object);
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.jScriptWithMethod); // JScriptWith returns the with object as an 'Object' (used by the debugger EE)
// define a local named 'with()' that the debugger EE will use to bind to the with object
LocalBuilder withObj = null;
if (context.document.debugOn)
{
il.BeginScope(); // used by the debugger to mark a with block
withObj = il.DeclareLocal(Typeob.Object);
withObj.SetLocalSymInfo("with()");
il.Emit(OpCodes.Stloc, withObj);
}
else
{
il.Emit(OpCodes.Pop);
}
il.BeginExceptionBlock();
this.block.TranslateToILInitializer(il);
this.block.TranslateToIL(il, Typeob.Void);
il.BeginFinallyBlock();
if (context.document.debugOn)
{
// null the local used by the debugger EE
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Stloc, withObj);
}
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.popScriptObjectMethod);
il.Emit(OpCodes.Pop);
il.EndExceptionBlock();
if (context.document.debugOn)
{
il.EndScope(); // used by the debugger to mark a with block
}
il.MarkLabel(lab);
compilerGlobals.BreakLabelStack.Pop();
compilerGlobals.ContinueLabelStack.Pop();
compilerGlobals.InsideProtectedRegion = savedInsideProtectedRegion;
Globals.ScopeStack.Pop();
}
private void EmitMethod(FieldBuilder innerFieldBuilder, MethodInfo method, TypeBuilder typeBuilder)
{
Contract.Requires(method != null);
Contract.Requires(typeBuilder != null);
MethodBuilder methodBuilder = typeBuilder.DefineMethod(method.Name, MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual, method.ReturnType, method.GetParameters().Select(pi => pi.ParameterType).ToArray());
ILGenerator il = methodBuilder.GetILGenerator();
LocalBuilder returnResult = null;
if (method.ReturnType != typeof(void))
{
returnResult = il.DeclareLocal(method.ReturnType);
}
LocalBuilder exception = il.DeclareLocal(typeof(Exception));
Label endOfMethod = il.DefineLabel();
// try block
il.BeginExceptionBlock();
// Call OnExecuting method
this.EmitOnExecutingMethodCall(il);
// Call method
EmitInnerMethodCall(method, innerFieldBuilder, il);
// Call OnExecuted method
this.EmitOnExecutedMethodCall(il);
il.Emit(OpCodes.Leave_S, endOfMethod);
il.BeginCatchBlock(typeof(Exception));
// Call OnException method
il.Emit(OpCodes.Stloc_S, exception);
this.EmitOnExceptionMethodCall(exception, il);
// re-throw;
il.Emit(OpCodes.Rethrow);
il.EndExceptionBlock();
il.MarkLabel(endOfMethod);
if (returnResult != null)
{
// return returnValue;
il.Emit(OpCodes.Ldloc_S, returnResult);
}
// done
il.Emit(OpCodes.Ret);
typeBuilder.DefineMethodOverride(methodBuilder, method);
}
public void DefineFilterBodyWithTypeNotNull()
{
DefineBasicMethod();
il_gen.BeginExceptionBlock();
il_gen.EmitWriteLine("in try");
il_gen.BeginExceptFilterBlock();
il_gen.EmitWriteLine("in filter head");
il_gen.BeginCatchBlock(typeof(Exception));
il_gen.EmitWriteLine("in filter body");
il_gen.EndExceptionBlock();
}
private static void ExcptionDeal()
{
#region Init
string name = "DynamicExceptionHandler";
string fileName = name + ".dll";
AssemblyName asmName = new AssemblyName(name);
AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(name, fileName);
#endregion
TypeBuilder typeBuilder = moduleBuilder.DefineType("ExceptionHandler", TypeAttributes.Public);
MethodBuilder methodBuilder = typeBuilder.DefineMethod("ConvertToInt32", MethodAttributes.Public | MethodAttributes.Static, typeof(Int32), new Type[] { typeof(string) });
ILGenerator methodIL = methodBuilder.GetILGenerator();
LocalBuilder num = methodIL.DeclareLocal(typeof(Int32));
//int num = 0;
methodIL.Emit(OpCodes.Ldc_I4_0);
methodIL.Emit(OpCodes.Stloc_0);
//begin try
Label tryLabel = methodIL.BeginExceptionBlock();
//num = Convert.ToInt32(str);
methodIL.Emit(OpCodes.Ldarg_0);
methodIL.Emit(OpCodes.Call, typeof(Convert).GetMethod("ToInt32", new Type[] { typeof(string) }));
methodIL.Emit(OpCodes.Stloc_0);
//end try
//begin catch 注意，这个时侯堆栈顶为异常信息ex
methodIL.BeginCatchBlock(typeof(Exception));
//Console.WriteLine(ex.Message);
methodIL.Emit(OpCodes.Call, typeof(Exception).GetMethod("get_Message"));
methodIL.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }));
//end catch
methodIL.EndExceptionBlock();
//return num;
methodIL.Emit(OpCodes.Ldloc_0);
methodIL.Emit(OpCodes.Ret);
Type type = typeBuilder.CreateType();
assemblyBuilder.Save(fileName);
object ob = type.GetMethod("ConvertToInt32").Invoke(null, new object[] { "12" });
Console.WriteLine(ob);
ob = type.GetMethod("ConvertToInt32").Invoke(null, new object[] { "s12" });
Console.WriteLine(ob);
}
protected override void InitUnserializeDelegate(Type type, string[] names, DynamicMethod dynamicMethod)
{
Dictionary <string, PropertyTypeInfo> properties = HproseHelper.GetProperties(type);
ILGenerator gen = dynamicMethod.GetILGenerator();
LocalBuilder e = gen.DeclareLocal(typeofException);
int count = names.Length;
for (int i = 0; i < count; ++i)
{
PropertyTypeInfo property;
if (properties.TryGetValue(names[i], out property))
{
Label exTryCatch = gen.BeginExceptionBlock();
if (type.IsValueType)
{
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Unbox, type);
}
else
{
gen.Emit(OpCodes.Ldarg_0);
}
gen.Emit(OpCodes.Ldarg_1);
gen.Emit(OpCodes.Ldc_I4, i);
gen.Emit(OpCodes.Ldelem_Ref);
if (property.type.IsValueType)
{
gen.Emit(OpCodes.Unbox_Any, property.type);
}
MethodInfo setMethod = property.info.GetSetMethod(true);
if (setMethod.IsVirtual)
{
gen.Emit(OpCodes.Callvirt, setMethod);
}
else
{
gen.Emit(OpCodes.Call, setMethod);
}
gen.Emit(OpCodes.Leave_S, exTryCatch);
gen.BeginCatchBlock(typeofException);
gen.Emit(OpCodes.Stloc_S, e);
gen.Emit(OpCodes.Ldstr, "The property value can\'t be unserialized.");
gen.Emit(OpCodes.Ldloc_S, e);
gen.Emit(OpCodes.Newobj, hproseExceptionCtor);
gen.Emit(OpCodes.Throw);
gen.Emit(OpCodes.Leave_S, exTryCatch);
gen.EndExceptionBlock();
}
}
gen.Emit(OpCodes.Ret);
}
private void DefineVerifyEntityStateIL(ILGenerator generator, LocalBuilder entityCopy, PropertyInfo propertyInfo, FieldBuilder fieldBuilder)
{
var contextType = typeof(DbContext);
var entityEntryType = typeof(DbEntityEntry);
var entityStateType = typeof(EntityState);
var label = generator.DefineLabel();
var methodInfo = contextType.GetMethod("Entry", BindingFlags.Instance | BindingFlags.Public, null, new[] { typeof(object) }, null);
var localState = generator.DeclareLocal(entityStateType);
var localValue = generator.DeclareLocal(propertyInfo.PropertyType);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldfld, fieldBuilder);
generator.Emit(OpCodes.Call, propertyInfo.GetGetMethod());
generator.Emit(OpCodes.Stloc, localValue);
generator.Emit(OpCodes.Ldnull);
generator.Emit(OpCodes.Ldloc, localValue);
generator.Emit(OpCodes.Ceq);
generator.Emit(OpCodes.Brtrue, label);
generator.BeginExceptionBlock();
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Ldloc, localValue);
generator.Emit(OpCodes.Call, methodInfo);
var stateProperty = entityEntryType.GetProperty("State");
generator.Emit(OpCodes.Call, stateProperty.GetGetMethod());
generator.Emit(OpCodes.Stloc, localState);
generator.Emit(OpCodes.Ldloc, localState);
generator.Emit(OpCodes.Ldc_I4, (int)EntityState.Detached);
generator.Emit(OpCodes.Ceq);
generator.Emit(OpCodes.Brfalse, label);
var ctor = typeof(EntityStateValidationException).GetConstructor(new[] { typeof(string) });
generator.Emit(OpCodes.Ldstr, String.Format(
"The specified entity of type {0} is in a detached state and cannot be used for this operation",
propertyInfo.PropertyType.FullName));
generator.Emit(OpCodes.Newobj, ctor);
generator.Emit(OpCodes.Throw);
generator.BeginCatchBlock(typeof(InvalidOperationException));
generator.EndExceptionBlock();
generator.MarkLabel(label);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(this._syncLockSource, gen);
gen.Emit(OpCodes.Call, typeof(Monitor).GetMethod("Enter", new Type[] { typeof(object) }));
gen.BeginExceptionBlock();
foreach (Statement statement in this._stmts)
{
statement.Emit(member, gen);
}
gen.BeginFinallyBlock();
ArgumentsUtil.EmitLoadOwnerAndReference(this._syncLockSource, gen);
gen.Emit(OpCodes.Call, typeof(Monitor).GetMethod("Exit"));
gen.EndExceptionBlock();
}
private void EmitStreamWriter(ILGenerator ilGenerator)
{
var streamWriterConstructor = typeof(StreamWriter).GetTypeInfo().DeclaredConstructors.First(c =>
{
var parameters = c.GetParameters();
return(parameters.Length == 1 && parameters[0].ParameterType == typeof(Stream));
});
ilGenerator.Emit(OpCodes.Ldloc_1);
ilGenerator.Emit(OpCodes.Newobj, streamWriterConstructor);
ilGenerator.Emit(OpCodes.Stloc_2);
ilGenerator.BeginExceptionBlock();
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
base.context.EmitLineInfo(il);
base.Globals.ScopeStack.Push(new WithObject(base.Globals.ScopeStack.Peek(), new JSObject(null, false)));
bool insideProtectedRegion = base.compilerGlobals.InsideProtectedRegion;
base.compilerGlobals.InsideProtectedRegion = true;
Label item = il.DefineLabel();
base.compilerGlobals.BreakLabelStack.Push(item);
base.compilerGlobals.ContinueLabelStack.Push(item);
this.obj.TranslateToIL(il, Typeob.Object);
base.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.jScriptWithMethod);
LocalBuilder local = null;
if (base.context.document.debugOn)
{
il.BeginScope();
local = il.DeclareLocal(Typeob.Object);
local.SetLocalSymInfo("with()");
il.Emit(OpCodes.Stloc, local);
}
else
{
il.Emit(OpCodes.Pop);
}
il.BeginExceptionBlock();
this.block.TranslateToILInitializer(il);
this.block.TranslateToIL(il, Typeob.Void);
il.BeginFinallyBlock();
if (base.context.document.debugOn)
{
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Stloc, local);
}
base.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.popScriptObjectMethod);
il.Emit(OpCodes.Pop);
il.EndExceptionBlock();
if (base.context.document.debugOn)
{
il.EndScope();
}
il.MarkLabel(item);
base.compilerGlobals.BreakLabelStack.Pop();
base.compilerGlobals.ContinueLabelStack.Pop();
base.compilerGlobals.InsideProtectedRegion = insideProtectedRegion;
base.Globals.ScopeStack.Pop();
}
public static void checkAndSetExceptionHandler(List <FixedExceptionHandlersClass> sorted, int i, ILGenerator ilGenerator)
{
foreach (var allExceptionHandlerse in sorted)
{
if (allExceptionHandlerse.HandlerType == 1)
{
if (allExceptionHandlerse.TryStart == i)
{
ilGenerator.BeginExceptionBlock();
}
if (allExceptionHandlerse.HandlerEnd == i)
{
ilGenerator.EndExceptionBlock();
}
if (allExceptionHandlerse.HandlerStart.Contains(i))
{
var indes = allExceptionHandlerse.HandlerStart.IndexOf(i);
ilGenerator.BeginCatchBlock(allExceptionHandlerse.CatchType[indes]);
}
}
else if (allExceptionHandlerse.HandlerType == 5)
{
if (allExceptionHandlerse.TryStart == i)
{
ilGenerator.BeginExceptionBlock();
}
else if (allExceptionHandlerse.HandlerEnd == i)
{
ilGenerator.EndExceptionBlock();
}
else if (allExceptionHandlerse.TryEnd == i)
{
ilGenerator.BeginFinallyBlock();
}
}
}
}
public DefineLabelDelegate BeginExceptionBlock()
{
ILGenerator forIl = null;
System.Reflection.Emit.Label?l = null;
DefineLabelDelegate ret =
il =>
{
if (forIl != null && forIl != il)
{
l = null;
}
if (l != null)
{
return(l.Value);
}
forIl = il;
l = forIl.BeginExceptionBlock();
return(l.Value);
};
InstructionSizes.Add(() => InstructionSize.BeginExceptionBlock());
LengthCache.Clear();
Buffer.Add(
(il, logOnly, log) =>
{
if (!logOnly)
{
ret(il);
}
log.AppendLine("--BeginExceptionBlock--");
}
);
TraversableBuffer.Add(new BufferedILInstruction {
StartsExceptionBlock = true
});
Operations.Add(null);
return(ret);
}
public void PosTest3()
{
MethodBuilder method = TestTypeBuilder.DefineMethod("PosTest3_Method", DefaultMethodAttribute);
ILGenerator generator = method.GetILGenerator();
LocalBuilder arg = generator.DeclareLocal(typeof(object));
generator.BeginExceptionBlock();
generator.Emit(OpCodes.Ldnull, arg);
generator.Emit(OpCodes.Ldarg_0, arg);
generator.Emit(OpCodes.Nop, arg);
// Try emit opcode which takes multiple args
generator.Emit(OpCodes.Add, arg);
}
public static void Do()
{
string name = "EmitDemo.ExceptionHandler";
string asmFileName = name + ".dll";
AssemblyName asmName = new AssemblyName(name);
AssemblyBuilder assBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave);
ModuleBuilder moduleBuilder = assBuilder.DefineDynamicModule(name, asmFileName);
TypeBuilder typeBuilder = moduleBuilder.DefineType(name, TypeAttributes.Public);
MethodBuilder methodBuilder = typeBuilder.DefineMethod("ConvertToInt32", MethodAttributes.Public | MethodAttributes.Static, typeof(Int32), new Type[] { typeof(string) });
ILGenerator methodIL = methodBuilder.GetILGenerator();
LocalBuilder num = methodIL.DeclareLocal(typeof(Int32));
//int num = 0;
methodIL.Emit(OpCodes.Ldc_I4_0);
methodIL.Emit(OpCodes.Stloc_0);//从计算堆栈的顶部弹出当前值并将其存储到索引 0 处的局部变量列表中
//begin try
Label lblTry = methodIL.BeginExceptionBlock();
//num = Convert.ToInt32(str);
methodIL.Emit(OpCodes.Ldarg_0);
methodIL.Emit(OpCodes.Call, typeof(Convert).GetMethod("ToInt32", new Type[] { typeof(string) }));
methodIL.Emit(OpCodes.Stloc_0);
//end try
//begin catch,注意，这个时侯堆栈顶为异常信息ex
methodIL.BeginCatchBlock(typeof(Exception));
//Console.WriteLine(ex.Message);
methodIL.Emit(OpCodes.Call, typeof(Exception).GetMethod("get_Message"));
methodIL.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }));
methodIL.EndExceptionBlock();
//return num
methodIL.Emit(OpCodes.Ldloc_0);
methodIL.Emit(OpCodes.Ret);
Type type = typeBuilder.CreateType();
assBuilder.Save(asmFileName);
Console.WriteLine("input a string :");
var str = Console.ReadLine();
int numRst = Convert.ToInt32(type.GetMethod("ConvertToInt32").Invoke(null, new object[] { str }));
Console.WriteLine("convert result:{0}", numRst);
}
/// <summary>
/// Aspect code to inject at the beginning of weaved method
/// </summary>
/// <param name="typeBuilder">Type Builder</param>
/// <param name="method">Method</param>
/// <param name="parameter">Parameter</param>
/// <param name="il">ILGenerator</param>
internal void BeginAspectBlock(TypeBuilder typeBuilder, MethodBase method, ParameterInfo parameter, ILGenerator il)
{
var meth = method as MethodInfo;
var returnType = meth.ReturnType;
local = returnType != typeof(void) ? il.DeclareLocal(returnType) : null;
@lock = il.DeclareLocal(typeof(Thread.ReaderWriterLockSlim));
il.Emit(method.IsStatic ? OpCodes.Ldnull : OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, GetLockMethod);
il.Emit(OpCodes.Stloc, @lock);
il.BeginExceptionBlock();
il.Emit(OpCodes.Ldloc, @lock);
il.Emit(OpCodes.Callvirt, EnterMethod);
}
public void PosTest3()
{
TypeBuilder type = Helpers.DynamicType(TypeAttributes.NotPublic);
MethodBuilder method = type.DefineMethod("Method", MethodAttributes.Public | MethodAttributes.Static);
ILGenerator generator = method.GetILGenerator();
LocalBuilder arg = generator.DeclareLocal(typeof(object));
generator.BeginExceptionBlock();
generator.Emit(OpCodes.Ldnull, arg);
generator.Emit(OpCodes.Ldarg_0, arg);
generator.Emit(OpCodes.Nop, arg);
// Try emit opcode which takes multiple args
generator.Emit(OpCodes.Add, arg);
}
private void InitSerializeFieldsDelegate(Type type)
{
Dictionary <string, MemberInfo> fields = HproseHelper.GetFields(type);
DynamicMethod dynamicMethod = new DynamicMethod("$SerializeFields",
typeofVoid,
typeofArgs,
type,
true);
ILGenerator gen = dynamicMethod.GetILGenerator();
LocalBuilder value = gen.DeclareLocal(typeofObject);
LocalBuilder e = gen.DeclareLocal(typeofException);
foreach (KeyValuePair <string, MemberInfo> field in fields)
{
FieldInfo fieldInfo = (FieldInfo)field.Value;
Label exTryCatch = gen.BeginExceptionBlock();
if (type.IsValueType)
{
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Unbox, type);
}
else
{
gen.Emit(OpCodes.Ldarg_0);
}
gen.Emit(OpCodes.Ldfld, fieldInfo);
if (fieldInfo.FieldType.IsValueType)
{
gen.Emit(OpCodes.Box, fieldInfo.FieldType);
}
gen.Emit(OpCodes.Stloc_S, value);
gen.Emit(OpCodes.Leave_S, exTryCatch);
gen.BeginCatchBlock(typeofException);
gen.Emit(OpCodes.Stloc_S, e);
gen.Emit(OpCodes.Ldstr, "The field value can\'t be serialized.");
gen.Emit(OpCodes.Ldloc_S, e);
gen.Emit(OpCodes.Newobj, hproseExceptionCtor);
gen.Emit(OpCodes.Throw);
gen.Emit(OpCodes.Leave_S, exTryCatch);
gen.EndExceptionBlock();
gen.Emit(OpCodes.Ldarg_1);
gen.Emit(OpCodes.Ldloc_S, value);
gen.Emit(OpCodes.Call, serializeMethod);
}
gen.Emit(OpCodes.Ret);
serializeFieldsDelegate = (SerializeDelegate)dynamicMethod.CreateDelegate(typeofSerializeDelegate);
}
private static void EmitDeserializeConverter(ILGenerator il, SerializedMemberInfo member, Label nextLabel, LocalAllocator GetLocal,
Action <ILGenerator> thisobj, Action <ILGenerator> parentobj)
{
if (!member.HasConverter)
{
throw new InvalidOperationException("EmitDeserializeConverter called for member without converter");
}
using var stlocal = GetLocal.Allocate(typeof(Value));
using var valLocal = GetLocal.Allocate(member.Type);
il.Emit(OpCodes.Stloc, stlocal);
il.BeginExceptionBlock();
il.Emit(OpCodes.Ldsfld, member.ConverterField);
il.Emit(OpCodes.Ldloc, stlocal);
parentobj(il);
if (member.IsGenericConverter)
{
var fromValueBase = member.ConverterBase.GetMethod(nameof(ValueConverter <int> .FromValue),
new[] { typeof(Value), typeof(object) });
var fromValue = member.Converter.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
.FirstOrDefault(m => m.GetBaseDefinition() == fromValueBase) ?? fromValueBase;
il.Emit(OpCodes.Call, fromValue);
}
else
{
var fromValueBase = typeof(IValueConverter).GetMethod(nameof(IValueConverter.FromValue),
new[] { typeof(Value), typeof(object) });
var fromValue = member.Converter.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
.FirstOrDefault(m => m.GetBaseDefinition() == fromValueBase) ?? fromValueBase;
il.Emit(OpCodes.Call, fromValue);
if (member.Type.IsValueType)
{
il.Emit(OpCodes.Unbox);
}
}
il.Emit(OpCodes.Stloc, valLocal);
il.BeginCatchBlock(typeof(Exception));
EmitWarnException(il, "Error occurred while deserializing");
il.Emit(OpCodes.Leave, nextLabel);
il.EndExceptionBlock();
il.Emit(OpCodes.Ldloc, valLocal);
}
public static Func <object, BaseProvider, List <DbParameter> > GetParamsImpl(object paramters, Type parametersType)
{
DynamicMethod method = new DynamicMethod(string.Format("Deserialize{0}", Guid.NewGuid()), typeof(List <DbParameter>), new Type[] { typeof(object), typeof(BaseProvider) }, true);
ILGenerator iLGenerator = method.GetILGenerator();
iLGenerator.DeclareLocal(typeof(List <DbParameter>));
iLGenerator.Emit(OpCodes.Newobj, typeof(List <DbParameter>).GetConstructor(new Type[] { }));
iLGenerator.Emit(OpCodes.Stloc_0);
List <PropertyInfo> items = parametersType.GetProperties().ToList();
iLGenerator.BeginExceptionBlock();
var indexlocal = iLGenerator.DeclareLocal(typeof(object));
var indexlocalDbParameter = iLGenerator.DeclareLocal(typeof(DbParameter));
foreach (PropertyInfo item in items)
{
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Unbox_Any, parametersType);
iLGenerator.Emit(OpCodes.Callvirt, item.GetGetMethod(true));
if (item.PropertyType.IsValueType)
{
iLGenerator.Emit(OpCodes.Box, item.PropertyType);
}
iLGenerator.Emit(OpCodes.Box, typeof(object));
iLGenerator.Emit(OpCodes.Stloc, indexlocal);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.Emit(OpCodes.Ldstr, item.Name);
iLGenerator.Emit(OpCodes.Ldloc, indexlocal);
iLGenerator.Emit(OpCodes.Callvirt, typeof(BaseProvider).GetMethod("CreateEmitParameter", new Type[] { typeof(string), typeof(object) }));
iLGenerator.Emit(OpCodes.Stloc, indexlocalDbParameter);
iLGenerator.Emit(OpCodes.Ldloc_0);
iLGenerator.Emit(OpCodes.Ldloc, indexlocalDbParameter);
iLGenerator.Emit(OpCodes.Callvirt, typeof(List <DbParameter>).GetMethod("Add", new Type[] { typeof(DbParameter) }));
}
iLGenerator.BeginCatchBlock(typeof(Exception));
iLGenerator.EmitCall(OpCodes.Call, typeof(SqlMapper).GetMethod("ThrowDataException"), null);
iLGenerator.EndExceptionBlock();
iLGenerator.Emit(OpCodes.Ldloc_0);
iLGenerator.Emit(OpCodes.Ret);
return((Func <object, BaseProvider, List <DbParameter> >)method.CreateDelegate(typeof(Func <object, BaseProvider, List <DbParameter> >)));
}
void EmitSpecial(ILGenerator gen)
{
switch (special)
{
case Specials.Label:
gen.MarkLabel((Label)operand);
break;
case Specials.BeginTry:
gen.BeginExceptionBlock();
break;
case Specials.BeginFinally:
gen.BeginFinallyBlock();
break;
case Specials.EndTry:
gen.EndExceptionBlock();
break;
case Specials.BeginTotemScope:
gen.Emit(OpCodes.Nop);
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Newobj, Generator.scope_ctor);
gen.Emit(OpCodes.Stloc, (LocalBuilder)operand);
gen.BeginExceptionBlock();
break;
case Specials.EndTotemScope:
var endFinallyLabel = gen.DefineLabel();
gen.BeginFinallyBlock();
gen.Emit(OpCodes.Ldloc, (LocalBuilder)operand);
gen.Emit(OpCodes.Ldnull);
gen.Emit(OpCodes.Ceq);
gen.Emit(OpCodes.Brtrue, endFinallyLabel);
gen.Emit(OpCodes.Ldloc, (LocalBuilder)operand);
gen.Emit(OpCodes.Callvirt, Generator.dispose);
gen.Emit(OpCodes.Nop);
gen.MarkLabel(endFinallyLabel);
gen.EndExceptionBlock();
break;
default:
throw new InvalidOperationException("default:special");
}
}