private bool TryCacheLookup(BaseUriWithWildcard key, out TItem item)
{
object value = this.lookupCache.GetValue(this.ThisLock, key);
item = (value == DBNull.Value ? default(TItem) : (TItem)value);
return(value != null);
}
private BaseUriWithWildcard(string protocol, int defaultPort, string binding, int segmentCount, string path, string sampleBinding)
{
string[] strArrays = BaseUriWithWildcard.SplitBinding(binding);
if ((int)strArrays.Length != segmentCount)
{
ExceptionUtility exceptionUtility = Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility;
string hostingMisformattedBinding = Resources.Hosting_MisformattedBinding;
object[] objArray = new object[] { binding, protocol, sampleBinding };
throw exceptionUtility.ThrowHelperError(new UriFormatException(Microsoft.ServiceBus.SR.GetString(hostingMisformattedBinding, objArray)));
}
int num = segmentCount - 1;
string str = this.ParseHostAndHostNameComparisonMode(strArrays[num]);
int num1 = -1;
int num2 = num - 1;
num = num2;
if (num2 >= 0)
{
string str1 = strArrays[num].Trim();
if (!string.IsNullOrEmpty(str1) && !int.TryParse(str1, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out num1))
{
ExceptionUtility exceptionUtility1 = Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility;
string hostingMisformattedPort = Resources.Hosting_MisformattedPort;
object[] objArray1 = new object[] { protocol, binding, str1 };
throw exceptionUtility1.ThrowHelperError(new UriFormatException(Microsoft.ServiceBus.SR.GetString(hostingMisformattedPort, objArray1)));
}
if (num1 == defaultPort)
{
num1 = -1;
}
}
try
{
this.baseAddress = (new UriBuilder(protocol, str, num1, path)).Uri;
}
catch (Exception exception1)
{
Exception exception = exception1;
if (!Fx.IsFatal(exception))
{
if (Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ShouldTraceError)
{
Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Error);
}
ExceptionUtility exceptionUtility2 = Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility;
string hostingMisformattedBindingData = Resources.Hosting_MisformattedBindingData;
object[] objArray2 = new object[] { binding, protocol };
throw exceptionUtility2.ThrowHelperError(new UriFormatException(Microsoft.ServiceBus.SR.GetString(hostingMisformattedBindingData, objArray2)));
}
throw;
}
this.SetComparisonAddressAndHashCode();
}
public override bool Equals(object o)
{
BaseUriWithWildcard baseUriWithWildcard = o as BaseUriWithWildcard;
if (baseUriWithWildcard == null || baseUriWithWildcard.hashCode != this.hashCode || baseUriWithWildcard.hostNameComparisonMode != this.hostNameComparisonMode || baseUriWithWildcard.comparand.Port != this.comparand.Port)
{
return(false);
}
if (!object.ReferenceEquals(baseUriWithWildcard.comparand.Scheme, this.comparand.Scheme))
{
return(false);
}
return(this.comparand.Address.Equals(baseUriWithWildcard.comparand.Address));
}
public void SetData(TData data, BaseUriWithWildcard path)
{
this.path = path;
if (!this.useWeakReferences)
{
this.data = data;
return;
}
if (data == null)
{
this.weakData = null;
return;
}
this.weakData = new WeakReference((object)data);
}
private void AddToCache(BaseUriWithWildcard key, TItem item)
{
object value;
HopperCache hopperCache = this.lookupCache;
BaseUriWithWildcard baseUriWithWildcard = key;
TItem tItem = item;
if (tItem != null)
{
value = tItem;
}
else
{
value = DBNull.Value;
}
hopperCache.Add(baseUriWithWildcard, value);
}
public bool IsRegistered(BaseUriWithWildcard key)
{
bool flag;
SegmentHierarchyNode <TItem> segmentHierarchyNode;
Uri baseAddress = key.BaseAddress;
string[] path = UriPrefixTable <TItem> .UriSegmenter.ToPath(baseAddress, key.HostNameComparisonMode, this.includePortInComparison);
lock (this.ThisLock)
{
segmentHierarchyNode = this.FindDataNode(path, out flag);
}
if (!flag || segmentHierarchyNode == null)
{
return(false);
}
return(segmentHierarchyNode.Data != null);
}
public void RegisterUri(Uri uri, HostNameComparisonMode hostNameComparisonMode, TItem item)
{
lock (this.ThisLock)
{
this.ClearCache();
BaseUriWithWildcard baseUriWithWildcard = new BaseUriWithWildcard(uri, hostNameComparisonMode);
SegmentHierarchyNode <TItem> segmentHierarchyNode = this.FindOrCreateNode(baseUriWithWildcard);
if (segmentHierarchyNode.Data != null)
{
ExceptionUtility exceptionUtility = Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility;
string duplicateRegistration = Resources.DuplicateRegistration;
object[] objArray = new object[] { uri };
throw exceptionUtility.ThrowHelperError(new InvalidOperationException(Microsoft.ServiceBus.SR.GetString(duplicateRegistration, objArray)));
}
segmentHierarchyNode.SetData(item, baseUriWithWildcard);
UriPrefixTable <TItem> uriPrefixTable = this;
uriPrefixTable.count = uriPrefixTable.count + 1;
}
}
private SegmentHierarchyNode <TItem> FindOrCreateNode(BaseUriWithWildcard baseUri)
{
SegmentHierarchyNode <TItem> segmentHierarchyNode;
string[] path = UriPrefixTable <TItem> .UriSegmenter.ToPath(baseUri.BaseAddress, baseUri.HostNameComparisonMode, this.includePortInComparison);
SegmentHierarchyNode <TItem> segmentHierarchyNode1 = this.root;
for (int i = 0; i < (int)path.Length; i++)
{
if (!segmentHierarchyNode1.TryGetChild(path[i], out segmentHierarchyNode))
{
segmentHierarchyNode = new SegmentHierarchyNode <TItem>(path[i], this.useWeakReferences);
segmentHierarchyNode1.SetChildNode(path[i], segmentHierarchyNode);
}
segmentHierarchyNode1 = segmentHierarchyNode;
}
return(segmentHierarchyNode1);
}
public bool TryLookupUri(Uri uri, HostNameComparisonMode hostNameComparisonMode, out TItem item)
{
bool flag;
bool flag1;
BaseUriWithWildcard baseUriWithWildcard = new BaseUriWithWildcard(uri, hostNameComparisonMode);
if (this.TryCacheLookup(baseUriWithWildcard, out item))
{
return(item != null);
}
lock (this.ThisLock)
{
SegmentHierarchyNode <TItem> segmentHierarchyNode = this.FindDataNode(UriPrefixTable <TItem> .UriSegmenter.ToPath(baseUriWithWildcard.BaseAddress, hostNameComparisonMode, this.includePortInComparison), out flag);
if (segmentHierarchyNode != null)
{
item = segmentHierarchyNode.Data;
}
this.AddToCache(baseUriWithWildcard, item);
flag1 = item != null;
}
return(flag1);
}
