Fixes sync context capture and multiple async continuation issues (#5044)

* Fixes sync context capture and multiple async continuation issues

* Fix callback contract capturing Sync Context breaking test due to XUnit sync context

* Fix some more test issues now we're capturing sync context

* Fix test mistake where it was making 100 calls instead of 1

* Add client certificate requirement to new tests using client certificates

Author: mconnew

global.json

@@ -4,7 +4,8 @@
     "runtimes": {
       "dotnet": [
         "3.1.5",
-        "6.0.12"
+        "6.0.15",
+		"7.0.4"
       ]
     }
   },

src/System.Private.ServiceModel/tests/Common/Scenarios/ScenarioTestTypes.cs

@@ -185,7 +185,20 @@ public SingleThreadSynchronizationContext(bool trackOperations)
         public override void Post(SendOrPostCallback d, object state)
         {
             if (d == null) throw new ArgumentNullException("d");
-            _queue.Add(new KeyValuePair<SendOrPostCallback, object>(d, state));
+            if (ExecutionContext.IsFlowSuppressed())
+            {
+                _queue.Add(new KeyValuePair<SendOrPostCallback, object>(d, state));
+            }
+            else
+            {
+                var ec = ExecutionContext.Capture();
+                _queue.Add(new KeyValuePair<SendOrPostCallback, object>(RunOnCapturedState, (d, state, ec)));
+                void RunOnCapturedState(object obj)
+                {
+                    var s = ((SendOrPostCallback d, object state, ExecutionContext ec))obj;
+                    ExecutionContext.Run(s.ec, new ContextCallback(d), s.state);
+                }
+            }
         }
 
         public override void Send(SendOrPostCallback d, object state)
@@ -218,6 +231,15 @@ public void RunOnCurrentThread()
             }
         }
 
+        public Task RunOnThreadPoolThread()
+        {
+            return Task.Run(() =>
+            {
+                SetSynchronizationContext(this);
+                RunOnCurrentThread();
+            });
+        }
+
         public void Complete()
         {
             _queue.CompleteAdding();
@@ -674,6 +696,7 @@ public string StringValue
     }
 }
 
+[CallbackBehavior(UseSynchronizationContext = false)]
 public class WcfDuplexService_CallbackDebugBehavior_Callback : IWcfDuplexService_CallbackDebugBehavior_Callback
 {
     public void ReplyThrow(string input)
@@ -840,6 +863,7 @@ public MyDuplexClientBase(InstanceContext callbackInstance, Binding binding, End
     }
 }
 
+[CallbackBehavior(UseSynchronizationContext = false)]
 public class WcfDuplexServiceCallback : IWcfDuplexServiceCallback, IWcfDuplexService_DataContract_Callback, IWcfDuplexService_Xml_Callback
 {
     private TaskCompletionSource<Guid> _tcs;

src/System.Private.ServiceModel/tests/Scenarios/Binding/Tcp/NetTcpBindingTests.4.0.0.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.ServiceModel;
+using System.Threading.Tasks;
 using Infrastructure.Common;
 using Xunit;
 
@@ -40,4 +41,42 @@ public static void SecurityModeNone_Echo_RoundTrips_String()
             ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory);
         }
     }
+
+    // Test for https://github.com/dotnet/wcf/issues/4946
+    [WcfFact]
+    [OuterLoop]
+    public static async Task SecurityModeNone_Echo_RoundTrips_String_SyncAfterAsync()
+    {
+        string testString = "Hello";
+        ChannelFactory<IWcfServiceGenerated> factory = null;
+        IWcfServiceGenerated serviceProxy = null;
+
+        try
+        {
+            // *** SETUP *** \\
+            NetTcpBinding binding = new NetTcpBinding(SecurityMode.None);
+            factory = new ChannelFactory<IWcfServiceGenerated>(binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_Address));
+            serviceProxy = factory.CreateChannel();
+
+            // *** EXECUTE *** \\
+            string result = serviceProxy.Echo(testString);
+            Assert.Equal(testString, result);
+            // Without the ConfigureAwait, the xunit sync context will hop threads from the
+            // completing thread to their sync context. ConfigureAwait means it continues
+            // executing on the completing thread and triggers the bug (without the fix).
+            result = await serviceProxy.EchoAsync(testString).ConfigureAwait(false);
+            Assert.Equal(testString, result);
+            result = serviceProxy.Echo(testString);
+            Assert.Equal(testString, result);
+
+            // *** CLEANUP *** \\
+            ((ICommunicationObject)serviceProxy).Close();
+            factory.Close();
+        }
+        finally
+        {
+            // *** ENSURE CLEANUP *** \\
+            ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory);
+        }
+    }
 }