STA-Thread lost after async operation

[SamuelMuellerKMS]

Describe the bug

When running a STATestMethod and calling a async Method, it's not syncing back to the STA Thread

Steps To Reproduce

Execute an async method in a STATestMethod. After the Execution you will not return on the STA-Thread.

[STATestMethod]
public async Task StaTestMethodIssueTest()
{
	Console.WriteLine($"Current Thread Apartment State: {Thread.CurrentThread.GetApartmentState()}");

	Console.WriteLine("Executing async Method...");
	await Task.Yield();
		
	Console.WriteLine($"Current Thread Apartment State: {Thread.CurrentThread.GetApartmentState()}");
	Assert.IsTrue(Thread.CurrentThread.GetApartmentState() == ApartmentState.STA, "Thread is not in Single Threaded Apartment (STA) mode");
}

Example Project: STATestIssue.zip

Expected behavior

After executing an async Method you should return to the calling thread (or not when .ConfigureAwait(false) is present)

Actual behavior

The STA Thread Context is lost and you get Exceptions when calling code that requires an STA-Thread

[Youssef1313]

Thanks for reporting this @SamuelMuellerKMS. Is this somehow a regression? Or that's how it always behaved?

The current behavior makes sense to me. MSTest doesn't (and shouldn't) plug any custom SynchronizationContext. Without a synchronization context, I don't see how you would expect the continuations to get back to an STA thread (whether it's the same thread or a different one).

If you need special needs, I think you should plug your own SynchronizationContext.

[Youssef1313]

We may actually consider changing STAThreadAttribute behavior so that it either sets a single threaded synchronization context so that continuations are pushed back to the original thread (needs careful implementation, and may risk deadlocks), or alternatively, a synchronization context that always posts continuations to a new STA thread.

[Youssef1313]

@SamuelMuellerKMS Meanwhile, you can try something like the following, which implements a new custom attribute, ExSTATestMethod that uses a single threaded synchronization context.

    internal sealed class ExSTATestMethodAttribute : TestMethodAttribute
    {
        private sealed class SingleThreadSynchronizationContext : SynchronizationContext
        {
            private readonly BlockingCollection<(SendOrPostCallback, object)> _queue = new();
            private readonly Thread _thread;

            public SingleThreadSynchronizationContext()
            {
                _thread = new Thread(() =>
                {
                    SetSynchronizationContext(this);
                    foreach (var (callback, state) in _queue.GetConsumingEnumerable())
                    {
                        callback(state);
                    }
                })
                {
                    IsBackground = true
                };
                _thread.SetApartmentState(ApartmentState.STA);
                _thread.Start();
            }

            public override void Post(SendOrPostCallback d, object state)
            {
                _queue.Add((d, state));
            }

            public override void Send(SendOrPostCallback d, object state)
            {
                if (Environment.CurrentManagedThreadId == _thread.ManagedThreadId)
                {
                    d(state);
                }
                else
                {
                    using var done = new ManualResetEventSlim();
                    _queue.Add((s =>
                    {
                        d(s);
                        done.Set();
                    }, state));
                    done.Wait();
                }
            }

            public void Complete() => _queue.CompleteAdding();
        }


        public override TestResult[] Execute(ITestMethod testMethod)
        {
            return ExecuteInner(testMethod).GetAwaiter().GetResult();
        }

        private async Task<TestResult[]> ExecuteInner(ITestMethod testMethod)
        {
            var originalContext = SynchronizationContext.Current;
            try
            {
                var syncContext = new SingleThreadSynchronizationContext();
                SynchronizationContext.SetSynchronizationContext(syncContext);
                await Task.Yield();
                var t = await testMethod.InvokeAsync(null);
                syncContext.Complete();
                return [t];
            }
            finally
            {
                SynchronizationContext.SetSynchronizationContext(originalContext);
            }
        }
    }

@nohwnd Does the above implementation sound reasonable to you?

[Youssef1313]

@AArnott Can I have your thoughts please on modifying MSTest's STATestMethodAttribute per the above implementation?
Today, what we do is very simple, we simply create a new STA thread, and run the test method (we do .GetAwaiter().GetResult()). This means that the test method is only STA until the first await is encountered.

I'm thinking we could (as a breaking change in MSTest v4) fix the implementation to set a custom synchronization context, as indicated above.

[AArnott]

I've never used [STATestMethod] in MSTest, so I can't speak on compatibility for your proposed change.
I can tell you that [StaFact] is probably one of the least popular attributes in Xunit.StaFact for the reason that it isn't 'sticky' across awaits though. It also ties tests to Windows.

I generally recommend (when no specific GUI framework applies) that folks use [UIFact] in their tests when using Xunit with my xunit.stafact library, since that is xplat but creates an STA thread on Windows, and is 'sticky'.

You can see my implementation of SynchronizationContext that makes this sticky here:

https://github.com/AArnott/Xunit.StaFact/blob/main/src/Xunit.StaFact/Sdk/UISynchronizationContext.cs

TLDR: mine is significantly longer than yours. While some of that is due to xunit-specific interactions, you may still learn some things to add to your proposed version.

[fforjanAVEVA]

I think i'm hitting the same issue.

I have some WPF testing, the Output Log shows (notice the ExecutionThreadApartmentState as STA)

[6/27/2025 3:05:12.920 PM]  Tests run settings for My.dll:
 <RunSettings>
  <!-- Configurations that affect the Test Framework -->
  <RunConfiguration>
    <!-- [x86] | x64  
      - You can also change it from menu Test, Test Settings, Default Processor Architecture -->
    <TargetPlatform>x64</TargetPlatform>
    <!-- Framework35 | [Framework40] | Framework45 -->
    <MaxCpuCount>0</MaxCpuCount>
    <DisableParallelization>true</DisableParallelization>
    <ExecutionThreadApartmentState>STA</ExecutionThreadApartmentState>
    <ResultsDirectory><bla>\TestResults</ResultsDirectory>
    <SolutionDirectory><bla></SolutionDirectory>
    <CollectSourceInformation>False</CollectSourceInformation>
  </RunConfiguration>
  <!-- MSTest adapter -->
  <MSTest>
    <DeleteDeploymentDirectoryAfterTestRunIsComplete>True</DeleteDeploymentDirectoryAfterTestRunIsComplete>
    <DeploymentEnabled>True</DeploymentEnabled>
  </MSTest>
  <Python>
    <TestCases />
  </Python>
</RunSettings>.

But some tests fails (in visual studio or on the build machine)

i can reproduce with the following test class with a unit test configured to use WPF while the context is setup to STA :

[TestClass]
[STATestClass]
public sealed class Test1
{
    [TestMethod]
    public void TestMethod1()
    {
        _ = new Window();
    }

    [TestMethod]
    public async Task  TestMethod2()
    {
        await Task.Yield();
    }

    [TestMethod]
    public void TestMethod3()
    {
        _ = new Window();
    }
}

@Youssef1313 this one is an impediment for us to execute our WPF test, note that the TestMethod2 may be completely unrelated to WPF and simply test a view model

[Youssef1313]

Thanks @fforjanAVEVA. As mentioned before, today's behavior of STA is that it just starts the test method in a STA thread and it doesn't set a synchronization context that schedules continuations on STA as well.

For now you can try out the ExSTATestMethodAttribute implementation that I pasted above. In MSTest v4, I'm considering having STATestMethodAttribute to, by default, set synchronization context.