mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
673 lines
20 KiB
C#
673 lines
20 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel
|
|
{
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Runtime;
|
|
using System.Runtime.CompilerServices;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.ServiceModel.Dispatcher;
|
|
using System.Threading;
|
|
using System.ServiceModel.Diagnostics.Application;
|
|
|
|
public sealed class InstanceContext : CommunicationObject, IExtensibleObject<InstanceContext>
|
|
{
|
|
internal static InstanceContextEmptyCallback NotifyEmptyCallback = new InstanceContextEmptyCallback(InstanceContext.NotifyEmpty);
|
|
internal static InstanceContextIdleCallback NotifyIdleCallback = new InstanceContextIdleCallback(InstanceContext.NotifyIdle);
|
|
|
|
bool autoClose;
|
|
InstanceBehavior behavior;
|
|
ServiceChannelManager channels;
|
|
ConcurrencyInstanceContextFacet concurrency;
|
|
ExtensionCollection<InstanceContext> extensions;
|
|
readonly ServiceHostBase host;
|
|
QuotaThrottle quotaThrottle;
|
|
ServiceThrottle serviceThrottle;
|
|
int instanceContextManagerIndex;
|
|
object serviceInstanceLock = new object();
|
|
SynchronizationContext synchronizationContext;
|
|
TransactionInstanceContextFacet transaction;
|
|
object userObject;
|
|
bool wellKnown;
|
|
SynchronizedCollection<IChannel> wmiChannels;
|
|
bool isUserCreated;
|
|
|
|
public InstanceContext(object implementation)
|
|
: this(null, implementation)
|
|
{
|
|
}
|
|
|
|
public InstanceContext(ServiceHostBase host, object implementation)
|
|
: this(host, implementation, true)
|
|
{
|
|
}
|
|
|
|
internal InstanceContext(ServiceHostBase host, object implementation, bool isUserCreated)
|
|
: this(host, implementation, true, isUserCreated)
|
|
{
|
|
}
|
|
|
|
internal InstanceContext(ServiceHostBase host, object implementation, bool wellKnown, bool isUserCreated)
|
|
{
|
|
this.host = host;
|
|
if (implementation != null)
|
|
{
|
|
this.userObject = implementation;
|
|
this.wellKnown = wellKnown;
|
|
}
|
|
this.autoClose = false;
|
|
this.channels = new ServiceChannelManager(this);
|
|
this.isUserCreated = isUserCreated;
|
|
}
|
|
|
|
public InstanceContext(ServiceHostBase host)
|
|
: this(host, true)
|
|
{
|
|
}
|
|
|
|
internal InstanceContext(ServiceHostBase host, bool isUserCreated)
|
|
{
|
|
if (host == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("host"));
|
|
}
|
|
|
|
this.host = host;
|
|
this.autoClose = true;
|
|
this.channels = new ServiceChannelManager(this, NotifyEmptyCallback);
|
|
this.isUserCreated = isUserCreated;
|
|
}
|
|
|
|
internal bool IsUserCreated
|
|
{
|
|
get { return this.isUserCreated; }
|
|
set { this.isUserCreated = value; }
|
|
}
|
|
|
|
internal bool IsWellKnown
|
|
{
|
|
get { return this.wellKnown; }
|
|
}
|
|
|
|
internal bool AutoClose
|
|
{
|
|
get { return this.autoClose; }
|
|
set { this.autoClose = value; }
|
|
}
|
|
|
|
internal InstanceBehavior Behavior
|
|
{
|
|
get { return this.behavior; }
|
|
set
|
|
{
|
|
if (this.behavior == null)
|
|
{
|
|
this.behavior = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal ConcurrencyInstanceContextFacet Concurrency
|
|
{
|
|
get
|
|
{
|
|
if (this.concurrency == null)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.concurrency == null)
|
|
this.concurrency = new ConcurrencyInstanceContextFacet();
|
|
}
|
|
}
|
|
|
|
return this.concurrency;
|
|
}
|
|
}
|
|
|
|
internal static InstanceContext Current
|
|
{
|
|
get { return OperationContext.Current != null ? OperationContext.Current.InstanceContext : null; }
|
|
}
|
|
|
|
protected override TimeSpan DefaultCloseTimeout
|
|
{
|
|
get
|
|
{
|
|
if (this.host != null)
|
|
{
|
|
return this.host.CloseTimeout;
|
|
}
|
|
else
|
|
{
|
|
return ServiceDefaults.CloseTimeout;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override TimeSpan DefaultOpenTimeout
|
|
{
|
|
get
|
|
{
|
|
if (this.host != null)
|
|
{
|
|
return this.host.OpenTimeout;
|
|
}
|
|
else
|
|
{
|
|
return ServiceDefaults.OpenTimeout;
|
|
}
|
|
}
|
|
}
|
|
|
|
public IExtensionCollection<InstanceContext> Extensions
|
|
{
|
|
get
|
|
{
|
|
this.ThrowIfClosed();
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.extensions == null)
|
|
this.extensions = new ExtensionCollection<InstanceContext>(this, this.ThisLock);
|
|
return this.extensions;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal bool HasTransaction
|
|
{
|
|
get { return (this.transaction != null) && !object.Equals(this.transaction.Attached, null); }
|
|
}
|
|
|
|
public ICollection<IChannel> IncomingChannels
|
|
{
|
|
get
|
|
{
|
|
this.ThrowIfClosed();
|
|
return channels.IncomingChannels;
|
|
}
|
|
}
|
|
|
|
bool IsBusy
|
|
{
|
|
get
|
|
{
|
|
if (this.State == CommunicationState.Closed)
|
|
return false;
|
|
return this.channels.IsBusy;
|
|
}
|
|
}
|
|
|
|
bool IsSingleton
|
|
{
|
|
get
|
|
{
|
|
return ((this.behavior != null) &&
|
|
InstanceContextProviderBase.IsProviderSingleton(this.behavior.InstanceContextProvider));
|
|
}
|
|
}
|
|
|
|
public ICollection<IChannel> OutgoingChannels
|
|
{
|
|
get
|
|
{
|
|
this.ThrowIfClosed();
|
|
return channels.OutgoingChannels;
|
|
}
|
|
}
|
|
|
|
public ServiceHostBase Host
|
|
{
|
|
get
|
|
{
|
|
this.ThrowIfClosed();
|
|
return this.host;
|
|
}
|
|
}
|
|
|
|
public int ManualFlowControlLimit
|
|
{
|
|
get { return this.EnsureQuotaThrottle().Limit; }
|
|
set { this.EnsureQuotaThrottle().SetLimit(value); }
|
|
}
|
|
|
|
internal QuotaThrottle QuotaThrottle
|
|
{
|
|
get { return this.quotaThrottle; }
|
|
}
|
|
|
|
internal ServiceThrottle ServiceThrottle
|
|
{
|
|
get { return this.serviceThrottle; }
|
|
set
|
|
{
|
|
this.ThrowIfDisposed();
|
|
this.serviceThrottle = value;
|
|
}
|
|
}
|
|
|
|
internal int InstanceContextManagerIndex
|
|
{
|
|
get { return this.instanceContextManagerIndex; }
|
|
set { this.instanceContextManagerIndex = value; }
|
|
}
|
|
|
|
public SynchronizationContext SynchronizationContext
|
|
{
|
|
get { return this.synchronizationContext; }
|
|
set
|
|
{
|
|
this.ThrowIfClosedOrOpened();
|
|
this.synchronizationContext = value;
|
|
}
|
|
}
|
|
|
|
new internal object ThisLock
|
|
{
|
|
get { return base.ThisLock; }
|
|
}
|
|
|
|
internal TransactionInstanceContextFacet Transaction
|
|
{
|
|
get
|
|
{
|
|
if (this.transaction == null)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.transaction == null)
|
|
this.transaction = new TransactionInstanceContextFacet(this);
|
|
}
|
|
}
|
|
|
|
return this.transaction;
|
|
}
|
|
}
|
|
|
|
internal object UserObject
|
|
{
|
|
get { return this.userObject; }
|
|
}
|
|
|
|
internal ICollection<IChannel> WmiChannels
|
|
{
|
|
get
|
|
{
|
|
if (this.wmiChannels == null)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.wmiChannels == null)
|
|
{
|
|
this.wmiChannels = new SynchronizedCollection<IChannel>();
|
|
}
|
|
}
|
|
}
|
|
return this.wmiChannels;
|
|
}
|
|
}
|
|
|
|
protected override void OnAbort()
|
|
{
|
|
channels.Abort();
|
|
this.Unload();
|
|
}
|
|
|
|
internal IAsyncResult BeginCloseInput(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return channels.BeginCloseInput(timeout, callback, state);
|
|
}
|
|
|
|
internal void BindRpc(ref MessageRpc rpc)
|
|
{
|
|
this.ThrowIfClosed();
|
|
this.channels.IncrementActivityCount();
|
|
rpc.SuccessfullyBoundInstance = true;
|
|
}
|
|
|
|
internal void BindIncomingChannel(ServiceChannel channel)
|
|
{
|
|
this.ThrowIfDisposed();
|
|
|
|
channel.InstanceContext = this;
|
|
IChannel proxy = (IChannel)channel.Proxy;
|
|
this.channels.AddIncomingChannel(proxy);
|
|
|
|
// CSDMain 265783: Memory Leak on Chat Stress test scenario
|
|
// There's a race condition while on one thread we received a new request from underlying sessionful channel
|
|
// and on another thread we just aborted the channel. So the channel will be added to the IncomingChannels list of
|
|
// ServiceChannelManager and never get a chance to be removed.
|
|
if (proxy != null)
|
|
{
|
|
CommunicationState state = channel.State;
|
|
if (state == CommunicationState.Closing
|
|
|| state == CommunicationState.Closed
|
|
|| state == CommunicationState.Faulted)
|
|
{
|
|
this.channels.RemoveChannel(proxy);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CloseIfNotBusy()
|
|
{
|
|
if (!(this.State != CommunicationState.Created && this.State != CommunicationState.Opening))
|
|
{
|
|
Fx.Assert("InstanceContext.CloseIfNotBusy: (this.State != CommunicationState.Created && this.State != CommunicationState.Opening)");
|
|
}
|
|
|
|
if (this.State != CommunicationState.Opened)
|
|
return;
|
|
|
|
if (this.IsBusy)
|
|
return;
|
|
|
|
if (this.behavior.CanUnload(this) == false)
|
|
return;
|
|
|
|
try
|
|
{
|
|
if (this.State == CommunicationState.Opened)
|
|
this.Close();
|
|
}
|
|
catch (ObjectDisposedException e)
|
|
{
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
|
|
}
|
|
catch (InvalidOperationException e)
|
|
{
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
|
|
}
|
|
catch (CommunicationException e)
|
|
{
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
|
|
}
|
|
catch (TimeoutException e)
|
|
{
|
|
if (TD.CloseTimeoutIsEnabled())
|
|
{
|
|
TD.CloseTimeout(e.Message);
|
|
}
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
|
|
}
|
|
}
|
|
|
|
internal void CloseInput(TimeSpan timeout)
|
|
{
|
|
channels.CloseInput(timeout);
|
|
}
|
|
|
|
internal void EndCloseInput(IAsyncResult result)
|
|
{
|
|
channels.EndCloseInput(result);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|
internal void CompleteAttachedTransaction()
|
|
{
|
|
Exception error = null;
|
|
|
|
if (!this.behavior.TransactionAutoCompleteOnSessionClose)
|
|
{
|
|
error = new Exception();
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
TraceUtility.TraceEvent(TraceEventType.Information,
|
|
TraceCode.TxCompletionStatusAbortedOnSessionClose,
|
|
SR.GetString(SR.TraceCodeTxCompletionStatusAbortedOnSessionClose,
|
|
transaction.Attached.TransactionInformation.LocalIdentifier)
|
|
);
|
|
|
|
}
|
|
else if (DiagnosticUtility.ShouldTraceInformation)
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Information,
|
|
TraceCode.TxCompletionStatusCompletedForTACOSC,
|
|
SR.GetString(SR.TraceCodeTxCompletionStatusCompletedForTACOSC,
|
|
transaction.Attached.TransactionInformation.LocalIdentifier)
|
|
);
|
|
}
|
|
|
|
transaction.CompletePendingTransaction(transaction.Attached, error);
|
|
transaction.Attached = null;
|
|
}
|
|
|
|
QuotaThrottle EnsureQuotaThrottle()
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.quotaThrottle == null)
|
|
{
|
|
this.quotaThrottle = new QuotaThrottle(ImmutableDispatchRuntime.GotDynamicInstanceContext, this.ThisLock);
|
|
this.quotaThrottle.Owner = "InstanceContext";
|
|
}
|
|
return this.quotaThrottle;
|
|
}
|
|
}
|
|
|
|
internal void FaultInternal()
|
|
{
|
|
this.Fault();
|
|
}
|
|
|
|
public object GetServiceInstance()
|
|
{
|
|
return this.GetServiceInstance(null);
|
|
}
|
|
|
|
public object GetServiceInstance(Message message)
|
|
{
|
|
lock (this.serviceInstanceLock)
|
|
{
|
|
this.ThrowIfClosedOrNotOpen();
|
|
|
|
object current = this.userObject;
|
|
|
|
if (current != null)
|
|
{
|
|
return current;
|
|
}
|
|
|
|
if (this.behavior == null)
|
|
{
|
|
Exception error = new InvalidOperationException(SR.GetString(SR.SFxInstanceNotInitialized));
|
|
if (message != null)
|
|
{
|
|
throw TraceUtility.ThrowHelperError(error, message);
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
|
|
}
|
|
}
|
|
|
|
object newUserObject;
|
|
if (message != null)
|
|
{
|
|
newUserObject = this.behavior.GetInstance(this, message);
|
|
}
|
|
else
|
|
{
|
|
newUserObject = this.behavior.GetInstance(this);
|
|
}
|
|
if (newUserObject != null)
|
|
{
|
|
this.SetUserObject(newUserObject);
|
|
}
|
|
|
|
return newUserObject;
|
|
}
|
|
}
|
|
|
|
public int IncrementManualFlowControlLimit(int incrementBy)
|
|
{
|
|
return this.EnsureQuotaThrottle().IncrementLimit(incrementBy);
|
|
}
|
|
|
|
void Load()
|
|
{
|
|
if (this.behavior != null)
|
|
{
|
|
this.behavior.Initialize(this);
|
|
}
|
|
|
|
if (this.host != null)
|
|
{
|
|
this.host.BindInstance(this);
|
|
}
|
|
}
|
|
|
|
static void NotifyEmpty(InstanceContext instanceContext)
|
|
{
|
|
if (instanceContext.autoClose)
|
|
{
|
|
instanceContext.CloseIfNotBusy();
|
|
}
|
|
}
|
|
|
|
static void NotifyIdle(InstanceContext instanceContext)
|
|
{
|
|
instanceContext.CloseIfNotBusy();
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new CloseAsyncResult(timeout, callback, state, this);
|
|
}
|
|
|
|
protected override void OnEndClose(IAsyncResult result)
|
|
{
|
|
CloseAsyncResult.End(result);
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new CompletedAsyncResult(callback, state);
|
|
}
|
|
|
|
protected override void OnEndOpen(IAsyncResult result)
|
|
{
|
|
CompletedAsyncResult.End(result);
|
|
}
|
|
|
|
protected override void OnClose(TimeSpan timeout)
|
|
{
|
|
channels.Close(timeout);
|
|
this.Unload();
|
|
}
|
|
|
|
protected override void OnClosed()
|
|
{
|
|
base.OnClosed();
|
|
|
|
ServiceThrottle throttle = this.serviceThrottle;
|
|
if (throttle != null)
|
|
{
|
|
throttle.DeactivateInstanceContext();
|
|
}
|
|
}
|
|
|
|
protected override void OnFaulted()
|
|
{
|
|
base.OnFaulted();
|
|
|
|
if (this.IsSingleton && (this.host != null))
|
|
{
|
|
this.host.FaultInternal();
|
|
}
|
|
}
|
|
|
|
protected override void OnOpen(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
}
|
|
|
|
protected override void OnOpened()
|
|
{
|
|
base.OnOpened();
|
|
}
|
|
|
|
protected override void OnOpening()
|
|
{
|
|
this.Load();
|
|
base.OnOpening();
|
|
}
|
|
|
|
public void ReleaseServiceInstance()
|
|
{
|
|
this.ThrowIfDisposedOrNotOpen();
|
|
this.SetUserObject(null);
|
|
}
|
|
|
|
void SetUserObject(object newUserObject)
|
|
{
|
|
if (this.behavior != null && !this.wellKnown)
|
|
{
|
|
object oldUserObject = Interlocked.Exchange(ref this.userObject, newUserObject);
|
|
|
|
if ((oldUserObject != null) && (this.host != null) && !Object.Equals(oldUserObject, this.host.DisposableInstance))
|
|
{
|
|
this.behavior.ReleaseInstance(this, oldUserObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void UnbindRpc(ref MessageRpc rpc)
|
|
{
|
|
if (rpc.InstanceContext == this && rpc.SuccessfullyBoundInstance)
|
|
{
|
|
this.channels.DecrementActivityCount();
|
|
}
|
|
}
|
|
|
|
internal void UnbindIncomingChannel(ServiceChannel channel)
|
|
{
|
|
this.channels.RemoveChannel((IChannel)channel.Proxy);
|
|
}
|
|
|
|
void Unload()
|
|
{
|
|
this.SetUserObject(null);
|
|
|
|
if (this.host != null)
|
|
{
|
|
this.host.UnbindInstance(this);
|
|
}
|
|
}
|
|
|
|
class CloseAsyncResult : AsyncResult
|
|
{
|
|
InstanceContext instanceContext;
|
|
TimeoutHelper timeoutHelper;
|
|
|
|
public CloseAsyncResult(TimeSpan timeout, AsyncCallback callback, object state, InstanceContext instanceContext)
|
|
: base(callback, state)
|
|
{
|
|
this.timeoutHelper = new TimeoutHelper(timeout);
|
|
this.instanceContext = instanceContext;
|
|
IAsyncResult result = this.instanceContext.channels.BeginClose(this.timeoutHelper.RemainingTime(), PrepareAsyncCompletion(new AsyncCompletion(CloseChannelsCallback)), this);
|
|
if (result.CompletedSynchronously && CloseChannelsCallback(result))
|
|
{
|
|
base.Complete(true);
|
|
}
|
|
}
|
|
|
|
public static void End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<CloseAsyncResult>(result);
|
|
}
|
|
|
|
bool CloseChannelsCallback(IAsyncResult result)
|
|
{
|
|
Fx.Assert(object.ReferenceEquals(this, result.AsyncState), "AsyncState should be this");
|
|
this.instanceContext.channels.EndClose(result);
|
|
this.instanceContext.Unload();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|