public bool GetMatchingValue(Message message, out TFilterData data)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
}
MessageFilter f = InnerMatch(message);
if (f == null)
{
data = default(TFilterData);
return(false);
}
data = this.filters[f];
return(true);
}
public bool GetMatchingFilter(MessageBuffer messageBuffer, out MessageFilter filter)
{
if (messageBuffer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("messageBuffer");
}
FilterDataPair pair = InnerMatch(messageBuffer);
if (pair == null)
{
filter = null;
return(false);
}
filter = pair.filter;
return(true);
}
public void RemoveEndpoint(EndpointDispatcher endpoint)
{
lock (this.ThisLock)
{
if (this.filters == null)
{
if ((this.cachedEndpoints != null) && this.cachedEndpoints.Contains(endpoint))
{
this.cachedEndpoints.Remove(endpoint);
}
}
else
{
MessageFilter endpointFilter = endpoint.EndpointFilter;
this.filters.Remove(endpointFilter);
}
}
}
public bool GetMatchingFilter(Message message, out MessageFilter filter)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
}
Candidate can = InnerMatch(message);
if (can != null)
{
filter = can.filter;
return(true);
}
filter = null;
return(false);
}
public EndpointDispatcher(System.ServiceModel.EndpointAddress address, string contractName, string contractNamespace, bool isSystemEndpoint)
{
this.originalAddress = address;
this.contractName = contractName;
this.contractNamespace = contractNamespace;
if (address != null)
{
this.addressFilter = new EndpointAddressMessageFilter(address);
}
else
{
this.addressFilter = new MatchAllMessageFilter();
}
this.contractFilter = new MatchAllMessageFilter();
this.dispatchRuntime = new System.ServiceModel.Dispatcher.DispatchRuntime(this);
this.filterPriority = 0;
this.isSystemEndpoint = isSystemEndpoint;
}
public TFilterData this[MessageFilter filter]
{
get
{
return(this.filters[filter]);
}
set
{
if (this.filters.ContainsKey(filter))
{
this.filters[filter] = value;
}
else
{
this.Add(filter, value);
}
}
}
public void RemoveEndpoint(EndpointDispatcher endpoint)
{
lock (ThisLock)
{
if (filters == null)
{
if (cachedEndpoints != null && cachedEndpoints.Contains(endpoint))
{
cachedEndpoints.Remove(endpoint);
}
}
else
{
MessageFilter filter = endpoint.EndpointFilter;
filters.Remove(filter);
}
}
}
public bool GetMatchingFilter(MessageBuffer messageBuffer, out MessageFilter filter)
{
if (messageBuffer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("messageBuffer");
}
Message msg = messageBuffer.CreateMessage();
try
{
filter = InnerMatch(msg);
return(filter != null);
}
finally
{
msg.Close();
}
}
public TFilterData this[MessageFilter filter]
{
get
{
return(this.filters[filter]);
}
set
{
if (this.ContainsKey(filter))
{
int priority = this.GetPriority(filter);
this.Remove(filter);
this.Add(filter, value, priority);
}
else
{
this.Add(filter, value, this.defaultPriority);
}
}
}
public bool GetMatchingFilter(MessageBuffer buffer, out MessageFilter filter)
{
filter = null;
foreach (KeyValuePair <MessageFilter, FilterData> pair in this.filters)
{
if (pair.Key.Match(buffer))
{
if (filter != null)
{
Collection <MessageFilter> filters = new Collection <MessageFilter> {
filter,
pair.Key
};
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MultipleFilterMatchesException(System.ServiceModel.SR.GetString("FilterMultipleMatches"), null, filters));
}
filter = pair.Key;
}
}
return(filter != null);
}
public bool GetMatchingFilter(XPathNavigator navigator, out MessageFilter filter)
{
Collection <MessageFilter> filters = new Collection <MessageFilter>();
this.GetMatchingFilters(navigator, filters);
if (filters.Count > 1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MultipleFilterMatchesException(SR.GetString(SR.FilterMultipleMatches), null, filters));
}
else if (filters.Count == 1)
{
filter = filters[0];
return(true);
}
else
{
filter = null;
return(false);
}
}
public bool GetMatchingFilter(Message message, out MessageFilter filter)
{
Collection <MessageFilter> filters = new Collection <MessageFilter>();
this.GetMatchingFilters(message, filters);
if (filters.Count > 1)
{
throw TraceUtility.ThrowHelperError(new MultipleFilterMatchesException(SR.GetString(SR.FilterMultipleMatches), null, filters), message);
}
else if (filters.Count == 1)
{
filter = filters[0];
return(true);
}
else
{
filter = null;
return(false);
}
}
public bool GetMatchingFilter(MessageBuffer buffer, out MessageFilter filter)
{
filter = null;
foreach (KeyValuePair <MessageFilter, FilterData> item in this.filters)
{
if (item.Key.Match(buffer))
{
if (filter != null)
{
Collection <MessageFilter> f = new Collection <MessageFilter>();
f.Add(filter);
f.Add(item.Key);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MultipleFilterMatchesException(SR.GetString(SR.FilterMultipleMatches), null, f));
}
filter = item.Key;
}
}
return(filter != null);
}
public bool GetMatchingFilter(MessageBuffer messageBuffer, out MessageFilter filter)
{
bool flag;
if (messageBuffer == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("messageBuffer");
}
Message message = messageBuffer.CreateMessage();
try
{
filter = this.InnerMatch(message);
flag = filter != null;
}
finally
{
message.Close();
}
return(flag);
}
private EndpointDispatcher(EndpointDispatcher baseEndpoint, IEnumerable <AddressHeader> headers)
{
EndpointAddressBuilder builder = new EndpointAddressBuilder(baseEndpoint.EndpointAddress);
foreach (AddressHeader header in headers)
{
builder.Headers.Add(header);
}
System.ServiceModel.EndpointAddress address = builder.ToEndpointAddress();
this.addressFilter = new EndpointAddressMessageFilter(address);
this.contractFilter = baseEndpoint.ContractFilter;
this.contractName = baseEndpoint.ContractName;
this.contractNamespace = baseEndpoint.ContractNamespace;
this.dispatchRuntime = baseEndpoint.DispatchRuntime;
this.filterPriority = baseEndpoint.FilterPriority + 1;
this.originalAddress = address;
if (PerformanceCounters.PerformanceCountersEnabled)
{
this.perfCounterId = baseEndpoint.perfCounterId;
this.perfCounterBaseId = baseEndpoint.perfCounterBaseId;
}
this.id = baseEndpoint.id;
}
public void AddEndpoint(EndpointDispatcher endpoint)
{
lock (ThisLock)
{
MessageFilter filter = endpoint.EndpointFilter;
int priority = endpoint.FilterPriority;
if (filters == null)
{
if (this.cachedEndpoints == null)
{
this.cachedEndpoints = new List <EndpointDispatcher>(optimizationThreshold);
}
if (this.cachedEndpoints.Count < optimizationThreshold)
{
this.cachedEndpoints.Add(endpoint);
}
else
{
filters = new MessageFilterTable <EndpointDispatcher>();
for (int i = 0; i < this.cachedEndpoints.Count; i++)
{
int cachedPriority = cachedEndpoints[i].FilterPriority;
MessageFilter cachedFilter = cachedEndpoints[i].EndpointFilter;
filters.Add(cachedFilter, cachedEndpoints[i], cachedPriority);
}
filters.Add(filter, endpoint, priority);
this.cachedEndpoints = null;
}
}
else
{
filters.Add(filter, endpoint, priority);
}
}
}
// Umm, this API is ugly, since it or its members will
// anyways require ServiceEndpoint, those arguments are
// likely to be replaced by ServiceEndpoint (especially
// considering about possible EndpointAddress inconsistency).
public EndpointDispatcher(EndpointAddress address,
string contractName, string contractNamespace)
{
if (contractName == null)
{
throw new ArgumentNullException("contractName");
}
if (contractNamespace == null)
{
throw new ArgumentNullException("contractNamespace");
}
if (address == null)
{
throw new ArgumentNullException("address");
}
this.address = address;
contract_name = contractName;
contract_ns = contractNamespace;
dispatch_runtime = new DispatchRuntime(this, null);
this.address_filter = new EndpointAddressMessageFilter(address);
}
public void Add(MessageFilter filter, TFilterData data)
{
}
public bool ContainsKey(MessageFilter filter)
{
return(this.filters.ContainsKey(filter));
}
public bool GetMatchingFilter(System.ServiceModel.Channels.MessageBuffer messageBuffer, out MessageFilter filter)
{
filter = default(MessageFilter);
return(default(bool));
}
public bool GetMatchingFilter(System.Xml.XPath.XPathNavigator navigator, out MessageFilter filter)
{
filter = default(MessageFilter);
return(default(bool));
}
public bool ContainsKey(MessageFilter filter)
{
return(default(bool));
}
public bool GetMatchingFilter(SeekableXPathNavigator navigator, out MessageFilter filter)
{
filter = default(MessageFilter);
return(default(bool));
}
public bool GetMatchingFilter(MessageBuffer buffer, out MessageFilter result)
{
throw new NotImplementedException();
}
public bool TryGetValue(MessageFilter filter, out TFilterData data)
{
data = default(TFilterData);
return(default(bool));
}
public bool Remove(MessageFilter filter)
{
return(default(bool));
}
public void Add(MessageFilter filter, TFilterData data)
{
this.Add(filter, data, this.defaultPriority);
}
public bool TryGetValue(MessageFilter filter, out TFilterData data)
{
return(this.filters.TryGetValue(filter, out data));
}
internal Entry(MessageFilter f, TFilterData d)
{
filter = f;
data = d;
}
internal Entry(MessageFilter f, TFilterData d, int p)
{
this.filter = f;
this.data = d;
this.priority = p;
}
