Files
mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/ClientBase.cs
T
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

1545 lines
56 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel
{
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.ServiceModel.Diagnostics;
using System.Threading;
using System.ServiceModel.Diagnostics.Application;
using System.Runtime.Remoting.Messaging;
using System.ServiceModel.Dispatcher;
using System.Security;
public abstract class ClientBase<TChannel> : ICommunicationObject, IDisposable
where TChannel : class
{
TChannel channel;
ChannelFactoryRef<TChannel> channelFactoryRef;
EndpointTrait<TChannel> endpointTrait;
// Determine whether the proxy can share factory with others. It is false only if the public getters
// are invoked.
bool canShareFactory = true;
// Determine whether the proxy is currently holding a cached factory
bool useCachedFactory;
// Determine whether we have locked down sharing for this proxy. This is turned on only when the channel
// is created.
bool sharingFinalized;
// Determine whether the ChannelFactoryRef has been released. We should release it only once per proxy
bool channelFactoryRefReleased;
// Determine whether we have released the last ref count of the ChannelFactory so that we could abort it when it was closing.
bool releasedLastRef;
object syncRoot = new object();
object finalizeLock = new object();
// Cache at most 32 ChannelFactories
const int maxNumChannelFactories = 32;
static ChannelFactoryRefCache<TChannel> factoryRefCache = new ChannelFactoryRefCache<TChannel>(maxNumChannelFactories);
static object staticLock = new object();
static object cacheLock = new object();
static CacheSetting cacheSetting = CacheSetting.Default;
static bool isCacheSettingReadOnly;
static AsyncCallback onAsyncCallCompleted = Fx.ThunkCallback(new AsyncCallback(OnAsyncCallCompleted));
// IMPORTANT: any changes to the set of protected .ctors of this class need to be reflected
// in ServiceContractGenerator.cs as well.
protected ClientBase()
{
MakeCacheSettingReadOnly();
if (cacheSetting == CacheSetting.AlwaysOff)
{
this.channelFactoryRef = new ChannelFactoryRef<TChannel>(new ChannelFactory<TChannel>("*"));
this.channelFactoryRef.ChannelFactory.TraceOpenAndClose = false;
TryDisableSharing();
}
else
{
this.endpointTrait = new ConfigurationEndpointTrait<TChannel>("*", null, null);
InitializeChannelFactoryRef();
}
}
protected ClientBase(string endpointConfigurationName)
{
if (endpointConfigurationName == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointConfigurationName");
MakeCacheSettingReadOnly();
if (cacheSetting == CacheSetting.AlwaysOff)
{
this.channelFactoryRef = new ChannelFactoryRef<TChannel>(new ChannelFactory<TChannel>(endpointConfigurationName));
this.channelFactoryRef.ChannelFactory.TraceOpenAndClose = false;
TryDisableSharing();
}
else
{
this.endpointTrait = new ConfigurationEndpointTrait<TChannel>(endpointConfigurationName, null, null);
InitializeChannelFactoryRef();
}
}
protected ClientBase(string endpointConfigurationName, string remoteAddress)
{
if (endpointConfigurationName == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointConfigurationName");
if (remoteAddress == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("remoteAddress");
MakeCacheSettingReadOnly();
EndpointAddress endpointAddress = new EndpointAddress(remoteAddress);
if (cacheSetting == CacheSetting.AlwaysOff)
{
this.channelFactoryRef = new ChannelFactoryRef<TChannel>(new ChannelFactory<TChannel>(endpointConfigurationName, endpointAddress));
this.channelFactoryRef.ChannelFactory.TraceOpenAndClose = false;
TryDisableSharing();
}
else
{
this.endpointTrait = new ConfigurationEndpointTrait<TChannel>(endpointConfigurationName, endpointAddress, null);
InitializeChannelFactoryRef();
}
}
protected ClientBase(string endpointConfigurationName, EndpointAddress remoteAddress)
{
if (endpointConfigurationName == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointConfigurationName");
if (remoteAddress == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("remoteAddress");
MakeCacheSettingReadOnly();
if (cacheSetting == CacheSetting.AlwaysOff)
{
this.channelFactoryRef = new ChannelFactoryRef<TChannel>(new ChannelFactory<TChannel>(endpointConfigurationName, remoteAddress));
this.channelFactoryRef.ChannelFactory.TraceOpenAndClose = false;
TryDisableSharing();
}
else
{
this.endpointTrait = new ConfigurationEndpointTrait<TChannel>(endpointConfigurationName, remoteAddress, null);
InitializeChannelFactoryRef();
}
}
protected ClientBase(Binding binding, EndpointAddress remoteAddress)
{
if (binding == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("binding");
if (remoteAddress == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("remoteAddress");
MakeCacheSettingReadOnly();
if (cacheSetting == CacheSetting.AlwaysOn)
{
this.endpointTrait = new ProgrammaticEndpointTrait<TChannel>(binding, remoteAddress, null);
InitializeChannelFactoryRef();
}
else
{
this.channelFactoryRef = new ChannelFactoryRef<TChannel>(new ChannelFactory<TChannel>(binding, remoteAddress));
this.channelFactoryRef.ChannelFactory.TraceOpenAndClose = false;
TryDisableSharing();
}
}
protected ClientBase(ServiceEndpoint endpoint)
{
if (endpoint == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpoint");
MakeCacheSettingReadOnly();
if (cacheSetting == CacheSetting.AlwaysOn)
{
this.endpointTrait = new ServiceEndpointTrait<TChannel>(endpoint, null);
this.InitializeChannelFactoryRef();
}
else
{
channelFactoryRef = new ChannelFactoryRef<TChannel>(new ChannelFactory<TChannel>(endpoint));
channelFactoryRef.ChannelFactory.TraceOpenAndClose = false;
TryDisableSharing();
}
}
protected ClientBase(InstanceContext callbackInstance)
{
if (callbackInstance == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("callbackInstance");
MakeCacheSettingReadOnly();
if (cacheSetting == CacheSetting.AlwaysOff)
{
this.channelFactoryRef = new ChannelFactoryRef<TChannel>(
new DuplexChannelFactory<TChannel>(callbackInstance, "*"));
this.channelFactoryRef.ChannelFactory.TraceOpenAndClose = false;
TryDisableSharing();
}
else
{
this.endpointTrait = new ConfigurationEndpointTrait<TChannel>("*", null, callbackInstance);
InitializeChannelFactoryRef();
}
}
protected ClientBase(InstanceContext callbackInstance, string endpointConfigurationName)
{
if (callbackInstance == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("callbackInstance");
if (endpointConfigurationName == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointConfigurationName");
MakeCacheSettingReadOnly();
if (cacheSetting == CacheSetting.AlwaysOff)
{
this.channelFactoryRef = new ChannelFactoryRef<TChannel>(
new DuplexChannelFactory<TChannel>(callbackInstance, endpointConfigurationName));
this.channelFactoryRef.ChannelFactory.TraceOpenAndClose = false;
TryDisableSharing();
}
else
{
this.endpointTrait = new ConfigurationEndpointTrait<TChannel>(endpointConfigurationName, null, callbackInstance);
InitializeChannelFactoryRef();
}
}
protected ClientBase(InstanceContext callbackInstance, string endpointConfigurationName, string remoteAddress)
{
if (callbackInstance == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("callbackInstance");
if (endpointConfigurationName == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointConfigurationName");
if (remoteAddress == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("remoteAddress");
MakeCacheSettingReadOnly();
EndpointAddress endpointAddress = new EndpointAddress(remoteAddress);
if (cacheSetting == CacheSetting.AlwaysOff)
{
this.channelFactoryRef = new ChannelFactoryRef<TChannel>(
new DuplexChannelFactory<TChannel>(callbackInstance, endpointConfigurationName, endpointAddress));
this.channelFactoryRef.ChannelFactory.TraceOpenAndClose = false;
TryDisableSharing();
}
else
{
this.endpointTrait = new ConfigurationEndpointTrait<TChannel>(endpointConfigurationName, endpointAddress, callbackInstance);
InitializeChannelFactoryRef();
}
}
protected ClientBase(InstanceContext callbackInstance, string endpointConfigurationName, EndpointAddress remoteAddress)
{
if (callbackInstance == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("callbackInstance");
if (endpointConfigurationName == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointConfigurationName");
if (remoteAddress == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("remoteAddress");
MakeCacheSettingReadOnly();
if (cacheSetting == CacheSetting.AlwaysOff)
{
this.channelFactoryRef = new ChannelFactoryRef<TChannel>(
new DuplexChannelFactory<TChannel>(callbackInstance, endpointConfigurationName, remoteAddress));
this.channelFactoryRef.ChannelFactory.TraceOpenAndClose = false;
TryDisableSharing();
}
else
{
this.endpointTrait = new ConfigurationEndpointTrait<TChannel>(endpointConfigurationName, remoteAddress, callbackInstance);
InitializeChannelFactoryRef();
}
}
protected ClientBase(InstanceContext callbackInstance, Binding binding, EndpointAddress remoteAddress)
{
if (callbackInstance == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("callbackInstance");
if (binding == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("binding");
if (remoteAddress == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("remoteAddress");
MakeCacheSettingReadOnly();
if (cacheSetting == CacheSetting.AlwaysOn)
{
this.endpointTrait = new ProgrammaticEndpointTrait<TChannel>(binding, remoteAddress, callbackInstance);
InitializeChannelFactoryRef();
}
else
{
this.channelFactoryRef = new ChannelFactoryRef<TChannel>(
new DuplexChannelFactory<TChannel>(callbackInstance, binding, remoteAddress));
this.channelFactoryRef.ChannelFactory.TraceOpenAndClose = false;
TryDisableSharing();
}
}
protected ClientBase(InstanceContext callbackInstance, ServiceEndpoint endpoint)
{
if (callbackInstance == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("callbackInstance");
if (endpoint == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpoint");
MakeCacheSettingReadOnly();
if (cacheSetting == CacheSetting.AlwaysOn)
{
this.endpointTrait = new ServiceEndpointTrait<TChannel>(endpoint, callbackInstance);
InitializeChannelFactoryRef();
}
else
{
this.channelFactoryRef = new ChannelFactoryRef<TChannel>(
new DuplexChannelFactory<TChannel>(callbackInstance, endpoint));
this.channelFactoryRef.ChannelFactory.TraceOpenAndClose = false;
TryDisableSharing();
}
}
protected T GetDefaultValueForInitialization<T>()
{
return default(T);
}
object ThisLock
{
get
{
return syncRoot;
}
}
protected TChannel Channel
{
get
{
// created on demand, so that Mort can modify .Endpoint before calling methods on the client
if (this.channel == null)
{
lock (ThisLock)
{
if (this.channel == null)
{
using (ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.CreateBoundedActivity() : null)
{
if (DiagnosticUtility.ShouldUseActivity)
{
ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityOpenClientBase, typeof(TChannel).FullName), ActivityType.OpenClient);
}
if (this.useCachedFactory)
{
try
{
CreateChannelInternal();
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception ex)
{
if (this.useCachedFactory &&
(ex is CommunicationException ||
ex is ObjectDisposedException ||
ex is TimeoutException))
{
DiagnosticUtility.TraceHandledException(ex, TraceEventType.Warning);
InvalidateCacheAndCreateChannel();
}
else
{
#pragma warning suppress 56503 // [....], We throw only for unknown exceptions.
throw;
}
}
}
else
{
CreateChannelInternal();
}
}
}
}
}
return channel;
}
}
public static CacheSetting CacheSetting
{
get
{
return cacheSetting;
}
set
{
lock (cacheLock)
{
if (isCacheSettingReadOnly && cacheSetting != value)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxImmutableClientBaseCacheSetting, typeof(TChannel).ToString())));
}
else
{
cacheSetting = value;
}
}
}
}
public ChannelFactory<TChannel> ChannelFactory
{
get
{
if (cacheSetting == CacheSetting.Default)
{
TryDisableSharing();
}
return GetChannelFactory();
}
}
public ClientCredentials ClientCredentials
{
get
{
if (cacheSetting == CacheSetting.Default)
{
TryDisableSharing();
}
return this.ChannelFactory.Credentials;
}
}
public CommunicationState State
{
get
{
IChannel channel = (IChannel)this.channel;
if (channel != null)
{
return channel.State;
}
else
{
// we may have failed to create the channel under open, in which case we our factory wouldn't be open
if (!this.useCachedFactory)
{
return GetChannelFactory().State;
}
else
{
return CommunicationState.Created;
}
}
}
}
public IClientChannel InnerChannel
{
get
{
return (IClientChannel)Channel;
}
}
public ServiceEndpoint Endpoint
{
get
{
if (cacheSetting == CacheSetting.Default)
{
TryDisableSharing();
}
return GetChannelFactory().Endpoint;
}
}
public void Open()
{
((ICommunicationObject)this).Open(GetChannelFactory().InternalOpenTimeout);
}
public void Abort()
{
IChannel channel = (IChannel)this.channel;
if (channel != null)
{
channel.Abort();
}
if (!channelFactoryRefReleased)
{
lock (staticLock)
{
if (!channelFactoryRefReleased)
{
if (this.channelFactoryRef.Release())
{
this.releasedLastRef = true;
}
channelFactoryRefReleased = true;
}
}
}
// Abort the ChannelFactory if we released the last one. We should be able to abort it when another thread is closing it.
if (this.releasedLastRef)
{
this.channelFactoryRef.Abort();
}
}
public void Close()
{
((ICommunicationObject)this).Close(GetChannelFactory().InternalCloseTimeout);
}
public void DisplayInitializationUI()
{
((IClientChannel)this.InnerChannel).DisplayInitializationUI();
}
// This ensures that the cachesetting (on, off or default) cannot be modified by
// another ClientBase instance of matching TChannel after the first instance is created.
void MakeCacheSettingReadOnly()
{
if (isCacheSettingReadOnly)
return;
lock (cacheLock)
{
isCacheSettingReadOnly = true;
}
}
void CreateChannelInternal()
{
try
{
this.channel = this.CreateChannel();
if (this.sharingFinalized)
{
if (this.canShareFactory && !this.useCachedFactory)
{
// It is OK to add ChannelFactory to the cache now.
TryAddChannelFactoryToCache();
}
}
}
finally
{
if (!this.sharingFinalized && cacheSetting == CacheSetting.Default)
{
// this.CreateChannel() is not called. For safety, we disable sharing.
TryDisableSharing();
}
}
}
protected virtual TChannel CreateChannel()
{
if (this.sharingFinalized)
return GetChannelFactory().CreateChannel();
lock (this.finalizeLock)
{
this.sharingFinalized = true;
return GetChannelFactory().CreateChannel();
}
}
void IDisposable.Dispose()
{
this.Close();
}
void ICommunicationObject.Open(TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
if (!this.useCachedFactory)
{
GetChannelFactory().Open(timeoutHelper.RemainingTime());
}
this.InnerChannel.Open(timeoutHelper.RemainingTime());
}
void ICommunicationObject.Close(TimeSpan timeout)
{
using (ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.CreateBoundedActivity() : null)
{
if (DiagnosticUtility.ShouldUseActivity)
{
ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityCloseClientBase, typeof(TChannel).FullName), ActivityType.Close);
}
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
if (this.channel != null)
{
InnerChannel.Close(timeoutHelper.RemainingTime());
}
if (!channelFactoryRefReleased)
{
lock (staticLock)
{
if (!channelFactoryRefReleased)
{
if (this.channelFactoryRef.Release())
{
this.releasedLastRef = true;
}
this.channelFactoryRefReleased = true;
}
}
// Close the factory outside of the lock so that we can abort from a different thread.
if (this.releasedLastRef)
{
if (this.useCachedFactory)
{
this.channelFactoryRef.Abort();
}
else
{
this.channelFactoryRef.Close(timeoutHelper.RemainingTime());
}
}
}
}
}
event EventHandler ICommunicationObject.Closed
{
add
{
this.InnerChannel.Closed += value;
}
remove
{
this.InnerChannel.Closed -= value;
}
}
event EventHandler ICommunicationObject.Closing
{
add
{
this.InnerChannel.Closing += value;
}
remove
{
this.InnerChannel.Closing -= value;
}
}
event EventHandler ICommunicationObject.Faulted
{
add
{
this.InnerChannel.Faulted += value;
}
remove
{
this.InnerChannel.Faulted -= value;
}
}
event EventHandler ICommunicationObject.Opened
{
add
{
this.InnerChannel.Opened += value;
}
remove
{
this.InnerChannel.Opened -= value;
}
}
event EventHandler ICommunicationObject.Opening
{
add
{
this.InnerChannel.Opening += value;
}
remove
{
this.InnerChannel.Opening -= value;
}
}
IAsyncResult ICommunicationObject.BeginClose(AsyncCallback callback, object state)
{
return ((ICommunicationObject)this).BeginClose(GetChannelFactory().InternalCloseTimeout, callback, state);
}
IAsyncResult ICommunicationObject.BeginClose(TimeSpan timeout, AsyncCallback callback, object state)
{
return new ChainedAsyncResult(timeout, callback, state, BeginChannelClose, EndChannelClose, BeginFactoryClose, EndFactoryClose);
}
void ICommunicationObject.EndClose(IAsyncResult result)
{
ChainedAsyncResult.End(result);
}
IAsyncResult ICommunicationObject.BeginOpen(AsyncCallback callback, object state)
{
return ((ICommunicationObject)this).BeginOpen(GetChannelFactory().InternalOpenTimeout, callback, state);
}
IAsyncResult ICommunicationObject.BeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
{
return new ChainedAsyncResult(timeout, callback, state, BeginFactoryOpen, EndFactoryOpen, BeginChannelOpen, EndChannelOpen);
}
void ICommunicationObject.EndOpen(IAsyncResult result)
{
ChainedAsyncResult.End(result);
}
//ChainedAsyncResult methods for opening and closing ChannelFactory<T>
internal IAsyncResult BeginFactoryOpen(TimeSpan timeout, AsyncCallback callback, object state)
{
if (this.useCachedFactory)
{
return new CompletedAsyncResult(callback, state);
}
else
{
return GetChannelFactory().BeginOpen(timeout, callback, state);
}
}
internal void EndFactoryOpen(IAsyncResult result)
{
if (this.useCachedFactory)
{
CompletedAsyncResult.End(result);
}
else
{
GetChannelFactory().EndOpen(result);
}
}
internal IAsyncResult BeginChannelOpen(TimeSpan timeout, AsyncCallback callback, object state)
{
return this.InnerChannel.BeginOpen(timeout, callback, state);
}
internal void EndChannelOpen(IAsyncResult result)
{
this.InnerChannel.EndOpen(result);
}
internal IAsyncResult BeginFactoryClose(TimeSpan timeout, AsyncCallback callback, object state)
{
if (this.useCachedFactory)
{
return new CompletedAsyncResult(callback, state);
}
else
{
return GetChannelFactory().BeginClose(timeout, callback, state);
}
}
internal void EndFactoryClose(IAsyncResult result)
{
if (typeof(CompletedAsyncResult).IsAssignableFrom(result.GetType()))
{
CompletedAsyncResult.End(result);
}
else
{
GetChannelFactory().EndClose(result);
}
}
internal IAsyncResult BeginChannelClose(TimeSpan timeout, AsyncCallback callback, object state)
{
if (this.channel != null)
{
return this.InnerChannel.BeginClose(timeout, callback, state);
}
else
{
return new CompletedAsyncResult(callback, state);
}
}
internal void EndChannelClose(IAsyncResult result)
{
if (typeof(CompletedAsyncResult).IsAssignableFrom(result.GetType()))
{
CompletedAsyncResult.End(result);
}
else
{
this.InnerChannel.EndClose(result);
}
}
ChannelFactory<TChannel> GetChannelFactory()
{
return this.channelFactoryRef.ChannelFactory;
}
void InitializeChannelFactoryRef()
{
Fx.Assert(this.channelFactoryRef == null, "The channelFactory should have never been assigned");
Fx.Assert(this.canShareFactory, "GetChannelFactoryFromCache can be called only when canShareFactory is true");
lock (staticLock)
{
ChannelFactoryRef<TChannel> factoryRef;
if (factoryRefCache.TryGetValue(this.endpointTrait, out factoryRef))
{
if (factoryRef.ChannelFactory.State != CommunicationState.Opened)
{
// Remove the bad ChannelFactory.
factoryRefCache.Remove(this.endpointTrait);
}
else
{
this.channelFactoryRef = factoryRef;
this.channelFactoryRef.AddRef();
useCachedFactory = true;
if (TD.ClientBaseChannelFactoryCacheHitIsEnabled())
{
TD.ClientBaseChannelFactoryCacheHit(this);
}
return;
}
}
}
if (this.channelFactoryRef == null)
{
// Creating the ChannelFactory at initial time to catch configuration exception earlier.
this.channelFactoryRef = CreateChannelFactoryRef(this.endpointTrait);
}
}
static ChannelFactoryRef<TChannel> CreateChannelFactoryRef(EndpointTrait<TChannel> endpointTrait)
{
Fx.Assert(endpointTrait != null, "The endpointTrait should not be null when the factory can be shared.");
ChannelFactory<TChannel> channelFactory = endpointTrait.CreateChannelFactory();
channelFactory.TraceOpenAndClose = false;
return new ChannelFactoryRef<TChannel>(channelFactory);
}
// Once the channel is created, we can't disable caching.
// This method can be called safely multiple times.
// this.sharingFinalized is set the first time the method is called.
// Subsequent calls are essentially no-ops.
void TryDisableSharing()
{
if (this.sharingFinalized)
return;
lock (this.finalizeLock)
{
if (this.sharingFinalized)
return;
this.canShareFactory = false;
this.sharingFinalized = true;
if (this.useCachedFactory)
{
ChannelFactoryRef<TChannel> pendingFactoryRef = this.channelFactoryRef;
this.channelFactoryRef = CreateChannelFactoryRef(this.endpointTrait);
this.useCachedFactory = false;
lock (staticLock)
{
if (!pendingFactoryRef.Release())
{
pendingFactoryRef = null;
}
}
if (pendingFactoryRef != null)
pendingFactoryRef.Abort();
}
}
// can be done outside the lock since the lines below do not access shared data.
// also the use of this.sharingFinalized in the lines above ensures that tracing
// happens only once and only when needed.
if (TD.ClientBaseUsingLocalChannelFactoryIsEnabled())
{
TD.ClientBaseUsingLocalChannelFactory(this);
}
}
void TryAddChannelFactoryToCache()
{
Fx.Assert(this.canShareFactory, "This should be called only when this proxy can share ChannelFactory.");
Fx.Assert(this.channelFactoryRef.ChannelFactory.State == CommunicationState.Opened,
"The ChannelFactory must be in Opened state for caching.");
// Lock the cache and add the item to synchronize with lookup.
lock (staticLock)
{
ChannelFactoryRef<TChannel> cfRef;
if (!factoryRefCache.TryGetValue(this.endpointTrait, out cfRef))
{
// Increment the ref count before adding to the cache.
this.channelFactoryRef.AddRef();
factoryRefCache.Add(this.endpointTrait, this.channelFactoryRef);
this.useCachedFactory = true;
if (TD.ClientBaseCachedChannelFactoryCountIsEnabled())
{
TD.ClientBaseCachedChannelFactoryCount(factoryRefCache.Count, maxNumChannelFactories, this);
}
}
}
}
// NOTE: This should be called inside ThisLock
void InvalidateCacheAndCreateChannel()
{
RemoveFactoryFromCache();
TryDisableSharing();
CreateChannelInternal();
}
void RemoveFactoryFromCache()
{
lock (staticLock)
{
ChannelFactoryRef<TChannel> factoryRef;
if (factoryRefCache.TryGetValue(this.endpointTrait, out factoryRef))
{
if (object.ReferenceEquals(this.channelFactoryRef, factoryRef))
{
factoryRefCache.Remove(this.endpointTrait);
}
}
}
}
// WARNING: changes in the signature/name of the following delegates must be applied to the
// ClientClassGenerator.cs as well, otherwise the ClientClassGenerator would generate wrong code.
protected delegate IAsyncResult BeginOperationDelegate(object[] inValues, AsyncCallback asyncCallback, object state);
protected delegate object[] EndOperationDelegate(IAsyncResult result);
// WARNING: Any changes in the signature/name of the following type and its ctor must be applied to the
// ClientClassGenerator.cs as well, otherwise the ClientClassGenerator would generate wrong code.
protected class InvokeAsyncCompletedEventArgs : AsyncCompletedEventArgs
{
object[] results;
internal InvokeAsyncCompletedEventArgs(object[] results, Exception error, bool cancelled, object userState)
: base(error, cancelled, userState)
{
this.results = results;
}
public object[] Results
{
get
{
return this.results;
}
}
}
// WARNING: Any changes in the signature/name of the following method ctor must be applied to the
// ClientClassGenerator.cs as well, otherwise the ClientClassGenerator would generate wrong code.
protected void InvokeAsync(BeginOperationDelegate beginOperationDelegate, object[] inValues,
EndOperationDelegate endOperationDelegate, SendOrPostCallback operationCompletedCallback, object userState)
{
if (beginOperationDelegate == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("beginOperationDelegate");
}
if (endOperationDelegate == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endOperationDelegate");
}
AsyncOperation asyncOperation = AsyncOperationManager.CreateOperation(userState);
AsyncOperationContext context = new AsyncOperationContext(asyncOperation, endOperationDelegate, operationCompletedCallback);
Exception error = null;
object[] results = null;
IAsyncResult result = null;
try
{
result = beginOperationDelegate(inValues, onAsyncCallCompleted, context);
if (result.CompletedSynchronously)
{
results = endOperationDelegate(result);
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
error = e;
}
if (error != null || result.CompletedSynchronously) /* result cannot be null if error == null */
{
CompleteAsyncCall(context, results, error);
}
}
static void OnAsyncCallCompleted(IAsyncResult result)
{
if (result.CompletedSynchronously)
{
return;
}
AsyncOperationContext context = (AsyncOperationContext)result.AsyncState;
Exception error = null;
object[] results = null;
try
{
results = context.EndDelegate(result);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
error = e;
}
CompleteAsyncCall(context, results, error);
}
static void CompleteAsyncCall(AsyncOperationContext context, object[] results, Exception error)
{
if (context.CompletionCallback != null)
{
InvokeAsyncCompletedEventArgs e = new InvokeAsyncCompletedEventArgs(results, error, false, context.AsyncOperation.UserSuppliedState);
context.AsyncOperation.PostOperationCompleted(context.CompletionCallback, e);
}
else
{
context.AsyncOperation.OperationCompleted();
}
}
class AsyncOperationContext
{
AsyncOperation asyncOperation;
EndOperationDelegate endDelegate;
SendOrPostCallback completionCallback;
internal AsyncOperationContext(AsyncOperation asyncOperation, EndOperationDelegate endDelegate, SendOrPostCallback completionCallback)
{
this.asyncOperation = asyncOperation;
this.endDelegate = endDelegate;
this.completionCallback = completionCallback;
}
internal AsyncOperation AsyncOperation
{
get
{
return this.asyncOperation;
}
}
internal EndOperationDelegate EndDelegate
{
get
{
return this.endDelegate;
}
}
internal SendOrPostCallback CompletionCallback
{
get
{
return this.completionCallback;
}
}
}
protected class ChannelBase<T> : IClientChannel, IOutputChannel, IRequestChannel, IChannelBaseProxy
where T : class
{
ServiceChannel channel;
System.ServiceModel.Dispatcher.ImmutableClientRuntime runtime;
protected ChannelBase(ClientBase<T> client)
{
if (client.Endpoint.Address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxChannelFactoryEndpointAddressUri)));
}
ChannelFactory<T> cf = client.ChannelFactory;
cf.EnsureOpened(); // to prevent the NullReferenceException that is thrown if the ChannelFactory is not open when cf.ServiceChannelFactory is accessed.
this.channel = cf.ServiceChannelFactory.CreateServiceChannel(client.Endpoint.Address, client.Endpoint.Address.Uri);
this.channel.InstanceContext = cf.CallbackInstance;
this.runtime = this.channel.ClientRuntime.GetRuntime();
}
[Fx.Tag.SecurityNote(Critical = "Accesses the critical IMethodCallMessage interface.",
Safe = "The implementation of IMethodCallMessage is local and is created locally as weell; i.e. not passed in from Remoting.")]
[SecuritySafeCritical]
protected IAsyncResult BeginInvoke(string methodName, object[] args, AsyncCallback callback, object state)
{
object[] inArgs = new object[args.Length + 2];
Array.Copy(args, inArgs, args.Length);
inArgs[inArgs.Length - 2] = callback;
inArgs[inArgs.Length - 1] = state;
IMethodCallMessage methodCall = new MethodCallMessage(inArgs);
ProxyOperationRuntime op = GetOperationByName(methodName);
object[] ins = op.MapAsyncBeginInputs(methodCall, out callback, out state);
return this.channel.BeginCall(op.Action, op.IsOneWay, op, ins, callback, state);
}
[Fx.Tag.SecurityNote(Critical = "Accesses the critical IMethodCallMessage interface.",
Safe = "The implementation of IMethodCallMessage is local and is created locally as weell; i.e. not passed in from Remoting.")]
[SecuritySafeCritical]
protected object EndInvoke(string methodName, object[] args, IAsyncResult result)
{
object[] inArgs = new object[args.Length + 1];
Array.Copy(args, inArgs, args.Length);
inArgs[inArgs.Length - 1] = result;
IMethodCallMessage methodCall = new MethodCallMessage(inArgs);
ProxyOperationRuntime op = GetOperationByName(methodName);
object[] outs;
op.MapAsyncEndInputs(methodCall, out result, out outs);
object ret = this.channel.EndCall(op.Action, outs, result);
object[] retArgs = op.MapAsyncOutputs(methodCall, outs, ref ret);
if (retArgs != null)
{
Fx.Assert(retArgs.Length == inArgs.Length, "retArgs.Length should be equal to inArgs.Length");
Array.Copy(retArgs, args, args.Length);
}
return ret;
}
System.ServiceModel.Dispatcher.ProxyOperationRuntime GetOperationByName(string methodName)
{
ProxyOperationRuntime op = this.runtime.GetOperationByName(methodName);
if (op == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.SFxMethodNotSupported1, methodName)));
}
return op;
}
bool IClientChannel.AllowInitializationUI
{
get { return ((IClientChannel)this.channel).AllowInitializationUI; }
set { ((IClientChannel)this.channel).AllowInitializationUI = value; }
}
bool IClientChannel.DidInteractiveInitialization
{
get { return ((IClientChannel)this.channel).DidInteractiveInitialization; }
}
Uri IClientChannel.Via
{
get { return ((IClientChannel)this.channel).Via; }
}
event EventHandler<UnknownMessageReceivedEventArgs> IClientChannel.UnknownMessageReceived
{
add { ((IClientChannel)this.channel).UnknownMessageReceived += value; }
remove { ((IClientChannel)this.channel).UnknownMessageReceived -= value; }
}
void IClientChannel.DisplayInitializationUI()
{
((IClientChannel)this.channel).DisplayInitializationUI();
}
IAsyncResult IClientChannel.BeginDisplayInitializationUI(AsyncCallback callback, object state)
{
return ((IClientChannel)this.channel).BeginDisplayInitializationUI(callback, state);
}
void IClientChannel.EndDisplayInitializationUI(IAsyncResult result)
{
((IClientChannel)this.channel).EndDisplayInitializationUI(result);
}
bool IContextChannel.AllowOutputBatching
{
get { return ((IContextChannel)this.channel).AllowOutputBatching; }
set { ((IContextChannel)this.channel).AllowOutputBatching = value; }
}
IInputSession IContextChannel.InputSession
{
get { return ((IContextChannel)this.channel).InputSession; }
}
EndpointAddress IContextChannel.LocalAddress
{
get { return ((IContextChannel)this.channel).LocalAddress; }
}
TimeSpan IContextChannel.OperationTimeout
{
get { return ((IContextChannel)this.channel).OperationTimeout; }
set { ((IContextChannel)this.channel).OperationTimeout = value; }
}
IOutputSession IContextChannel.OutputSession
{
get { return ((IContextChannel)this.channel).OutputSession; }
}
EndpointAddress IContextChannel.RemoteAddress
{
get { return ((IContextChannel)this.channel).RemoteAddress; }
}
string IContextChannel.SessionId
{
get { return ((IContextChannel)this.channel).SessionId; }
}
TProperty IChannel.GetProperty<TProperty>()
{
return ((IChannel)this.channel).GetProperty<TProperty>();
}
CommunicationState ICommunicationObject.State
{
get { return ((ICommunicationObject)this.channel).State; }
}
event EventHandler ICommunicationObject.Closed
{
add { ((ICommunicationObject)this.channel).Closed += value; }
remove { ((ICommunicationObject)this.channel).Closed -= value; }
}
event EventHandler ICommunicationObject.Closing
{
add { ((ICommunicationObject)this.channel).Closing += value; }
remove { ((ICommunicationObject)this.channel).Closing -= value; }
}
event EventHandler ICommunicationObject.Faulted
{
add { ((ICommunicationObject)this.channel).Faulted += value; }
remove { ((ICommunicationObject)this.channel).Faulted -= value; }
}
event EventHandler ICommunicationObject.Opened
{
add { ((ICommunicationObject)this.channel).Opened += value; }
remove { ((ICommunicationObject)this.channel).Opened -= value; }
}
event EventHandler ICommunicationObject.Opening
{
add { ((ICommunicationObject)this.channel).Opening += value; }
remove { ((ICommunicationObject)this.channel).Opening -= value; }
}
void ICommunicationObject.Abort()
{
((ICommunicationObject)this.channel).Abort();
}
void ICommunicationObject.Close()
{
((ICommunicationObject)this.channel).Close();
}
void ICommunicationObject.Close(TimeSpan timeout)
{
((ICommunicationObject)this.channel).Close(timeout);
}
IAsyncResult ICommunicationObject.BeginClose(AsyncCallback callback, object state)
{
return ((ICommunicationObject)this.channel).BeginClose(callback, state);
}
IAsyncResult ICommunicationObject.BeginClose(TimeSpan timeout, AsyncCallback callback, object state)
{
return ((ICommunicationObject)this.channel).BeginClose(timeout, callback, state);
}
void ICommunicationObject.EndClose(IAsyncResult result)
{
((ICommunicationObject)this.channel).EndClose(result);
}
void ICommunicationObject.Open()
{
((ICommunicationObject)this.channel).Open();
}
void ICommunicationObject.Open(TimeSpan timeout)
{
((ICommunicationObject)this.channel).Open(timeout);
}
IAsyncResult ICommunicationObject.BeginOpen(AsyncCallback callback, object state)
{
return ((ICommunicationObject)this.channel).BeginOpen(callback, state);
}
IAsyncResult ICommunicationObject.BeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
{
return ((ICommunicationObject)this.channel).BeginOpen(timeout, callback, state);
}
void ICommunicationObject.EndOpen(IAsyncResult result)
{
((ICommunicationObject)this.channel).EndOpen(result);
}
IExtensionCollection<IContextChannel> IExtensibleObject<IContextChannel>.Extensions
{
get { return ((IExtensibleObject<IContextChannel>)this.channel).Extensions; }
}
void IDisposable.Dispose()
{
((IDisposable)this.channel).Dispose();
}
Uri IOutputChannel.Via
{
get { return ((IOutputChannel)this.channel).Via; }
}
EndpointAddress IOutputChannel.RemoteAddress
{
get { return ((IOutputChannel)this.channel).RemoteAddress; }
}
void IOutputChannel.Send(Message message)
{
((IOutputChannel)this.channel).Send(message);
}
void IOutputChannel.Send(Message message, TimeSpan timeout)
{
((IOutputChannel)this.channel).Send(message, timeout);
}
IAsyncResult IOutputChannel.BeginSend(Message message, AsyncCallback callback, object state)
{
return ((IOutputChannel)this.channel).BeginSend(message, callback, state);
}
IAsyncResult IOutputChannel.BeginSend(Message message, TimeSpan timeout, AsyncCallback callback, object state)
{
return ((IOutputChannel)this.channel).BeginSend(message, timeout, callback, state);
}
void IOutputChannel.EndSend(IAsyncResult result)
{
((IOutputChannel)this.channel).EndSend(result);
}
Uri IRequestChannel.Via
{
get { return ((IRequestChannel)this.channel).Via; }
}
EndpointAddress IRequestChannel.RemoteAddress
{
get { return ((IRequestChannel)this.channel).RemoteAddress; }
}
Message IRequestChannel.Request(Message message)
{
return ((IRequestChannel)this.channel).Request(message);
}
Message IRequestChannel.Request(Message message, TimeSpan timeout)
{
return ((IRequestChannel)this.channel).Request(message, timeout);
}
IAsyncResult IRequestChannel.BeginRequest(Message message, AsyncCallback callback, object state)
{
return ((IRequestChannel)this.channel).BeginRequest(message, callback, state);
}
IAsyncResult IRequestChannel.BeginRequest(Message message, TimeSpan timeout, AsyncCallback callback, object state)
{
return ((IRequestChannel)this.channel).BeginRequest(message, timeout, callback, state);
}
Message IRequestChannel.EndRequest(IAsyncResult result)
{
return ((IRequestChannel)this.channel).EndRequest(result);
}
ServiceChannel IChannelBaseProxy.GetServiceChannel()
{
return this.channel;
}
class MethodCallMessage : IMethodCallMessage
{
readonly object[] args;
public MethodCallMessage(object[] args)
{
this.args = args;
}
public object[] Args
{
get { return this.args; }
}
public int ArgCount
{
get { return this.args.Length; }
}
public LogicalCallContext LogicalCallContext
{
get { return null; }
}
public object GetInArg(int argNum)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
public string GetInArgName(int index)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
public int InArgCount
{
get
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
}
public object[] InArgs
{
get { return this.args; }
}
public object GetArg(int argNum)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
public string GetArgName(int index)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
public bool HasVarArgs
{
get
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
}
public Reflection.MethodBase MethodBase
{
get
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
}
public string MethodName
{
get
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
}
public object MethodSignature
{
get
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
}
public string TypeName
{
get
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
}
public string Uri
{
get
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
}
public Collections.IDictionary Properties
{
get
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
}
}
}
}
}