AllowChangingInputArguments System.InvalidProgramException

[Son1x90]

The Following code gives the following runtime error:
System.InvalidProgramException Common Language Runtime detected an invalid program.

Minimalistic Setup:

using MethodBoundaryAspect.Fody.Attributes;
using System.Reflection;

internal class Program
{

    [AllowChangingInputArguments]
    public class AsyncWrapperAttribute : OnMethodBoundaryAspect
    {

        public override void OnEntry(MethodExecutionArgs args)
        {
            Console.WriteLine("testing");
        }

    }

    class FodyTestClass
    {
        [AsyncWrapper]
        public bool FillGuids(out Guid guid1, out Guid guid2)
        {
            guid1 = Guid.NewGuid();
            guid2 = Guid.NewGuid();
            return true;
        }
    }


    private static void Main(string[] args)
    {
        FodyTestClass fodyTestClass = new FodyTestClass();
        fodyTestClass.FillGuids(out Guid guid1, out Guid guid2);


        Console.WriteLine("Hello, World!");
    }
}

Full Code: Method wrapper for WPF running functions without SynchronizationContext
Goal: Being able to set out params

using MethodBoundaryAspect.Fody.Attributes;
using System.Reflection;

internal class Program
{

    [AllowChangingInputArguments]
    public class AsyncWrapperAttribute : OnMethodBoundaryAspect
    {
        private static AsyncLocal<bool> isExecuting = new AsyncLocal<bool>();

        public override void OnEntry(MethodExecutionArgs args)
        {
            if (isExecuting.Value)
                return;

            var method = args.Method as MethodInfo;
            if (method == null)
                throw new InvalidOperationException("Method is not a valid MethodInfo.");

            var parameters = method.GetParameters();
            object[] arguments = new object[args.Arguments.Length];
            Array.Copy(args.Arguments, arguments, args.Arguments.Length);

            isExecuting.Value = true;

            try
            {
                object result = null;

                ExecuteWithoutSynchronizationContext(() =>
                {
                    object[] tempArguments = new object[arguments.Length];
                    Array.Copy(arguments, tempArguments, arguments.Length);
                    result = method.Invoke(args.Instance, tempArguments);

                    for (int i = 0; i < parameters.Length; i++)
                        if (parameters[i].IsOut || parameters[i].ParameterType.IsByRef)
                            args.Arguments[i] = tempArguments[i];
                });

                args.ReturnValue = result;
                args.FlowBehavior = FlowBehavior.Return;
            }
            finally
            {
                isExecuting.Value = false;
            }
        }

        private void ExecuteWithoutSynchronizationContext(Action action)
        {
            var currentContext = SynchronizationContext.Current;
            try
            {
                SynchronizationContext.SetSynchronizationContext(null);
                action();
            }
            finally
            {
                SynchronizationContext.SetSynchronizationContext(currentContext);
            }
        }
    }

    class FodyTestClass
    {
        [AsyncWrapper]
        public bool FillGuids(out Guid guid1, out Guid guid2)
        {
            guid1 = Guid.NewGuid();
            guid2 = Guid.NewGuid();
            return true;
        }
    }


    private static void Main(string[] args)
    {
        FodyTestClass fodyTestClass = new FodyTestClass();
        fodyTestClass.FillGuids(out Guid guid1, out Guid guid2);


        Console.WriteLine("Hello, World!");
    }
}

Minimal Repro

Running Minimalistic Setup will give the Exception on the following line:
fodyTestClass.FillGuids(out Guid guid1, out Guid guid2);

Running the Full code without the AllowChangingInputArguments attribute results in:
not set parameters (guid1 & guid2 both are Guid.Empty) in the Main function after line
fodyTestClass.FillGuids(out Guid guid1, out Guid guid2);

[Ralf1108]

Hi @Son1x90,

Can you reduce your code to reproduce the error?
Why is AsyncLocal used at all?
Please also remove ExecuteWithoutSynchronizationContext() for reproduction.
Remove everything to have the smallest amount of code to reproduce the bug

Thx

[Son1x90]

For Testing please use a WPF Application.

There are 2 code sections, the top one is the "Minimalistic Setup" without AsyncLocal and without ExecuteWithoutSynchronizationContext().
Reproduction Steps:

1. Create WPF app.
2. Delete contents of Program.cs
3. Paste Minimalistic Setup Code.
4. Build & Run.

Result:
Exception System.InvalidProgramException on line fodyTestClass.FillGuids(out Guid guid1, out Guid guid2);

Expected:
No exceptions and guid1 and guid2 not being Guid.Empty

Note:
If you comment out [AllowChangingInputArguments] then no Exception is thrown but guid1 and guid2 are Guid.Empty
If i understood correctly The [AllowChangingInputArguments] is needed to being able to modify the out params.
So the out params will not come back as Guid.Empty.

Anything after this line is probably not needed in order to resolve the issue.

The "Full Code"
There is an issue with WPF and WCF where without the AsyncWrapperAttribute on the functions using WCF API calls would end up in a deadlock. More info here: https://stackoverflow.com/questions/25095243/set-synchronizationcontext-to-null-instead-of-using-configureawaitfalse

The AsyncLocal is for preventing the Function being executed twice since it is calling OnEntry again on method.Invoke, without AsyncLocal it would call itself infinitely and end up in a Stack Overflow.