示例#1
0
        private void WeaveOnExecute(MethodDefinition targetMethod, ILProcessor ilp, VariableDefinition aspectInstance, VariableDefinition correlation, Instruction addAfter)
        {
            if (_onExecute != null)
            {
                var onExecInstructions = GetOnExecuteInstructions(targetMethod, ilp, aspectInstance, correlation);

                if (addAfter == null)
                {
                    ilp.PrependInstructions(onExecInstructions);
                }
                else
                {
                    ilp.InsertInstructionsAfter(addAfter, onExecInstructions);
                }
            }
        }
示例#2
0
        private void WeaveOnException(MethodDefinition targetMethod, ILProcessor ilp, VariableDefinition aspectInstance, VariableDefinition correlation, Instruction addAfter)
        {
            if (_onException != null)
            {
                targetMethod.Body.InitLocals = true;

                var exceptionType = targetMethod.Module.Import(typeof(Exception));

                var onExceptionInstructions = GetOnExceptionInstructions(targetMethod, ilp, aspectInstance, correlation, exceptionType).ToArray();

                var tryEnd = ilp.Body.Instructions.Last();
                var returns = false;

                if (tryEnd.OpCode == OpCodes.Ret)
                {
                    returns = true;

                    var nopOrLoad = tryEnd.Previous;

                    if (nopOrLoad.OpCode == OpCodes.Nop)
                    {
                        var leaveToNop = ilp.Create(OpCodes.Leave_S, nopOrLoad);
                        ilp.InsertBefore(nopOrLoad, leaveToNop);
                        tryEnd = nopOrLoad;
                    }
                    else
                    {
                        var nopOrBreak = nopOrLoad.Previous;

                        if (nopOrBreak.OpCode == OpCodes.Br_S)
                        {
                            var nop = ilp.Create(OpCodes.Nop);
                            ilp.InsertBefore(nopOrBreak, nop);

                            ilp.Remove(nopOrBreak);

                            var leave = ilp.Create(OpCodes.Leave_S, nop);
                            ilp.InsertBefore(nop, leave);

                            tryEnd = nop;
                        }
                        else
                        {
                            tryEnd = nopOrBreak;
                        }
                    }
                }
                else
                {
                    var nop = ilp.Create(OpCodes.Nop);
                    ilp.Append(nop);

                    tryEnd = nop;
                }

                var insertPoint = tryEnd.Previous;

                ilp.InsertInstructionsAfter(insertPoint, onExceptionInstructions);

                if (!returns)
                {
                    ilp.Remove(tryEnd);
                }

                tryEnd = insertPoint.Next;

                var exceptionHandler = new ExceptionHandler(ExceptionHandlerType.Catch)
                {
                    TryStart = addAfter != null
                        ? addAfter.Next
                        : ilp.Body.Instructions.First(),
                    TryEnd = tryEnd,
                    HandlerStart = tryEnd,
                    HandlerEnd = returns
                        ? onExceptionInstructions.Last().Next
                        : null,
                    CatchType = exceptionType
                };

                targetMethod.Body.ExceptionHandlers.Add(exceptionHandler);
            }
        }