using System;

​

public static class Program

{

    public static void Main(string[] args)

    {

        // run original

        try

        {

            Test(false);

        }

        catch (AIException ai)

        {

            var mex = ai.InnerException as MovementException;

            if (mex != null)

            {

                Console.WriteLine("Original ==> " + mex);

            }

        }

​

        // run patched

        try

        {

            Test(true);

        }

        catch (AIException ai)

        {

            var mex = ai.InnerException as MovementException;

            if (mex != null)

            {

                Console.WriteLine("Patched ==> " + mex);

            }

        }

    }

​

​

    public static void Test(bool simulatePatching)

    {

        try

        {

            if (simulatePatching)

                PATCHED();

            else

                ORIGINAL();

        }

        catch (MovementException mex)

        {

            throw new AIException("Could not move to target", mex);

        }

    }

​

    // original method that can throw

    public static void ORIGINAL()

    {

        A();

    }

​

    public static void A() { B(); }

    public static void B() { C(); }

    public static void C() { throw new MovementException("first"); }

​

    // simulate harmonys dynamic method that calls

    // original and all patch methods

    public static void PATCHED()

    {

        Exception __ex = null;

        try

        {

            // call all prefixes logic here

​

            ORIGINAL();

​

            // call all postfixes logic here

        }

        catch (Exception ex)

        {

            __ex = ex;

        }

        finally

        {

            // call new finally patch method

            __ex = Finally1(__ex);

            Finally2();

            __ex = Finally3(__ex);

            __ex = Finally4(__ex);

​

            if (__ex != null)

            {

                PreserveStackTrace(__ex);

                throw __ex;

            }

        }

    }

​

    // new harmony patch method types

    public static Exception Finally1(Exception ex)

    {

        // creating a new exception will wipe the lower end of the stacktrace

        // return new MovementException("third");

​

        // editing the exception will keep the stacktrace fully intact

        //

        var f_Message = ex.GetType().GetField("_message", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);

        f_Message.SetValue(ex, "second");

        return ex;

    }

​

    public static void Finally2()

    {

        // void Finally methods can be used to execute code regardless

        // of what happens in the original or any patch method

​

        // a void return value will not alter the exception

    }

​

    public static Exception Finally3(Exception ex)

    {

        // to suppress exceptions, return null

        if (ex is ArgumentNullException)

            return null;

​

        return ex;

    }

​

    public static Exception Finally4(Exception ex)

    {

        // Finally handlers must expect null exception input

        // since any of the previous Finally handlers might

        // want to suppress the original exception

        if (ex != null)

            ; // do something

​

        return ex;

    }

​

    private static void PreserveStackTrace(Exception exception)

    {

        var preserveStackTrace = typeof(Exception).GetMethod("InternalPreserveStackTrace", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);

        preserveStackTrace.Invoke(exception, null);

    }

}

​

[Serializable()]

public class MovementException : System.Exception

{

    public MovementException(string name) : base(name) { }

}

​

[Serializable()]

public class AIException : System.Exception

{

    public AIException(string name, Exception ex) : base(name, ex) { }

}