static void BuildDispatchOperation(OperationDescription operation, DispatchRuntime parent, EndpointFilterProvider provider)
{
string requestAction = operation.Messages[0].Action;
DispatchOperation child = null;
if (operation.IsOneWay)
{
child = new DispatchOperation(parent, operation.Name, requestAction);
}
else
{
string replyAction = operation.Messages[1].Action;
child = new DispatchOperation(parent, operation.Name, requestAction, replyAction);
}
child.HasNoDisposableParameters = operation.HasNoDisposableParameters;
child.IsTerminating = operation.IsTerminating;
child.IsSessionOpenNotificationEnabled = operation.IsSessionOpenNotificationEnabled;
for (int i = 0; i < operation.Faults.Count; i++)
{
FaultDescription fault = operation.Faults[i];
child.FaultContractInfos.Add(new FaultContractInfo(fault.Action, fault.DetailType, fault.ElementName, fault.Namespace, operation.KnownTypes));
}
child.IsInsideTransactedReceiveScope = operation.IsInsideTransactedReceiveScope;
if (provider != null)
{
if (operation.IsInitiating)
{
provider.InitiatingActions.Add(requestAction);
}
}
if (requestAction != MessageHeaders.WildcardAction)
{
parent.Operations.Add(child);
}
else
{
if (parent.HasMatchAllOperation)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxMultipleContractStarOperations0)));
}
parent.UnhandledDispatchOperation = child;
}
}
public void InitializeServiceHost(ServiceDescription description, ServiceHostBase serviceHost)
{
if (serviceHost.ImplementedContracts != null && serviceHost.ImplementedContracts.Count > 0)
{
EnsureThereAreApplicationEndpoints(description);
}
ValidateDescription(description, serviceHost);
AspNetEnvironment.Current.AddHostingBehavior(serviceHost, description);
ServiceBehaviorAttribute instanceSettings = description.Behaviors.Find<ServiceBehaviorAttribute>();
InitializeServicePerformanceCounters(serviceHost);
Dictionary<ListenUriInfo, StuffPerListenUriInfo> stuffPerListenUriInfo
= new Dictionary<ListenUriInfo, StuffPerListenUriInfo>();
Dictionary<EndpointAddress, Collection<EndpointInfo>> endpointInfosPerEndpointAddress
= new Dictionary<EndpointAddress, Collection<EndpointInfo>>();
// Ensure ListenUri and group endpoints per ListenUri
for (int i = 0; i < description.Endpoints.Count; i++)
{
//Ensure ReceiveContextSettings before building channel
bool requiresReceiveContext = false; //at least one operation had ReceiveContextEnabledAttribute
ServiceEndpoint endpoint = description.Endpoints[i];
foreach (OperationDescription operation in endpoint.Contract.Operations)
{
if (operation.Behaviors.Find<ReceiveContextEnabledAttribute>() != null)
{
requiresReceiveContext = true;
break;
}
}
if (requiresReceiveContext)
{
IReceiveContextSettings receiveContextSettings = endpoint.Binding.GetProperty<IReceiveContextSettings>(new BindingParameterCollection());
if (receiveContextSettings == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR.GetString(SR.SFxReceiveContextSettingsPropertyMissing,
endpoint.Contract.Name,
typeof(ReceiveContextEnabledAttribute).Name,
endpoint.Address.Uri.AbsoluteUri,
typeof(IReceiveContextSettings).Name)));
}
//Enable ReceiveContext on the binding.
receiveContextSettings.Enabled = true;
}
ListenUriInfo listenUriInfo = GetListenUriInfoForEndpoint(serviceHost, endpoint);
if (!stuffPerListenUriInfo.ContainsKey(listenUriInfo))
{
stuffPerListenUriInfo.Add(listenUriInfo, new StuffPerListenUriInfo());
}
stuffPerListenUriInfo[listenUriInfo].Endpoints.Add(endpoint);
}
foreach (KeyValuePair<ListenUriInfo, StuffPerListenUriInfo> stuff in stuffPerListenUriInfo)
{
Uri listenUri = stuff.Key.ListenUri;
ListenUriMode listenUriMode = stuff.Key.ListenUriMode;
BindingParameterCollection parameters = stuff.Value.Parameters;
Binding binding = stuff.Value.Endpoints[0].Binding;
EndpointIdentity identity = stuff.Value.Endpoints[0].Address.Identity;
// same EndpointAddressTable instance must be shared between channelDispatcher and parameters
ThreadSafeMessageFilterTable<EndpointAddress> endpointAddressTable = new ThreadSafeMessageFilterTable<EndpointAddress>();
parameters.Add(endpointAddressTable);
bool supportContextSession = false;
// add service-level binding parameters
foreach (IServiceBehavior behavior in description.Behaviors)
{
if (behavior is IContextSessionProvider)
{
supportContextSession = true;
}
behavior.AddBindingParameters(description, serviceHost, stuff.Value.Endpoints, parameters);
}
for (int i = 0; i < stuff.Value.Endpoints.Count; i++)
{
ServiceEndpoint endpoint = stuff.Value.Endpoints[i];
string viaString = listenUri.AbsoluteUri;
// ensure all endpoints with this ListenUriInfo have same binding
if (endpoint.Binding != binding)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ABindingInstanceHasAlreadyBeenAssociatedTo1, viaString)));
}
// ensure all endpoints with this ListenUriInfo have same identity
if (!object.Equals(endpoint.Address.Identity, identity))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.SFxWhenMultipleEndpointsShareAListenUriTheyMustHaveSameIdentity, viaString)));
}
// add binding parameters (endpoint scope and below)
AddMsmqIntegrationContractInformation(endpoint);
SecurityContractInformationEndpointBehavior.ServerInstance.AddBindingParameters(endpoint, parameters);
AddBindingParameters(endpoint, parameters);
}
// build IChannelListener and ChannelDispatcher
IChannelListener listener;
Type channelType = this.BuildChannelListener(stuff.Value,
serviceHost,
listenUri,
listenUriMode,
supportContextSession,
out listener);
XmlQualifiedName bindingQname = new XmlQualifiedName(binding.Name, binding.Namespace);
ChannelDispatcher channelDispatcher = new ChannelDispatcher(listener, bindingQname.ToString(), binding);
channelDispatcher.SetEndpointAddressTable(endpointAddressTable);
stuff.Value.ChannelDispatcher = channelDispatcher;
bool canReceiveInTransaction = false; // at least one operation is TransactionScopeRequired
int transactedBatchSize = int.MaxValue;
for (int i = 0; i < stuff.Value.Endpoints.Count; i++)
{
ServiceEndpoint endpoint = stuff.Value.Endpoints[i];
string viaString = listenUri.AbsoluteUri;
EndpointFilterProvider provider = new EndpointFilterProvider();
EndpointDispatcher dispatcher = DispatcherBuilder.BuildDispatcher(serviceHost, description, endpoint, endpoint.Contract, provider);
for (int j = 0; j < endpoint.Contract.Operations.Count; j++)
{
OperationDescription operation = endpoint.Contract.Operations[j];
OperationBehaviorAttribute operationBehavior = operation.Behaviors.Find<OperationBehaviorAttribute>();
if (null != operationBehavior && operationBehavior.TransactionScopeRequired)
{
canReceiveInTransaction = true;
break;
}
}
if (!endpointInfosPerEndpointAddress.ContainsKey(endpoint.Address))
{
endpointInfosPerEndpointAddress.Add(endpoint.Address, new Collection<EndpointInfo>());
}
endpointInfosPerEndpointAddress[endpoint.Address].Add(new EndpointInfo(endpoint, dispatcher, provider));
channelDispatcher.Endpoints.Add(dispatcher);
TransactedBatchingBehavior batchBehavior = endpoint.Behaviors.Find<TransactedBatchingBehavior>();
if (batchBehavior == null)
{
transactedBatchSize = 0;
}
else
{
if (!canReceiveInTransaction)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.MsmqBatchRequiresTransactionScope)));
transactedBatchSize = System.Math.Min(transactedBatchSize, batchBehavior.MaxBatchSize);
}
if (PerformanceCounters.PerformanceCountersEnabled || PerformanceCounters.MinimalPerformanceCountersEnabled)
{
PerformanceCounters.AddPerformanceCountersForEndpoint(serviceHost, endpoint.Contract, dispatcher);
}
} // end foreach "endpoint"
if (canReceiveInTransaction)
{
BindingElementCollection bindingElements = binding.CreateBindingElements();
foreach (BindingElement bindingElement in bindingElements)
{
ITransactedBindingElement txElement = bindingElement as ITransactedBindingElement;
if (null != txElement && txElement.TransactedReceiveEnabled)
{
channelDispatcher.IsTransactedReceive = true;
channelDispatcher.MaxTransactedBatchSize = transactedBatchSize;
break;
}
}
}
//Set the mode of operation for ChannelDispatcher based on binding Settings.
IReceiveContextSettings receiveContextSettings = binding.GetProperty<IReceiveContextSettings>(new BindingParameterCollection());
if (receiveContextSettings != null)
{
channelDispatcher.ReceiveContextEnabled = receiveContextSettings.Enabled;
}
serviceHost.ChannelDispatchers.Add(channelDispatcher);
} // end foreach "ListenUri/ChannelDispatcher" group
// run service behaviors
for (int i = 0; i < description.Behaviors.Count; i++)
{
IServiceBehavior serviceBehavior = description.Behaviors[i];
serviceBehavior.ApplyDispatchBehavior(description, serviceHost);
}
foreach (KeyValuePair<ListenUriInfo, StuffPerListenUriInfo> stuff in stuffPerListenUriInfo)
{
for (int i = 0; i < stuff.Value.Endpoints.Count; i++)
{
ServiceEndpoint endpoint = stuff.Value.Endpoints[i];
// rediscover which dispatcher goes with this endpoint
Collection<EndpointInfo> infos = endpointInfosPerEndpointAddress[endpoint.Address];
EndpointInfo info = null;
foreach (EndpointInfo ei in infos)
{
if (ei.Endpoint == endpoint)
{
info = ei;
break;
}
}
EndpointDispatcher dispatcher = info.EndpointDispatcher;
// run contract behaviors
for (int k = 0; k < endpoint.Contract.Behaviors.Count; k++)
{
IContractBehavior behavior = endpoint.Contract.Behaviors[k];
behavior.ApplyDispatchBehavior(endpoint.Contract, endpoint, dispatcher.DispatchRuntime);
}
// run endpoint behaviors
BindingInformationEndpointBehavior.Instance.ApplyDispatchBehavior(endpoint, dispatcher);
TransactionContractInformationEndpointBehavior.Instance.ApplyDispatchBehavior(endpoint, dispatcher);
for (int j = 0; j < endpoint.Behaviors.Count; j++)
{
IEndpointBehavior eb = endpoint.Behaviors[j];
eb.ApplyDispatchBehavior(endpoint, dispatcher);
}
// run operation behaviors
DispatcherBuilder.BindOperations(endpoint.Contract, null, dispatcher.DispatchRuntime);
}
}
this.EnsureRequiredRuntimeProperties(endpointInfosPerEndpointAddress);
// Warn about obvious demux conflicts
foreach (Collection<EndpointInfo> endpointInfos in endpointInfosPerEndpointAddress.Values)
{
// all elements of endpointInfos share the same Address (and thus EndpointListener.AddressFilter)
if (endpointInfos.Count > 1)
{
for (int i = 0; i < endpointInfos.Count; i++)
{
for (int j = i + 1; j < endpointInfos.Count; j++)
{
// if not same ListenUri, won't conflict
// if not same ChannelType, may not conflict (some transports demux based on this)
// if they share a ChannelDispatcher, this means same ListenUri and same ChannelType
if (endpointInfos[i].EndpointDispatcher.ChannelDispatcher ==
endpointInfos[j].EndpointDispatcher.ChannelDispatcher)
{
EndpointFilterProvider iProvider = endpointInfos[i].FilterProvider;
EndpointFilterProvider jProvider = endpointInfos[j].FilterProvider;
// if not default EndpointFilterProvider, we won't try to throw, you're on your own
string commonAction;
if (iProvider != null && jProvider != null
&& HaveCommonInitiatingActions(iProvider, jProvider, out commonAction))
{
// you will definitely get a MultipleFiltersMatchedException at runtime,
// so let's go ahead and throw now
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR.GetString(SR.SFxDuplicateInitiatingActionAtSameVia,
endpointInfos[i].Endpoint.ListenUri, commonAction)));
}
}
}
}
}
}
}
static EndpointDispatcher BuildDispatcher(ServiceHostBase service,
ServiceDescription serviceDescription,
ServiceEndpoint endpoint,
ContractDescription contractDescription,
EndpointFilterProvider provider)
{
if (service == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("service");
}
if (serviceDescription == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceDescription");
}
if (contractDescription == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contractDescription");
}
EndpointAddress address = endpoint.Address;
EndpointDispatcher dispatcher = new EndpointDispatcher(address, contractDescription.Name, contractDescription.Namespace, endpoint.Id, endpoint.InternalIsSystemEndpoint(serviceDescription));
DispatchRuntime dispatch = dispatcher.DispatchRuntime;
if (contractDescription.CallbackContractType != null)
{
dispatch.CallbackClientRuntime.CallbackClientType = contractDescription.CallbackContractType;
dispatch.CallbackClientRuntime.ContractClientType = contractDescription.ContractType;
}
for (int i = 0; i < contractDescription.Operations.Count; i++)
{
OperationDescription operation = contractDescription.Operations[i];
if (!operation.IsServerInitiated())
{
DispatcherBuilder.BuildDispatchOperation(operation, dispatch, provider);
}
else
{
DispatcherBuilder.BuildProxyOperation(operation, dispatch.CallbackClientRuntime);
}
}
//dispatcher.SetSupportedChannels(DispatcherBuilder.GetSupportedChannelTypes(contractDescription));
int filterPriority = 0;
dispatcher.ContractFilter = provider.CreateFilter(out filterPriority);
dispatcher.FilterPriority = filterPriority;
return dispatcher;
}
public EndpointInfo(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher, EndpointFilterProvider provider)
{
this.endpoint = endpoint;
this.endpointDispatcher = endpointDispatcher;
this.provider = provider;
}
static bool HaveCommonInitiatingActions(EndpointFilterProvider x, EndpointFilterProvider y, out string commonAction)
{
commonAction = null;
foreach (string action in x.InitiatingActions)
{
if (y.InitiatingActions.Contains(action))
{
commonAction = action;
return true;
}
}
return false;
}
internal static void SetContractFilterToIncludeAllOperations(EndpointDispatcher dispatcher, ContractDescription contract)
{
if (dispatcher == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dispatcher");
}
if (contract == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contract");
}
if (contract.SessionMode == SessionMode.Required)
{
EndpointFilterProvider provider = new EndpointFilterProvider();
foreach (OperationDescription operation in contract.Operations)
{
if (!operation.IsServerInitiated())
{
provider.InitiatingActions.Add(operation.Messages[0].Action);
}
}
int priority;
dispatcher.ContractFilter = provider.CreateFilter(out priority);
dispatcher.FilterPriority = priority;
}
}
public void InitializeServiceHost(System.ServiceModel.Description.ServiceDescription description, ServiceHostBase serviceHost)
{
if ((serviceHost.ImplementedContracts != null) && (serviceHost.ImplementedContracts.Count > 0))
{
this.EnsureThereAreApplicationEndpoints(description);
}
this.ValidateDescription(description, serviceHost);
AspNetEnvironment.Current.AddHostingBehavior(serviceHost, description);
description.Behaviors.Find<ServiceBehaviorAttribute>();
this.InitializeServicePerformanceCounters(serviceHost);
Dictionary<ListenUriInfo, StuffPerListenUriInfo> dictionary = new Dictionary<ListenUriInfo, StuffPerListenUriInfo>();
Dictionary<EndpointAddress, Collection<EndpointInfo>> endpointInfosPerEndpointAddress = new Dictionary<EndpointAddress, Collection<EndpointInfo>>();
for (int i = 0; i < description.Endpoints.Count; i++)
{
bool flag = false;
ServiceEndpoint endpoint = description.Endpoints[i];
foreach (OperationDescription description2 in endpoint.Contract.Operations)
{
if (description2.Behaviors.Find<ReceiveContextEnabledAttribute>() != null)
{
flag = true;
break;
}
}
if (flag)
{
IReceiveContextSettings property = endpoint.Binding.GetProperty<IReceiveContextSettings>(new BindingParameterCollection());
if (property == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxReceiveContextSettingsPropertyMissing", new object[] { endpoint.Contract.Name, typeof(ReceiveContextEnabledAttribute).Name, endpoint.Address.Uri.AbsoluteUri, typeof(IReceiveContextSettings).Name })));
}
property.Enabled = true;
}
ListenUriInfo key = new ListenUriInfo(this.EnsureListenUri(serviceHost, endpoint), endpoint.ListenUriMode);
if (!dictionary.ContainsKey(key))
{
dictionary.Add(key, new StuffPerListenUriInfo());
}
dictionary[key].Endpoints.Add(endpoint);
}
foreach (KeyValuePair<ListenUriInfo, StuffPerListenUriInfo> pair in dictionary)
{
ThreadSafeMessageFilterTable<EndpointAddress> table;
IChannelListener listener;
Uri listenUri = pair.Key.ListenUri;
ListenUriMode listenUriMode = pair.Key.ListenUriMode;
BindingParameterCollection bindingParameters = pair.Value.Parameters;
Binding timeouts = pair.Value.Endpoints[0].Binding;
EndpointIdentity objB = pair.Value.Endpoints[0].Address.Identity;
table = new ThreadSafeMessageFilterTable<EndpointAddress> {
table
};
bool supportContextSession = false;
foreach (IServiceBehavior behavior in description.Behaviors)
{
if (behavior is IContextSessionProvider)
{
supportContextSession = true;
}
behavior.AddBindingParameters(description, serviceHost, pair.Value.Endpoints, bindingParameters);
}
for (int k = 0; k < pair.Value.Endpoints.Count; k++)
{
ServiceEndpoint endpoint2 = pair.Value.Endpoints[k];
string absoluteUri = listenUri.AbsoluteUri;
if (endpoint2.Binding != timeouts)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("ABindingInstanceHasAlreadyBeenAssociatedTo1", new object[] { absoluteUri })));
}
if (!object.Equals(endpoint2.Address.Identity, objB))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxWhenMultipleEndpointsShareAListenUriTheyMustHaveSameIdentity", new object[] { absoluteUri })));
}
AddMsmqIntegrationContractInformation(endpoint2);
SecurityContractInformationEndpointBehavior.ServerInstance.AddBindingParameters(endpoint2, bindingParameters);
AddBindingParameters(endpoint2, bindingParameters);
}
this.BuildChannelListener(pair.Value, serviceHost, listenUri, listenUriMode, supportContextSession, out listener);
XmlQualifiedName name = new XmlQualifiedName(timeouts.Name, timeouts.Namespace);
ChannelDispatcher item = new ChannelDispatcher(listener, name.ToString(), timeouts);
item.SetEndpointAddressTable(table);
pair.Value.ChannelDispatcher = item;
bool flag3 = false;
int num3 = 0x7fffffff;
for (int m = 0; m < pair.Value.Endpoints.Count; m++)
{
ServiceEndpoint endpoint3 = pair.Value.Endpoints[m];
string text1 = listenUri.AbsoluteUri;
EndpointFilterProvider provider = new EndpointFilterProvider(new string[0]);
EndpointDispatcher endpointDispatcher = BuildDispatcher(serviceHost, description, endpoint3, endpoint3.Contract, provider);
for (int n = 0; n < endpoint3.Contract.Operations.Count; n++)
{
OperationDescription description3 = endpoint3.Contract.Operations[n];
OperationBehaviorAttribute attribute = description3.Behaviors.Find<OperationBehaviorAttribute>();
if ((attribute != null) && attribute.TransactionScopeRequired)
{
flag3 = true;
break;
}
}
if (!endpointInfosPerEndpointAddress.ContainsKey(endpoint3.Address))
{
endpointInfosPerEndpointAddress.Add(endpoint3.Address, new Collection<EndpointInfo>());
}
endpointInfosPerEndpointAddress[endpoint3.Address].Add(new EndpointInfo(endpoint3, endpointDispatcher, provider));
item.Endpoints.Add(endpointDispatcher);
TransactedBatchingBehavior behavior2 = endpoint3.Behaviors.Find<TransactedBatchingBehavior>();
if (behavior2 == null)
{
num3 = 0;
}
else
{
if (!flag3)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("MsmqBatchRequiresTransactionScope")));
}
num3 = Math.Min(num3, behavior2.MaxBatchSize);
}
if (PerformanceCounters.PerformanceCountersEnabled || PerformanceCounters.MinimalPerformanceCountersEnabled)
{
PerformanceCounters.AddPerformanceCountersForEndpoint(serviceHost, endpoint3.Contract, endpointDispatcher);
}
}
if (flag3)
{
foreach (BindingElement element in timeouts.CreateBindingElements())
{
ITransactedBindingElement element2 = element as ITransactedBindingElement;
if ((element2 != null) && element2.TransactedReceiveEnabled)
{
item.IsTransactedReceive = true;
item.MaxTransactedBatchSize = num3;
break;
}
}
}
IReceiveContextSettings settings2 = timeouts.GetProperty<IReceiveContextSettings>(new BindingParameterCollection());
if (settings2 != null)
{
item.ReceiveContextEnabled = settings2.Enabled;
}
serviceHost.ChannelDispatchers.Add(item);
}
for (int j = 0; j < description.Behaviors.Count; j++)
{
description.Behaviors[j].ApplyDispatchBehavior(description, serviceHost);
}
foreach (KeyValuePair<ListenUriInfo, StuffPerListenUriInfo> pair2 in dictionary)
{
for (int num7 = 0; num7 < pair2.Value.Endpoints.Count; num7++)
{
ServiceEndpoint endpoint4 = pair2.Value.Endpoints[num7];
Collection<EndpointInfo> collection = endpointInfosPerEndpointAddress[endpoint4.Address];
EndpointInfo info2 = null;
foreach (EndpointInfo info3 in collection)
{
if (info3.Endpoint == endpoint4)
{
info2 = info3;
break;
}
}
EndpointDispatcher dispatcher3 = info2.EndpointDispatcher;
for (int num8 = 0; num8 < endpoint4.Contract.Behaviors.Count; num8++)
{
endpoint4.Contract.Behaviors[num8].ApplyDispatchBehavior(endpoint4.Contract, endpoint4, dispatcher3.DispatchRuntime);
}
BindingInformationEndpointBehavior.Instance.ApplyDispatchBehavior(endpoint4, dispatcher3);
TransactionContractInformationEndpointBehavior.Instance.ApplyDispatchBehavior(endpoint4, dispatcher3);
for (int num9 = 0; num9 < endpoint4.Behaviors.Count; num9++)
{
endpoint4.Behaviors[num9].ApplyDispatchBehavior(endpoint4, dispatcher3);
}
BindOperations(endpoint4.Contract, null, dispatcher3.DispatchRuntime);
}
}
this.EnsureRequiredRuntimeProperties(endpointInfosPerEndpointAddress);
foreach (Collection<EndpointInfo> collection2 in endpointInfosPerEndpointAddress.Values)
{
if (collection2.Count > 1)
{
for (int num10 = 0; num10 < collection2.Count; num10++)
{
for (int num11 = num10 + 1; num11 < collection2.Count; num11++)
{
if (collection2[num10].EndpointDispatcher.ChannelDispatcher == collection2[num11].EndpointDispatcher.ChannelDispatcher)
{
string str2;
EndpointFilterProvider filterProvider = collection2[num10].FilterProvider;
EndpointFilterProvider y = collection2[num11].FilterProvider;
if (((filterProvider != null) && (y != null)) && HaveCommonInitiatingActions(filterProvider, y, out str2))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxDuplicateInitiatingActionAtSameVia", new object[] { collection2[num10].Endpoint.ListenUri, str2 })));
}
}
}
}
}
}
}
private static void BuildDispatchOperation(OperationDescription operation, DispatchRuntime parent, EndpointFilterProvider provider)
{
string action = operation.Messages[0].Action;
DispatchOperation item = null;
if (operation.IsOneWay)
{
item = new DispatchOperation(parent, operation.Name, action);
}
else
{
string replyAction = operation.Messages[1].Action;
item = new DispatchOperation(parent, operation.Name, action, replyAction);
}
item.HasNoDisposableParameters = operation.HasNoDisposableParameters;
item.IsTerminating = operation.IsTerminating;
for (int i = 0; i < operation.Faults.Count; i++)
{
FaultDescription description = operation.Faults[i];
item.FaultContractInfos.Add(new FaultContractInfo(description.Action, description.DetailType, description.ElementName, description.Namespace, operation.KnownTypes));
}
item.IsInsideTransactedReceiveScope = operation.IsInsideTransactedReceiveScope;
if ((provider != null) && operation.IsInitiating)
{
provider.InitiatingActions.Add(action);
}
if (action != "*")
{
parent.Operations.Add(item);
}
else
{
if (parent.HasMatchAllOperation)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxMultipleContractStarOperations0")));
}
parent.UnhandledDispatchOperation = item;
}
}