Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Dispatcher/ThreadBehavior.cs

@@ -0,0 +1,147 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//-----------------------------------------------------------------------------
+
+namespace System.ServiceModel.Dispatcher
+{
+    using System;
+    using System.Runtime;
+    using System.ServiceModel;
+    using System.ServiceModel.Activation;
+    using System.Threading;
+
+    class ThreadBehavior
+    {
+        SendOrPostCallback threadAffinityStartCallback;
+        SendOrPostCallback threadAffinityEndCallback;
+        static Action<object> cleanThreadCallback;
+        readonly SynchronizationContext context;
+       
+        internal ThreadBehavior(DispatchRuntime dispatch)
+        {
+            this.context = dispatch.SynchronizationContext;
+        }
+
+        SendOrPostCallback ThreadAffinityStartCallbackDelegate
+        {
+            get
+            {
+                if (this.threadAffinityStartCallback == null)
+                {
+                    this.threadAffinityStartCallback = new SendOrPostCallback(this.SynchronizationContextStartCallback);
+                }
+                return this.threadAffinityStartCallback;
+            }
+        }
+        SendOrPostCallback ThreadAffinityEndCallbackDelegate
+        {
+            get
+            {
+                if (this.threadAffinityEndCallback == null)
+                {
+                    this.threadAffinityEndCallback = new SendOrPostCallback(this.SynchronizationContextEndCallback);
+                }
+                return this.threadAffinityEndCallback;
+            }
+        }
+
+        static Action<object> CleanThreadCallbackDelegate
+        {
+            get
+            {
+                if (ThreadBehavior.cleanThreadCallback == null)
+                {
+                    ThreadBehavior.cleanThreadCallback = new Action<object>(ThreadBehavior.CleanThreadCallback);
+                }
+                return ThreadBehavior.cleanThreadCallback;
+            }
+        }
+
+        internal void BindThread(ref MessageRpc rpc)
+        {
+            this.BindCore(ref rpc, true);
+        }
+
+        internal void BindEndThread(ref MessageRpc rpc)
+        {
+            this.BindCore(ref rpc, false);
+        }
+
+        void BindCore(ref MessageRpc rpc, bool startOperation)
+        {
+            SynchronizationContext syncContext = GetSyncContext(rpc.InstanceContext);
+
+            if (syncContext != null)
+            {
+                IResumeMessageRpc resume = rpc.Pause();
+                if (startOperation)
+                {
+                    syncContext.OperationStarted();
+                    syncContext.Post(this.ThreadAffinityStartCallbackDelegate, resume);
+                }
+                else
+                {
+                    syncContext.Post(this.ThreadAffinityEndCallbackDelegate, resume);
+                }
+            }
+            else if (rpc.SwitchedThreads)
+            {
+                IResumeMessageRpc resume = rpc.Pause();
+                ActionItem.Schedule(ThreadBehavior.CleanThreadCallbackDelegate, resume);
+            }
+        }
+
+        SynchronizationContext GetSyncContext(InstanceContext instanceContext)
+        {
+            Fx.Assert(instanceContext != null, "instanceContext is null !");
+            SynchronizationContext syncContext = instanceContext.SynchronizationContext ?? this.context;
+            return syncContext;
+        }
+
+        void SynchronizationContextStartCallback(object state)
+        {
+            ResumeProcessing((IResumeMessageRpc)state);
+        }
+        void SynchronizationContextEndCallback(object state)
+        {
+            IResumeMessageRpc resume = (IResumeMessageRpc)state;
+
+            ResumeProcessing(resume);
+
+            SynchronizationContext syncContext = GetSyncContext(resume.GetMessageInstanceContext());
+            Fx.Assert(syncContext != null, "syncContext is null !?");
+            syncContext.OperationCompleted();
+        }
+        void ResumeProcessing(IResumeMessageRpc resume)
+        {
+            bool alreadyResumedNoLock;
+            resume.Resume(out alreadyResumedNoLock);
+
+            if (alreadyResumedNoLock)
+            {
+                string text = SR.GetString(SR.SFxMultipleCallbackFromSynchronizationContext, context.GetType().ToString());
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(text));
+            }
+        }
+
+        static void CleanThreadCallback(object state)
+        {
+            bool alreadyResumedNoLock;
+            ((IResumeMessageRpc)state).Resume(out alreadyResumedNoLock);
+
+            if (alreadyResumedNoLock)
+            {
+                Fx.Assert("IOThreadScheduler called back twice");
+            }
+        }
+
+        internal static SynchronizationContext GetCurrentSynchronizationContext()
+        {
+            if (AspNetEnvironment.IsApplicationDomainHosted())
+            {
+                return null;
+            }
+            return SynchronizationContext.Current;
+        }
+    }
+}