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
1049 lines
33 KiB
C#
1049 lines
33 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Runtime;
|
|
using System.Runtime.Diagnostics;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.ServiceModel.Diagnostics.Application;
|
|
using System.Text;
|
|
using System.Transactions;
|
|
|
|
public class ChannelDispatcher : ChannelDispatcherBase
|
|
{
|
|
ThreadSafeMessageFilterTable<EndpointAddress> addressTable;
|
|
string bindingName;
|
|
SynchronizedCollection<IChannelInitializer> channelInitializers;
|
|
CommunicationObjectManager<IChannel> channels;
|
|
EndpointDispatcherCollection endpointDispatchers;
|
|
Collection<IErrorHandler> errorHandlers;
|
|
EndpointDispatcherTable filterTable;
|
|
ServiceHostBase host;
|
|
bool isTransactedReceive;
|
|
bool asynchronousTransactedAcceptEnabled;
|
|
bool receiveContextEnabled;
|
|
readonly IChannelListener listener;
|
|
ListenerHandler listenerHandler;
|
|
int maxTransactedBatchSize;
|
|
MessageVersion messageVersion;
|
|
SynchronizedChannelCollection<IChannel> pendingChannels; // app has not yet seen these.
|
|
bool receiveSynchronously;
|
|
bool sendAsynchronously;
|
|
int maxPendingReceives;
|
|
bool includeExceptionDetailInFaults;
|
|
ServiceThrottle serviceThrottle;
|
|
bool session;
|
|
SharedRuntimeState shared;
|
|
IDefaultCommunicationTimeouts timeouts;
|
|
IsolationLevel transactionIsolationLevel = ServiceBehaviorAttribute.DefaultIsolationLevel;
|
|
bool transactionIsolationLevelSet;
|
|
TimeSpan transactionTimeout;
|
|
bool performDefaultCloseInput;
|
|
EventTraceActivity eventTraceActivity;
|
|
ErrorBehavior errorBehavior;
|
|
|
|
internal ChannelDispatcher(SharedRuntimeState shared)
|
|
{
|
|
this.Initialize(shared);
|
|
}
|
|
|
|
public ChannelDispatcher(IChannelListener listener)
|
|
: this(listener, null, null)
|
|
{
|
|
}
|
|
|
|
public ChannelDispatcher(IChannelListener listener, string bindingName)
|
|
: this(listener, bindingName, null)
|
|
{
|
|
}
|
|
|
|
public ChannelDispatcher(IChannelListener listener, string bindingName, IDefaultCommunicationTimeouts timeouts)
|
|
{
|
|
if (listener == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("listener");
|
|
}
|
|
|
|
this.listener = listener;
|
|
this.bindingName = bindingName;
|
|
this.timeouts = new ImmutableCommunicationTimeouts(timeouts);
|
|
|
|
this.session = ((listener is IChannelListener<IInputSessionChannel>) ||
|
|
(listener is IChannelListener<IReplySessionChannel>) ||
|
|
(listener is IChannelListener<IDuplexSessionChannel>));
|
|
|
|
this.Initialize(new SharedRuntimeState(true));
|
|
}
|
|
|
|
void Initialize(SharedRuntimeState shared)
|
|
{
|
|
this.shared = shared;
|
|
this.endpointDispatchers = new EndpointDispatcherCollection(this);
|
|
this.channelInitializers = this.NewBehaviorCollection<IChannelInitializer>();
|
|
this.channels = new CommunicationObjectManager<IChannel>(this.ThisLock);
|
|
this.pendingChannels = new SynchronizedChannelCollection<IChannel>(this.ThisLock);
|
|
this.errorHandlers = new Collection<IErrorHandler>();
|
|
this.isTransactedReceive = false;
|
|
this.asynchronousTransactedAcceptEnabled = false;
|
|
this.receiveSynchronously = false;
|
|
this.serviceThrottle = null;
|
|
this.transactionTimeout = TimeSpan.Zero;
|
|
this.maxPendingReceives = MultipleReceiveBinder.MultipleReceiveDefaults.MaxPendingReceives;
|
|
if (this.listener != null)
|
|
{
|
|
this.listener.Faulted += new EventHandler(OnListenerFaulted);
|
|
}
|
|
}
|
|
|
|
public string BindingName
|
|
{
|
|
get { return this.bindingName; }
|
|
}
|
|
|
|
public SynchronizedCollection<IChannelInitializer> ChannelInitializers
|
|
{
|
|
get { return this.channelInitializers; }
|
|
}
|
|
|
|
protected override TimeSpan DefaultCloseTimeout
|
|
{
|
|
get
|
|
{
|
|
if (this.timeouts != null)
|
|
{
|
|
return this.timeouts.CloseTimeout;
|
|
}
|
|
else
|
|
{
|
|
return ServiceDefaults.CloseTimeout;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override TimeSpan DefaultOpenTimeout
|
|
{
|
|
get
|
|
{
|
|
if (this.timeouts != null)
|
|
{
|
|
return this.timeouts.OpenTimeout;
|
|
}
|
|
else
|
|
{
|
|
return ServiceDefaults.OpenTimeout;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal EndpointDispatcherTable EndpointDispatcherTable
|
|
{
|
|
get { return this.filterTable; }
|
|
}
|
|
|
|
internal CommunicationObjectManager<IChannel> Channels
|
|
{
|
|
get { return this.channels; }
|
|
}
|
|
|
|
public SynchronizedCollection<EndpointDispatcher> Endpoints
|
|
{
|
|
get { return this.endpointDispatchers; }
|
|
}
|
|
|
|
public Collection<IErrorHandler> ErrorHandlers
|
|
{
|
|
get { return this.errorHandlers; }
|
|
}
|
|
|
|
public MessageVersion MessageVersion
|
|
{
|
|
get { return this.messageVersion; }
|
|
set
|
|
{
|
|
this.messageVersion = value;
|
|
this.ThrowIfDisposedOrImmutable();
|
|
}
|
|
}
|
|
|
|
internal bool Session
|
|
{
|
|
get { return this.session; }
|
|
}
|
|
|
|
public override ServiceHostBase Host
|
|
{
|
|
get { return this.host; }
|
|
}
|
|
|
|
internal bool EnableFaults
|
|
{
|
|
get { return this.shared.EnableFaults; }
|
|
set
|
|
{
|
|
this.ThrowIfDisposedOrImmutable();
|
|
this.shared.EnableFaults = value;
|
|
}
|
|
}
|
|
|
|
internal bool IsOnServer
|
|
{
|
|
get { return this.shared.IsOnServer; }
|
|
}
|
|
|
|
public bool IsTransactedAccept
|
|
{
|
|
get { return this.isTransactedReceive && this.session; }
|
|
}
|
|
|
|
public bool IsTransactedReceive
|
|
{
|
|
get
|
|
{
|
|
return this.isTransactedReceive;
|
|
}
|
|
set
|
|
{
|
|
this.ThrowIfDisposedOrImmutable();
|
|
this.isTransactedReceive = value;
|
|
}
|
|
}
|
|
|
|
public bool AsynchronousTransactedAcceptEnabled
|
|
{
|
|
get
|
|
{
|
|
return this.asynchronousTransactedAcceptEnabled;
|
|
}
|
|
set
|
|
{
|
|
this.ThrowIfDisposedOrImmutable();
|
|
this.asynchronousTransactedAcceptEnabled = value;
|
|
}
|
|
}
|
|
|
|
public bool ReceiveContextEnabled
|
|
{
|
|
get
|
|
{
|
|
return this.receiveContextEnabled;
|
|
}
|
|
set
|
|
{
|
|
this.ThrowIfDisposedOrImmutable();
|
|
this.receiveContextEnabled = value;
|
|
}
|
|
}
|
|
|
|
internal bool BufferedReceiveEnabled
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public override IChannelListener Listener
|
|
{
|
|
get { return this.listener; }
|
|
}
|
|
|
|
public int MaxTransactedBatchSize
|
|
{
|
|
get
|
|
{
|
|
return this.maxTransactedBatchSize;
|
|
}
|
|
set
|
|
{
|
|
if (value < 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
|
|
SR.GetString(SR.ValueMustBeNonNegative)));
|
|
}
|
|
|
|
this.ThrowIfDisposedOrImmutable();
|
|
this.maxTransactedBatchSize = value;
|
|
}
|
|
}
|
|
|
|
public ServiceThrottle ServiceThrottle
|
|
{
|
|
get
|
|
{
|
|
return this.serviceThrottle;
|
|
}
|
|
set
|
|
{
|
|
this.ThrowIfDisposedOrImmutable();
|
|
this.serviceThrottle = value;
|
|
}
|
|
}
|
|
|
|
public bool ManualAddressing
|
|
{
|
|
get { return this.shared.ManualAddressing; }
|
|
set
|
|
{
|
|
this.ThrowIfDisposedOrImmutable();
|
|
this.shared.ManualAddressing = value;
|
|
}
|
|
}
|
|
|
|
internal SynchronizedChannelCollection<IChannel> PendingChannels
|
|
{
|
|
get { return this.pendingChannels; }
|
|
}
|
|
|
|
public bool ReceiveSynchronously
|
|
{
|
|
get
|
|
{
|
|
return this.receiveSynchronously;
|
|
}
|
|
set
|
|
{
|
|
this.ThrowIfDisposedOrImmutable();
|
|
this.receiveSynchronously = value;
|
|
}
|
|
}
|
|
|
|
public bool SendAsynchronously
|
|
{
|
|
get
|
|
{
|
|
return this.sendAsynchronously;
|
|
}
|
|
set
|
|
{
|
|
this.ThrowIfDisposedOrImmutable();
|
|
this.sendAsynchronously = value;
|
|
}
|
|
|
|
}
|
|
|
|
public int MaxPendingReceives
|
|
{
|
|
get
|
|
{
|
|
return this.maxPendingReceives;
|
|
}
|
|
set
|
|
{
|
|
this.ThrowIfDisposedOrImmutable();
|
|
this.maxPendingReceives = value;
|
|
}
|
|
}
|
|
|
|
public bool IncludeExceptionDetailInFaults
|
|
{
|
|
get { return this.includeExceptionDetailInFaults; }
|
|
set
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
this.ThrowIfDisposedOrImmutable();
|
|
this.includeExceptionDetailInFaults = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal IDefaultCommunicationTimeouts DefaultCommunicationTimeouts
|
|
{
|
|
get { return this.timeouts; }
|
|
}
|
|
|
|
public IsolationLevel TransactionIsolationLevel
|
|
{
|
|
get { return this.transactionIsolationLevel; }
|
|
set
|
|
{
|
|
switch (value)
|
|
{
|
|
case IsolationLevel.Serializable:
|
|
case IsolationLevel.RepeatableRead:
|
|
case IsolationLevel.ReadCommitted:
|
|
case IsolationLevel.ReadUncommitted:
|
|
case IsolationLevel.Unspecified:
|
|
case IsolationLevel.Chaos:
|
|
case IsolationLevel.Snapshot:
|
|
break;
|
|
|
|
default:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
|
|
}
|
|
|
|
this.ThrowIfDisposedOrImmutable();
|
|
this.transactionIsolationLevel = value;
|
|
this.transactionIsolationLevelSet = true;
|
|
}
|
|
}
|
|
|
|
internal bool TransactionIsolationLevelSet
|
|
{
|
|
get { return this.transactionIsolationLevelSet; }
|
|
}
|
|
|
|
public TimeSpan TransactionTimeout
|
|
{
|
|
get
|
|
{
|
|
return this.transactionTimeout;
|
|
}
|
|
set
|
|
{
|
|
if (value < TimeSpan.Zero)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
|
|
SR.GetString(SR.SFxTimeoutOutOfRange0)));
|
|
}
|
|
|
|
if (TimeoutHelper.IsTooLarge(value))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
|
|
SR.GetString(SR.SFxTimeoutOutOfRangeTooBig)));
|
|
}
|
|
|
|
this.ThrowIfDisposedOrImmutable();
|
|
this.transactionTimeout = value;
|
|
}
|
|
}
|
|
|
|
void AbortPendingChannels()
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
for (int i = this.pendingChannels.Count - 1; i >= 0; i--)
|
|
{
|
|
this.pendingChannels[i].Abort();
|
|
}
|
|
}
|
|
}
|
|
|
|
internal override void CloseInput(TimeSpan timeout)
|
|
{
|
|
// we have to perform some slightly convoluted logic here due to
|
|
// backwards compat. We probably need an IAsyncChannelDispatcher
|
|
// interface that has timeouts and async
|
|
this.CloseInput();
|
|
|
|
if (this.performDefaultCloseInput)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
lock (this.ThisLock)
|
|
{
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
{
|
|
for (int i = 0; i < this.endpointDispatchers.Count; i++)
|
|
{
|
|
EndpointDispatcher endpointDispatcher = this.endpointDispatchers[i];
|
|
this.TraceEndpointLifetime(endpointDispatcher, TraceCode.EndpointListenerClose, SR.GetString(SR.TraceCodeEndpointListenerClose));
|
|
}
|
|
}
|
|
|
|
ListenerHandler handler = this.listenerHandler;
|
|
if (handler != null)
|
|
{
|
|
handler.CloseInput(timeoutHelper.RemainingTime());
|
|
}
|
|
}
|
|
|
|
if (!this.session)
|
|
{
|
|
ListenerHandler handler = this.listenerHandler;
|
|
if (handler != null)
|
|
{
|
|
handler.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void ReleasePerformanceCounters()
|
|
{
|
|
if (PerformanceCounters.PerformanceCountersEnabled)
|
|
{
|
|
for (int i = 0; i < this.endpointDispatchers.Count; i++)
|
|
{
|
|
if (null != this.endpointDispatchers[i])
|
|
{
|
|
this.endpointDispatchers[i].ReleasePerformanceCounters();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void CloseInput()
|
|
{
|
|
this.performDefaultCloseInput = true;
|
|
}
|
|
|
|
void OnListenerFaulted(object sender, EventArgs e)
|
|
{
|
|
this.Fault();
|
|
}
|
|
|
|
internal bool HandleError(Exception error)
|
|
{
|
|
ErrorHandlerFaultInfo dummy = new ErrorHandlerFaultInfo();
|
|
return this.HandleError(error, ref dummy);
|
|
}
|
|
|
|
internal bool HandleError(Exception error, ref ErrorHandlerFaultInfo faultInfo)
|
|
{
|
|
ErrorBehavior behavior;
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.errorBehavior != null)
|
|
{
|
|
behavior = this.errorBehavior;
|
|
}
|
|
else
|
|
{
|
|
behavior = new ErrorBehavior(this);
|
|
}
|
|
}
|
|
|
|
if (behavior != null)
|
|
{
|
|
return behavior.HandleError(error, ref faultInfo);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal void InitializeChannel(IClientChannel channel)
|
|
{
|
|
this.ThrowIfDisposedOrNotOpen();
|
|
try
|
|
{
|
|
for (int i = 0; i < this.channelInitializers.Count; ++i)
|
|
{
|
|
this.channelInitializers[i].Initialize(channel);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
|
|
}
|
|
}
|
|
|
|
internal EndpointDispatcher Match(Message message, out bool addressMatched)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
return this.filterTable.Lookup(message, out addressMatched);
|
|
}
|
|
}
|
|
|
|
internal SynchronizedCollection<T> NewBehaviorCollection<T>()
|
|
{
|
|
return new ChannelDispatcherBehaviorCollection<T>(this);
|
|
}
|
|
|
|
internal bool HasApplicationEndpoints()
|
|
{
|
|
foreach (EndpointDispatcher endpointDispatcher in this.Endpoints)
|
|
{
|
|
if (!endpointDispatcher.IsSystemEndpoint)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void OnAddEndpoint(EndpointDispatcher endpoint)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
endpoint.Attach(this);
|
|
|
|
if (this.State == CommunicationState.Opened)
|
|
{
|
|
if (this.addressTable != null)
|
|
{
|
|
this.addressTable.Add(endpoint.AddressFilter, endpoint.EndpointAddress, endpoint.FilterPriority);
|
|
}
|
|
|
|
this.filterTable.AddEndpoint(endpoint);
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnRemoveEndpoint(EndpointDispatcher endpoint)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.State == CommunicationState.Opened)
|
|
{
|
|
this.filterTable.RemoveEndpoint(endpoint);
|
|
|
|
if (this.addressTable != null)
|
|
{
|
|
this.addressTable.Remove(endpoint.AddressFilter);
|
|
}
|
|
}
|
|
|
|
endpoint.Detach(this);
|
|
}
|
|
}
|
|
|
|
protected override void OnAbort()
|
|
{
|
|
if (this.listener != null)
|
|
{
|
|
this.listener.Abort();
|
|
}
|
|
|
|
ListenerHandler handler = this.listenerHandler;
|
|
if (handler != null)
|
|
{
|
|
handler.Abort();
|
|
}
|
|
|
|
this.AbortPendingChannels();
|
|
}
|
|
|
|
protected override void OnClose(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
|
|
if (this.listener != null)
|
|
{
|
|
this.listener.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
|
|
ListenerHandler handler = this.listenerHandler;
|
|
if (handler != null)
|
|
{
|
|
handler.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
|
|
this.AbortPendingChannels();
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
List<ICommunicationObject> list = new List<ICommunicationObject>();
|
|
|
|
if (this.listener != null)
|
|
{
|
|
list.Add(this.listener);
|
|
}
|
|
|
|
ListenerHandler handler = this.listenerHandler;
|
|
if (handler != null)
|
|
{
|
|
list.Add(handler);
|
|
}
|
|
|
|
return new CloseCollectionAsyncResult(timeout, callback, state, list);
|
|
}
|
|
|
|
protected override void OnEndClose(IAsyncResult result)
|
|
{
|
|
try
|
|
{
|
|
CloseCollectionAsyncResult.End(result);
|
|
}
|
|
finally
|
|
{
|
|
this.AbortPendingChannels();
|
|
}
|
|
}
|
|
|
|
protected override void OnClosed()
|
|
{
|
|
base.OnClosed();
|
|
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
{
|
|
for (int i = 0; i < this.endpointDispatchers.Count; i++)
|
|
{
|
|
EndpointDispatcher endpointDispatcher = this.endpointDispatchers[i];
|
|
this.TraceEndpointLifetime(endpointDispatcher, TraceCode.EndpointListenerClose, SR.GetString(SR.TraceCodeEndpointListenerClose));
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnOpen(TimeSpan timeout)
|
|
{
|
|
ThrowIfNotAttachedToHost();
|
|
ThrowIfNoMessageVersion();
|
|
|
|
if (this.listener != null)
|
|
{
|
|
try
|
|
{
|
|
this.listener.Open(timeout);
|
|
}
|
|
catch (InvalidOperationException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateOuterExceptionWithEndpointsInformation(e));
|
|
}
|
|
}
|
|
}
|
|
|
|
InvalidOperationException CreateOuterExceptionWithEndpointsInformation(InvalidOperationException e)
|
|
{
|
|
string endpointContractNames = CreateContractListString();
|
|
|
|
if (String.IsNullOrEmpty(endpointContractNames))
|
|
{
|
|
return new InvalidOperationException(SR.GetString(SR.SFxChannelDispatcherUnableToOpen1, this.listener.Uri), e);
|
|
}
|
|
else
|
|
{
|
|
return new InvalidOperationException(SR.GetString(SR.SFxChannelDispatcherUnableToOpen2, this.listener.Uri, endpointContractNames), e);
|
|
}
|
|
|
|
}
|
|
|
|
internal string CreateContractListString()
|
|
{
|
|
const string OpenQuote = "\"";
|
|
const string CloseQuote = "\"";
|
|
const string Space = " ";
|
|
|
|
Collection<string> namesSeen = new Collection<string>();
|
|
StringBuilder endpointContractNames = new StringBuilder();
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
foreach (EndpointDispatcher ed in this.Endpoints)
|
|
{
|
|
if (!namesSeen.Contains(ed.ContractName))
|
|
{
|
|
if (endpointContractNames.Length > 0)
|
|
{
|
|
endpointContractNames.Append(CultureInfo.CurrentCulture.TextInfo.ListSeparator);
|
|
endpointContractNames.Append(Space);
|
|
}
|
|
|
|
endpointContractNames.Append(OpenQuote);
|
|
endpointContractNames.Append(ed.ContractName);
|
|
endpointContractNames.Append(CloseQuote);
|
|
|
|
namesSeen.Add(ed.ContractName);
|
|
}
|
|
}
|
|
}
|
|
|
|
return endpointContractNames.ToString();
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
ThrowIfNotAttachedToHost();
|
|
ThrowIfNoMessageVersion();
|
|
|
|
if (this.listener != null)
|
|
{
|
|
try
|
|
{
|
|
return this.listener.BeginOpen(timeout, callback, state);
|
|
}
|
|
catch (InvalidOperationException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateOuterExceptionWithEndpointsInformation(e));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return new CompletedAsyncResult(callback, state);
|
|
}
|
|
}
|
|
|
|
protected override void OnEndOpen(IAsyncResult result)
|
|
{
|
|
if (this.listener != null)
|
|
{
|
|
try
|
|
{
|
|
this.listener.EndOpen(result);
|
|
}
|
|
catch (InvalidOperationException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateOuterExceptionWithEndpointsInformation(e));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CompletedAsyncResult.End(result);
|
|
}
|
|
}
|
|
|
|
protected override void OnOpening()
|
|
{
|
|
ThrowIfNotAttachedToHost();
|
|
|
|
if (TD.ListenerOpenStartIsEnabled())
|
|
{
|
|
this.eventTraceActivity = EventTraceActivity.GetFromThreadOrCreate();
|
|
TD.ListenerOpenStart(this.eventTraceActivity,
|
|
(this.Listener != null) ? this.Listener.Uri.ToString() : string.Empty,
|
|
(this.host != null && host.EventTraceActivity != null) ? this.host.EventTraceActivity.ActivityId : Guid.Empty);
|
|
}
|
|
|
|
base.OnOpening();
|
|
}
|
|
|
|
protected override void OnOpened()
|
|
{
|
|
ThrowIfNotAttachedToHost();
|
|
base.OnOpened();
|
|
|
|
if (TD.ListenerOpenStopIsEnabled())
|
|
{
|
|
TD.ListenerOpenStop(this.eventTraceActivity);
|
|
this.eventTraceActivity = null; // clear this since we don't need this anymore.
|
|
}
|
|
|
|
this.errorBehavior = new ErrorBehavior(this);
|
|
|
|
this.filterTable = new EndpointDispatcherTable(this.ThisLock);
|
|
for (int i = 0; i < this.endpointDispatchers.Count; i++)
|
|
{
|
|
EndpointDispatcher endpoint = this.endpointDispatchers[i];
|
|
|
|
// Force a build of the runtime to catch any unexpected errors before we are done opening.
|
|
endpoint.DispatchRuntime.GetRuntime();
|
|
// Lock down the DispatchRuntime.
|
|
endpoint.DispatchRuntime.LockDownProperties();
|
|
|
|
this.filterTable.AddEndpoint(endpoint);
|
|
|
|
if ((this.addressTable != null) && (endpoint.OriginalAddress != null))
|
|
{
|
|
this.addressTable.Add(endpoint.AddressFilter, endpoint.OriginalAddress, endpoint.FilterPriority);
|
|
}
|
|
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
{
|
|
this.TraceEndpointLifetime(endpoint, TraceCode.EndpointListenerOpen, SR.GetString(SR.TraceCodeEndpointListenerOpen));
|
|
}
|
|
}
|
|
|
|
ServiceThrottle throttle = this.serviceThrottle;
|
|
if (throttle == null)
|
|
{
|
|
throttle = this.host.ServiceThrottle;
|
|
}
|
|
|
|
IListenerBinder binder = ListenerBinder.GetBinder(this.listener, this.messageVersion);
|
|
this.listenerHandler = new ListenerHandler(binder, this, this.host, throttle, this.timeouts);
|
|
this.listenerHandler.Open(); // This never throws, which is why it's ok for it to happen in OnOpened
|
|
}
|
|
|
|
internal void ProvideFault(Exception e, FaultConverter faultConverter, ref ErrorHandlerFaultInfo faultInfo)
|
|
{
|
|
ErrorBehavior behavior;
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.errorBehavior != null)
|
|
{
|
|
behavior = this.errorBehavior;
|
|
}
|
|
else
|
|
{
|
|
behavior = new ErrorBehavior(this);
|
|
}
|
|
}
|
|
|
|
behavior.ProvideFault(e, faultConverter, ref faultInfo);
|
|
}
|
|
|
|
internal void SetEndpointAddressTable(ThreadSafeMessageFilterTable<EndpointAddress> table)
|
|
{
|
|
if (table == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("table");
|
|
}
|
|
|
|
this.ThrowIfDisposedOrImmutable();
|
|
|
|
this.addressTable = table;
|
|
}
|
|
|
|
internal new void ThrowIfDisposedOrImmutable()
|
|
{
|
|
base.ThrowIfDisposedOrImmutable();
|
|
this.shared.ThrowIfImmutable();
|
|
}
|
|
|
|
void ThrowIfNotAttachedToHost()
|
|
{
|
|
// if we are on the server, we need a host
|
|
// if we are on the client, we never call Open(), so this method is not invoked
|
|
if (this.host == null)
|
|
{
|
|
Exception error = new InvalidOperationException(SR.GetString(SR.SFxChannelDispatcherNoHost0));
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
|
|
}
|
|
}
|
|
|
|
void ThrowIfNoMessageVersion()
|
|
{
|
|
if (this.messageVersion == null)
|
|
{
|
|
Exception error = new InvalidOperationException(SR.GetString(SR.SFxChannelDispatcherNoMessageVersion));
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
|
|
}
|
|
}
|
|
|
|
void TraceEndpointLifetime(EndpointDispatcher endpoint, int traceCode, string traceDescription)
|
|
{
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
{
|
|
Dictionary<string, object> values = new Dictionary<string, object>(3)
|
|
{
|
|
{ "ContractNamespace", endpoint.ContractNamespace },
|
|
{ "ContractName", endpoint.ContractName },
|
|
{ "Endpoint", endpoint.ListenUri }
|
|
};
|
|
TraceUtility.TraceEvent(TraceEventType.Information, traceCode,
|
|
traceDescription, new DictionaryTraceRecord(values), endpoint, null);
|
|
}
|
|
}
|
|
|
|
protected override void Attach(ServiceHostBase host)
|
|
{
|
|
if (host == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("host");
|
|
}
|
|
|
|
ServiceHostBase serviceHost = host;
|
|
|
|
this.ThrowIfDisposedOrImmutable();
|
|
|
|
if (this.host != null)
|
|
{
|
|
Exception error = new InvalidOperationException(SR.GetString(SR.SFxChannelDispatcherMultipleHost0));
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
|
|
}
|
|
|
|
this.host = serviceHost;
|
|
}
|
|
|
|
protected override void Detach(ServiceHostBase host)
|
|
{
|
|
if (host == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("host");
|
|
}
|
|
|
|
if (this.host != host)
|
|
{
|
|
Exception error = new InvalidOperationException(SR.GetString(SR.SFxChannelDispatcherDifferentHost0));
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
|
|
}
|
|
|
|
this.ThrowIfDisposedOrImmutable();
|
|
|
|
this.host = null;
|
|
}
|
|
|
|
class EndpointDispatcherCollection : SynchronizedCollection<EndpointDispatcher>
|
|
{
|
|
ChannelDispatcher owner;
|
|
|
|
internal EndpointDispatcherCollection(ChannelDispatcher owner)
|
|
: base(owner.ThisLock)
|
|
{
|
|
this.owner = owner;
|
|
}
|
|
|
|
protected override void ClearItems()
|
|
{
|
|
foreach (EndpointDispatcher item in this.Items)
|
|
{
|
|
this.owner.OnRemoveEndpoint(item);
|
|
}
|
|
base.ClearItems();
|
|
}
|
|
|
|
protected override void InsertItem(int index, EndpointDispatcher item)
|
|
{
|
|
if (item == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
|
|
|
|
this.owner.OnAddEndpoint(item);
|
|
base.InsertItem(index, item);
|
|
}
|
|
|
|
protected override void RemoveItem(int index)
|
|
{
|
|
EndpointDispatcher item = this.Items[index];
|
|
base.RemoveItem(index);
|
|
this.owner.OnRemoveEndpoint(item);
|
|
}
|
|
|
|
protected override void SetItem(int index, EndpointDispatcher item)
|
|
{
|
|
Exception error = new InvalidOperationException(SR.GetString(SR.SFxCollectionDoesNotSupportSet0));
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
|
|
}
|
|
}
|
|
|
|
class ChannelDispatcherBehaviorCollection<T> : SynchronizedCollection<T>
|
|
{
|
|
ChannelDispatcher outer;
|
|
|
|
internal ChannelDispatcherBehaviorCollection(ChannelDispatcher outer)
|
|
: base(outer.ThisLock)
|
|
{
|
|
this.outer = outer;
|
|
}
|
|
|
|
protected override void ClearItems()
|
|
{
|
|
this.outer.ThrowIfDisposedOrImmutable();
|
|
base.ClearItems();
|
|
}
|
|
|
|
protected override void InsertItem(int index, T item)
|
|
{
|
|
if (item == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
|
|
}
|
|
|
|
this.outer.ThrowIfDisposedOrImmutable();
|
|
base.InsertItem(index, item);
|
|
}
|
|
|
|
protected override void RemoveItem(int index)
|
|
{
|
|
this.outer.ThrowIfDisposedOrImmutable();
|
|
base.RemoveItem(index);
|
|
}
|
|
|
|
protected override void SetItem(int index, T item)
|
|
{
|
|
if (item == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
|
|
}
|
|
|
|
this.outer.ThrowIfDisposedOrImmutable();
|
|
base.SetItem(index, item);
|
|
}
|
|
}
|
|
}
|
|
}
|