protected override void OnItemAgedOutOfCache(ChannelFactoryRef <TChannel> item) { if (TD.ClientBaseChannelFactoryAgedOutofCacheIsEnabled()) { TD.ClientBaseChannelFactoryAgedOutofCache(this.watermark, this); } }
protected override void OnSingleItemRemoved(ChannelFactoryRef <TChannel> item) { if (item.Release()) { item.Abort(); } }
protected ClientBase(Binding binding, EndpointAddress remoteAddress) { if (binding == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(binding)); } if (remoteAddress == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(remoteAddress)); } MakeCacheSettingReadOnly(); if (s_cacheSetting == CacheSetting.AlwaysOn) { _endpointTrait = new ProgrammaticEndpointTrait <TChannel>(binding, remoteAddress, null); InitializeChannelFactoryRef(); } else { _channelFactoryRef = new ChannelFactoryRef <TChannel>(new ChannelFactory <TChannel>(binding, remoteAddress)); _channelFactoryRef.ChannelFactory.TraceOpenAndClose = false; TryDisableSharing(); } }
void InitializeChannelFactoryRef() { Fx.Assert(_channelFactoryRef == null, "The channelFactory should have never been assigned"); Fx.Assert(_canShareFactory, "GetChannelFactoryFromCache can be called only when canShareFactory is true"); lock (s_staticLock) { ChannelFactoryRef <TChannel> factoryRef; if (s_factoryRefCache.TryGetValue(_endpointTrait, out factoryRef)) { if (factoryRef.ChannelFactory.State != CommunicationState.Opened) { // Remove the bad ChannelFactory. s_factoryRefCache.Remove(_endpointTrait); } else { _channelFactoryRef = factoryRef; _channelFactoryRef.AddRef(); _useCachedFactory = true; if (WcfEventSource.Instance.ClientBaseChannelFactoryCacheHitIsEnabled()) { WcfEventSource.Instance.ClientBaseChannelFactoryCacheHit(this); } return; } } } if (_channelFactoryRef == null) { // Creating the ChannelFactory at initial time to catch configuration exception earlier. _channelFactoryRef = CreateChannelFactoryRef(_endpointTrait); } }
private void TryDisableSharing() { if (!this.sharingFinalized) { lock (this.finalizeLock) { if (!this.sharingFinalized) { this.canShareFactory = false; this.sharingFinalized = true; if (this.useCachedFactory) { ChannelFactoryRef <TChannel> channelFactoryRef = this.channelFactoryRef; this.channelFactoryRef = ClientBase <TChannel> .CreateChannelFactoryRef(this.endpointTrait); this.useCachedFactory = false; lock (ClientBase <TChannel> .staticLock) { if (!channelFactoryRef.Release()) { channelFactoryRef = null; } } if (channelFactoryRef != null) { channelFactoryRef.Abort(); } } } } } }
private void InitializeChannelFactoryRef() { lock (ClientBase <TChannel> .staticLock) { ChannelFactoryRef <TChannel> ref2; if (ClientBase <TChannel> .factoryRefCache.TryGetValue(this.endpointTrait, out ref2)) { if (ref2.ChannelFactory.State != CommunicationState.Opened) { ClientBase <TChannel> .factoryRefCache.Remove(this.endpointTrait); } else { this.channelFactoryRef = ref2; this.channelFactoryRef.AddRef(); this.useCachedFactory = true; return; } } } if (this.channelFactoryRef == null) { this.channelFactoryRef = ClientBase <TChannel> .CreateChannelFactoryRef(this.endpointTrait); } }
protected override void OnItemAgedOutOfCache(ChannelFactoryRef <TChannel> item) { if (WcfEventSource.Instance.ClientBaseChannelFactoryAgedOutofCacheIsEnabled()) { WcfEventSource.Instance.ClientBaseChannelFactoryAgedOutofCache(_watermark, this); } }
protected override void OnSingleItemRemoved(ChannelFactoryRef <TChannel> item) { // Remove from cache. if (item.Release()) { item.Abort(); } if (TD.ClientBaseCachedChannelFactoryCountIsEnabled()) { TD.ClientBaseCachedChannelFactoryCount(this.Count, this.watermark, this); } }
protected ClientBase(ServiceEndpoint endpoint) { this.canShareFactory = true; this.syncRoot = new object(); this.finalizeLock = new object(); if (endpoint == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpoint"); } this.channelFactoryRef = new ChannelFactoryRef <TChannel>(new ChannelFactory <TChannel>(endpoint)); this.channelFactoryRef.ChannelFactory.TraceOpenAndClose = false; this.TryDisableSharing(); }
protected override void OnSingleItemRemoved(ChannelFactoryRef <TChannel> item) { // Remove from cache. if (item.Release()) { item.Abort(); } if (WcfEventSource.Instance.ClientBaseCachedChannelFactoryCountIsEnabled()) { WcfEventSource.Instance.ClientBaseCachedChannelFactoryCount(Count, _watermark, this); } }
// 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 (_sharingFinalized) { return; } lock (finalizeLock) { if (_sharingFinalized) { return; } _canShareFactory = false; _sharingFinalized = true; if (_useCachedFactory) { ChannelFactoryRef <TChannel> pendingFactoryRef = _channelFactoryRef; _channelFactoryRef = CreateChannelFactoryRef(_endpointTrait); _useCachedFactory = false; lock (s_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 (WcfEventSource.Instance.ClientBaseUsingLocalChannelFactoryIsEnabled()) { WcfEventSource.Instance.ClientBaseUsingLocalChannelFactory(this); } }
protected ClientBase(Binding binding, EndpointAddress remoteAddress) { this.canShareFactory = true; this.syncRoot = new object(); this.finalizeLock = new object(); if (binding == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("binding"); } if (remoteAddress == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("remoteAddress"); } this.channelFactoryRef = new ChannelFactoryRef <TChannel>(new ChannelFactory <TChannel>(binding, remoteAddress)); this.channelFactoryRef.ChannelFactory.TraceOpenAndClose = false; this.TryDisableSharing(); }
protected ClientBase(ServiceEndpoint endpoint) { if (endpoint == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(endpoint)); } MakeCacheSettingReadOnly(); if (s_cacheSetting == CacheSetting.AlwaysOn) { _endpointTrait = new ServiceEndpointTrait <TChannel>(endpoint, null); InitializeChannelFactoryRef(); } else { _channelFactoryRef = new ChannelFactoryRef <TChannel>(new ChannelFactory <TChannel>(endpoint)); _channelFactoryRef.ChannelFactory.TraceOpenAndClose = false; TryDisableSharing(); } }