private void Cleanup(TransportChannelListener channelListener, TimeSpan timeout, bool aborting)
{
using (ServiceModelActivity.BoundOperation(this.Activity))
{
this.Unregister(channelListener);
}
lock (this.ThisLock)
{
if (this.openCount <= 0)
{
throw Fx.AssertAndThrow("Invalid Open/Close state machine.");
}
this.openCount--;
if (this.openCount == 0)
{
using (ServiceModelActivity.BoundOperation(this.Activity, true))
{
if (aborting)
{
this.OnAbort();
}
else
{
this.OnClose(timeout);
}
}
if (this.Activity != null)
{
this.Activity.Dispose();
}
}
}
}
public override IList <TransportManager> Select(TransportChannelListener channelListener)
{
bool useIPv4 = (this.ListenUri.HostNameType != UriHostNameType.IPv6) && Socket.OSSupportsIPv4;
bool useIPv6 = (this.ListenUri.HostNameType != UriHostNameType.IPv4) && Socket.OSSupportsIPv6;
TcpChannelListener tcpListener = (TcpChannelListener)channelListener;
if (!this.IsCompatible(tcpListener, useIPv4, useIPv6))
{
return(null);
}
IList <TransportManager> result = new List <TransportManager>();
if (useIPv4)
{
this.ProcessSelection(tcpListener, IPAddress.Any, UriHostNameType.IPv4,
ref this.ipv4TransportManager, result);
}
if (useIPv6)
{
this.ProcessSelection(tcpListener, IPAddress.IPv6Any, UriHostNameType.IPv6,
ref this.ipv6TransportManager, result);
}
return(result);
}
internal override void Register(TransportChannelListener channelListener)
{
string method = ((HttpChannelListener)channelListener).Method;
UriPrefixTable <HttpChannelListener> addressTable;
if (!addressTables.TryGetValue(method, out addressTable))
{
lock (ThisLock)
{
if (!addressTables.TryGetValue(method, out addressTable))
{
Dictionary <string, UriPrefixTable <HttpChannelListener> > newAddressTables =
new Dictionary <string, UriPrefixTable <HttpChannelListener> >(addressTables);
addressTable = new UriPrefixTable <HttpChannelListener>();
newAddressTables[method] = addressTable;
addressTables = newAddressTables;
}
}
}
addressTable.RegisterUri(channelListener.Uri,
channelListener.InheritBaseAddressSettings ? hostNameComparisonMode : channelListener.HostNameComparisonModeInternal,
(HttpChannelListener)channelListener);
}
internal override void Register(TransportChannelListener channelListener)
{
AddressTable.RegisterUri(channelListener.Uri, channelListener.HostNameComparisonModeInternal,
(TChannelListener)channelListener);
channelListener.SetMessageReceivedCallback(new Action(OnMessageReceived));
}
TransportManagerContainer(TransportManagerContainer source)
{
this.listener = source.listener;
this.tableLock = source.tableLock;
this.transportManagers = new List <TransportManager>();
for (int i = 0; i < source.transportManagers.Count; i++)
{
this.transportManagers.Add(source.transportManagers[i]);
}
}
IList <TransportManager> ITransportManagerRegistration.Select(TransportChannelListener channelListener)
{
IList <TransportManager> result = null;
if (this.IsCompatible((HttpChannelListener)channelListener))
{
result = new List <TransportManager>();
result.Add(this);
}
return(result);
}
IList <TransportManager> ITransportManagerRegistration.Select(TransportChannelListener channelListener)
{
IList <TransportManager> list = null;
if (this.IsCompatible((HttpChannelListener)channelListener))
{
list = new List <TransportManager> {
this
};
}
return(list);
}
internal override void Unregister(TransportChannelListener channelListener)
{
UriPrefixTable <HttpChannelListener> table;
if (!this.addressTables.TryGetValue(((HttpChannelListener)channelListener).Method, out table))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("ListenerFactoryNotRegistered", new object[] { channelListener.Uri })));
}
System.ServiceModel.HostNameComparisonMode registeredComparisonMode = channelListener.InheritBaseAddressSettings ? this.hostNameComparisonMode : channelListener.HostNameComparisonModeInternal;
TransportManager.EnsureRegistered <HttpChannelListener>(table, (HttpChannelListener)channelListener, registeredComparisonMode);
table.UnregisterUri(channelListener.Uri, registeredComparisonMode);
}
IList <TransportManager> ITransportManagerRegistration.Select(TransportChannelListener channelListener)
{
this.OnSelecting((NamedPipeChannelListener)channelListener);
IList <TransportManager> list = null;
if (this.IsCompatible((NamedPipeChannelListener)channelListener))
{
list = new List <TransportManager> {
this
};
}
return(list);
}
internal override void Unregister(TransportChannelListener channelListener)
{
UriPrefixTable <HttpChannelListener> addressTable;
if (!addressTables.TryGetValue(((HttpChannelListener)channelListener).Method, out addressTable))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(
SR.ListenerFactoryNotRegistered, channelListener.Uri)));
}
HostNameComparisonMode registeredMode = channelListener.InheritBaseAddressSettings ? hostNameComparisonMode : channelListener.HostNameComparisonModeInternal;
EnsureRegistered(addressTable, (HttpChannelListener)channelListener, registeredMode);
addressTable.UnregisterUri(channelListener.Uri, registeredMode);
}
IList <TransportManager> ITransportManagerRegistration.Select(TransportChannelListener channelListener)
{
if (!channelListener.IsScopeIdCompatible(this.hostNameComparisonMode, this.listenUri))
{
return(null);
}
this.OnSelecting((TcpChannelListener)channelListener);
IList <TransportManager> list = null;
if (this.IsCompatible((TcpChannelListener)channelListener))
{
list = new List <TransportManager> {
this
};
}
return(list);
}
internal void Open(TransportChannelListener channelListener)
{
if (DiagnosticUtility.ShouldUseActivity)
{
if (this.activity == null)
{
this.activity = ServiceModelActivity.CreateActivity(true);
if (DiagnosticUtility.ShouldUseActivity)
{
if (null != FxTrace.Trace)
{
FxTrace.Trace.TraceTransfer(this.Activity.Id);
}
ServiceModelActivity.Start(this.Activity, SR.GetString(SR.ActivityListenAt, channelListener.Uri.ToString()), ActivityType.ListenAt);
}
}
channelListener.Activity = this.Activity;
}
using (ServiceModelActivity.BoundOperation(this.Activity))
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.TransportListen,
SR.GetString(SR.TraceCodeTransportListen, channelListener.Uri.ToString()), this);
}
this.Register(channelListener);
try
{
lock (ThisLock)
{
if (openCount == 0)
{
OnOpen();
}
openCount++;
}
}
catch
{
this.Unregister(channelListener);
throw;
}
}
}
internal void Open(TransportChannelListener channelListener)
{
if (DiagnosticUtility.ShouldUseActivity)
{
if (this.activity == null)
{
this.activity = ServiceModelActivity.CreateActivity(true);
if (DiagnosticUtility.ShouldUseActivity)
{
if (FxTrace.Trace != null)
{
FxTrace.Trace.TraceTransfer(this.Activity.Id);
}
ServiceModelActivity.Start(this.Activity, System.ServiceModel.SR.GetString("ActivityListenAt", new object[] { channelListener.Uri.ToString() }), ActivityType.ListenAt);
}
}
channelListener.Activity = this.Activity;
}
using (ServiceModelActivity.BoundOperation(this.Activity))
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, 0x80036, System.ServiceModel.SR.GetString("TraceCodeTransportListen", new object[] { channelListener.Uri.ToString() }), this);
}
this.Register(channelListener);
try
{
lock (this.ThisLock)
{
if (this.openCount == 0)
{
this.OnOpen();
}
this.openCount++;
}
}
catch
{
this.Unregister(channelListener);
throw;
}
}
}
internal override void Register(TransportChannelListener channelListener)
{
UriPrefixTable <HttpChannelListener> table;
string method = ((HttpChannelListener)channelListener).Method;
if (!this.addressTables.TryGetValue(method, out table))
{
lock (base.ThisLock)
{
if (!this.addressTables.TryGetValue(method, out table))
{
Dictionary <string, UriPrefixTable <HttpChannelListener> > dictionary = new Dictionary <string, UriPrefixTable <HttpChannelListener> >(this.addressTables);
table = new UriPrefixTable <HttpChannelListener>();
dictionary[method] = table;
this.addressTables = dictionary;
}
}
}
table.RegisterUri(channelListener.Uri, channelListener.InheritBaseAddressSettings ? this.hostNameComparisonMode : channelListener.HostNameComparisonModeInternal, (HttpChannelListener)channelListener);
}
internal override void Unregister(TransportChannelListener channelListener)
{
TransportManager.EnsureRegistered <TChannelListener>(this.AddressTable, (TChannelListener)channelListener, channelListener.HostNameComparisonModeInternal);
this.AddressTable.UnregisterUri(channelListener.Uri, channelListener.HostNameComparisonModeInternal);
channelListener.SetMessageReceivedCallback(null);
}
internal override void Unregister(TransportChannelListener channelListener)
{
// Nothing to do - we never use the transport manager during normal
// operation.
}
internal override void Register(TransportChannelListener channelListener)
{
channelListener.SetMessageReceivedCallback(new Action(OnMessageReceived));
}
public override IList <TransportManager> Select(TransportChannelListener channelListener)
{
return(this.list);
}
protected override void OnOpening()
{
base.OnOpening();
this.transportManagerContainer = this.listener.GetTransportManagers();
this.listener = null;
}
public TransportReplyChannelAcceptor(TransportChannelListener listener)
: base(listener)
{
this.listener = listener;
}
internal void Close(TransportChannelListener channelListener, TimeSpan timeout)
{
this.Cleanup(channelListener, timeout, false);
}
public TransportManagerContainer(TransportChannelListener listener)
{
this.listener = listener;
this.tableLock = listener.TransportManagerTable;
this.transportManagers = new List <TransportManager>();
}
internal abstract void Unregister(TransportChannelListener channelListener);
internal void Abort(TransportChannelListener channelListener)
{
this.Cleanup(channelListener, TimeSpan.Zero, true);
}
public abstract IList <TransportManager> Select(TransportChannelListener factory);
internal override void Unregister(TransportChannelListener channelListener)
{
}
