148 lines
4.9 KiB
C#
148 lines
4.9 KiB
C#
//-----------------------------------------------------------------------------
|
|
// 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;
|
|
}
|
|
}
|
|
}
|