Files
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

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);
}
}
}
}