internal override void Register(TransportChannelListener channelListener)
{
AddressTable.RegisterUri(channelListener.Uri, channelListener.HostNameComparisonModeInternal,
(TChannelListener)channelListener);
channelListener.SetMessageReceivedCallback(new Action(OnMessageReceived));
}
public override IList <TransportManager> Select(TransportChannelListener channelListener)
{
bool useIPv4 = (ListenUri.HostNameType != UriHostNameType.IPv6) && Socket.OSSupportsIPv4;
bool useIPv6 = (ListenUri.HostNameType != UriHostNameType.IPv4) && Socket.OSSupportsIPv6;
TcpChannelListener tcpListener = (TcpChannelListener)channelListener;
if (!IsCompatible(tcpListener, useIPv4, useIPv6))
{
return(null);
}
IList <TransportManager> result = new List <TransportManager>();
if (useIPv4)
{
ProcessSelection(tcpListener, IPAddress.Any, UriHostNameType.IPv4,
ref ipv4TransportManager, result);
}
if (useIPv6)
{
ProcessSelection(tcpListener, IPAddress.IPv6Any, UriHostNameType.IPv6,
ref ipv6TransportManager, result);
}
return(result);
}
Task CleanupAsync(TransportChannelListener channelListener, bool aborting, CancellationToken token)
{
Unregister(channelListener);
lock (ThisLock)
{
if (openCount <= 0)
{
throw Fx.AssertAndThrow("Invalid Open/Close state machine.");
}
openCount--;
if (openCount == 0)
{
// Wrap the final close here with transfers.
if (aborting)
{
OnAbort();
return(Task.CompletedTask);
}
else
{
return(OnCloseAsync(token));
}
}
}
return(Task.CompletedTask);
}
TransportManagerContainer(TransportManagerContainer source)
{
listener = source.listener;
tableLock = source.tableLock;
transportManagers = new List <TransportManager>();
for (int i = 0; i < source.transportManagers.Count; i++)
{
transportManagers.Add(source.transportManagers[i]);
}
}
internal async Task OpenAsync(TransportChannelListener channelListener)
{
Register(channelListener);
try
{
using (await ThisLock.TakeLockAsync())
{
if (openCount == 0)
{
await OnOpenAsync();
}
openCount++;
}
}
catch
{
Unregister(channelListener);
throw;
}
}
protected override void OnOpening()
{
base.OnOpening();
transportManagerContainer = listener.GetTransportManagers();
listener = null;
}
public TransportReplyChannelAcceptor(TransportChannelListener listener)
: base(listener)
{
this.listener = listener;
}
public abstract IList <TransportManager> Select(TransportChannelListener factory);
internal override void Unregister(TransportChannelListener channelListener)
{
EnsureRegistered(AddressTable, (TChannelListener)channelListener, channelListener.HostNameComparisonModeInternal);
AddressTable.UnregisterUri(channelListener.Uri, channelListener.HostNameComparisonModeInternal);
channelListener.SetMessageReceivedCallback(null);
}
internal Task CloseAsync(TransportChannelListener channelListener, CancellationToken token)
{
return(CleanupAsync(channelListener, false, token));
}
public TransportManagerContainer(TransportChannelListener listener)
{
this.listener = listener;
tableLock = listener.TransportManagerTable.AsyncLock;
transportManagers = new List <TransportManager>();
}
internal abstract void Unregister(TransportChannelListener channelListener);
internal void Abort(TransportChannelListener channelListener)
{
CleanupAsync(channelListener, true, CancellationToken.None);
}
