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