public void AfterInvoke(IInvocationInfo context, object returnValue)
 {
     foreach (IAroundInvoke invoke in _aroundInvokeList)
     {
         invoke.AfterInvoke(context, returnValue);
     }
 }

        public override object Intercept(IInvocationInfo info)
        {
            //typeof(LobbyMenu).GetField ("_hoverButtonInside", BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.Instance).SetValue (info.Target, false);
            try {
                Type lobbyMenu = typeof(LobbyMenu);

                if (first) {

                    GUISkin gUISkin7 = ScriptableObject.CreateInstance<GUISkin> ();

                    text = new Texture2D(87, 39); //115, 39
                    text.LoadImage(System.Reflection.Assembly.GetExecutingAssembly ().GetManifestResourceStream ("ScrollsModLoader.Mods.png").ReadToEnd ());

                    gUISkin7.button.normal.background = text;
                    gUISkin7.button.hover.background = text;
                    gUISkin7.button.active.background = text;

                    //info.Target.GUISkins.Add (gUISkin5);
                    FieldInfo GUISkins = lobbyMenu.GetField("GUISkins", BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.Instance);
                    if (GUISkins == null)
                        Console.WriteLine ("GuiSkins == null");
                    ((List<GUISkin>)(GUISkins.GetValue(info.Target))).Add(gUISkin7);
                    first = false;
                }

                MethodInfo drawHeader = lobbyMenu.GetMethod ("drawHeaderButton", BindingFlags.NonPublic | BindingFlags.Instance);
                drawHeader.Invoke(info.Target, new object[] {6, "_Settings"});

            } catch (Exception exp) {
                Console.WriteLine (exp);
            }
            return info.TargetMethod.Invoke(info.Target, info.Arguments);
        }

        /// <summary>
        /// Determines whether or not a particular method body should be replaced at runtime.
        /// </summary>
        /// <param name="host">The host instance that contains the target method.</param>
        /// <param name="context">The context surrounding the method call.</param>
        /// <returns>Returns <c>true</c> if the method body should be swapped; otherwise, it will return <c>false</c>.</returns>
        protected override bool ShouldReplace(object host, IInvocationInfo context)
        {
            if (MethodReplacementPredicate == null)
                return true;

            return MethodReplacementPredicate(context);
        }

        /// <summary>
        /// A method that redirects the method calls to 
        /// the functor instance.
        /// </summary>
        /// <param name="info">The <see cref="IInvocationInfo"/> instance that describes the context of the method call.</param>
        /// <returns>The return value from the target method.</returns>
        public object Intercept(IInvocationInfo info)
        {
            if (_doIntercept == null)
                throw new NotImplementedException();

            return _doIntercept(info);
        }

        /// <summary>
        /// Returns the provider that is currently attached to the registry.
        /// </summary>
        /// <param name="host">The type that is currently being intercepted.</param>
        /// <param name="info">The <see cref="IInvocationInfo"/> object that describes the invocation context.</param>
        /// <returns>A <see cref="IMethodReplacementProvider"/> that will determine the code that will be executed once a target method is called.</returns>
        public static IMethodReplacementProvider GetProvider(object host, IInvocationInfo info)
        {
            if (_provider == null)
                return null;

            return _provider.CanReplace(host, info) ? _provider : null;
        }

 /// <summary>
 /// Initializes the class with a functor that can provide the actual target instance.
 /// </summary>
 /// <param name="getActualTarget">The <see cref="Func{TResult}"/> that will provide the target instance that will be used for the method invocation.</param>
 /// <param name="methodInvoke">The method invoker.</param>
 /// <param name="realInfo">The <see cref="IInvocationInfo"/> instance that describes the current execution context.</param>
 internal InvocationInfoInterceptor(IInvocationInfo realInfo, Func<object> getActualTarget,
                                    IMethodInvoke<MethodInfo> methodInvoke)
     : base(methodInvoke)
 {
     _getActualTarget = getActualTarget;
     _realInfo = realInfo;
 }

        public IAroundInvoke GetSurroundingImplementation(IInvocationInfo context)
        {
            if (Predicate == null)
                return _around;

            return Predicate(context) ? _around : null;
        }

        public object Intercept(IInvocationInfo info)
        {
            var args = string.Join(", ", info.Arguments.Select(x => (x ?? string.Empty).ToString()));
            Debug.WriteLine(string.Format("Linfu: {0}({1})", info.TargetMethod.Name, args));

            return info.TargetMethod.Invoke(info.Target, info.Arguments);
        }

 public object Invoke(IInvocationInfo invocationInfo)
 {
     if (session.InTransaction)
     {
         return invocationInfo.Proceed();
     }
     using (var transaction = session.Connection.BeginTransaction())
     {
         session.InTransaction = true;
         try
         {
             var result = invocationInfo.Proceed();
             transaction.Commit();
             return result;
         }
         catch (Exception)
         {
             transaction.Rollback();
             throw;
         }
         finally
         {
             session.InTransaction = false;
         }
     }
 }

 public void BeforeInvoke(IInvocationInfo context)
 {
     foreach (IAroundInvoke invoke in _aroundInvokeList)
     {
         invoke.BeforeInvoke(context);
     }
 }

        /// <summary>
        /// Intercepts a method call using the given
        /// <see cref="IInvocationInfo"/> instance.
        /// </summary>
        /// <param name="info">The <see cref="IInvocationInfo"/> instance that will 
        /// contain all the necessary information associated with a 
        /// particular method call.</param>
        /// <returns>The return value of the target method. If the return type of the target
        /// method is <see cref="void"/>, then the return value will be ignored.</returns>
        public virtual object Intercept(IInvocationInfo info)
        {
            object target = GetTarget(info);
            MethodBase method = info.TargetMethod;
            object[] arguments = info.Arguments;

            return _methodInvoke.Invoke(target, (MethodInfo) method, arguments);
        }

        /// <summary>
        /// Intercepts a method call using the given
        /// <see cref="IInvocationInfo"/> instance.
        /// </summary>
        /// <param name="info">The <see cref="IInvocationInfo"/> instance that will 
        /// contain all the necessary information associated with a 
        /// particular method call.</param>
        /// <returns>The return value of the target method. If the return type of the target
        /// method is <see cref="Void"/>, then the return value will be ignored.</returns>
        public virtual object Intercept(IInvocationInfo info)
        {
            var target = GetTarget(info);
            var method = info.TargetMethod;
            var arguments = info.Arguments;

            return _methodInvoke.Invoke(target, (MethodInfo)method, arguments);
        }

        public object Intercept(IInvocationInfo info)
        {
            var methodName = info.TargetMethod.Name;

            Console.WriteLine("method '{0}' called", methodName);

            return info.TargetMethod;
        }

        public int GetPendingCalls(IInvocationInfo context)
        {
            int threadId = Thread.CurrentThread.ManagedThreadId;
            if (!_counts.ContainsKey(threadId))
                return 0;

            return _counts[threadId].GetPendingCalls(context);
        }

        /// <summary>
        /// Determines whether or not the current method implementation can be replaced.
        /// </summary>
        /// <param name="host">The target instance of the method call.</param>
        /// <param name="context">The <see cref="IInvocationInfo"/> that describes the context of the method call.</param>
        /// <returns><c>true</c> if the method can be intercepted; otherwise, it will return <c>false</c>.</returns>
        public bool CanReplace(object host, IInvocationInfo context)
        {
            var pendingCalls = _counter.GetPendingCalls(context);

            if (pendingCalls > 0)
                return false;

            return ShouldReplace(host, context);
        }

 /// <summary>
 /// Gets the surrounding implemetation for a given <see cref="IInvocationInfo">invocation context</see>.
 /// </summary>
 /// <param name="context">The context surrounding the method call.</param>
 /// <returns>The interceptor that will invoke around the method at runtime.</returns>
 public IAroundInvoke GetSurroundingImplementation(IInvocationInfo context)
 {
     var invokes = new HashSet<IAroundInvoke>();
     foreach (var invokePredicate in MethodInvokesAndPredicates.Where(x => x.Value != null && x.Value(context)))
     {
         invokes.Add(invokePredicate.Key);
     }
     return (invokes.Count > 0) ? new CompositeAroundInvoke(invokes) : null;
 }

 public object Intercept(IInvocationInfo info)
 {
     var methodName = info.TargetMethod.Name;
     Trace.WriteLine(String.Format("before: {0}", methodName));
     var result = info.TargetMethod.Invoke(info.Target, info.Arguments);
     result = (int)result * 2;
     Trace.WriteLine(String.Format("after: {0}", methodName));
     return result;
 }

 public InvocationInfo(IInvocationInfo info)
 {
     target = info.Target;
     targetMethod = info.TargetMethod.Name;
     stackTrace = info.StackTrace;
     returnType = info.ReturnType;
     parameterTypes = info.ParameterTypes;
     typeArguments = info.TypeArguments;
     arguments = info.Arguments;
 }

        /// <summary>
        /// Obtains the <see cref="IInterceptor"/> instance that will be used to replace the current method call.
        /// </summary>
        /// <param name="host">The target instance of the method call.</param>
        /// <param name="context">The <see cref="IInvocationInfo"/> that describes the context of the method call.</param>
        /// <returns>The interceptor that will intercept the method call itself.</returns>
        public IInterceptor GetMethodReplacement(object host, IInvocationInfo context)
        {
            var pendingCalls = _counter.GetPendingCalls(context);

            if (pendingCalls > 0)
                return null;

            var methodReplacement = GetReplacement(host, context);
            return new CountingInterceptor(_counter, methodReplacement);
        }

        public object Intercept(IInvocationInfo info)
        {
            var methodName = info.TargetMethod.Name;
            Console.WriteLine("method '{0}' called", methodName);

            // Replace the input parameter with 42
            var result = info.TargetMethod.Invoke(info.Target, new object[]{42});

            return result;
        }