/// <summary>
/// Main entrypoint of this cache. Tries to look up a string that matches the given internable. If it succeeds, returns
/// the string and sets cacheHit to true. If the string is not found, calls ExpensiveConvertToString on the internable,
/// adds the resulting string to the cache, and returns it, setting cacheHit to false.
/// </summary>
/// <param name="internable">The internable describing the string we're looking for.</param>
/// <returns>A string matching the given internable.</returns>
public string GetOrCreateEntry(ref InternableString internable, out bool cacheHit)
{
int hashCode = internable.GetHashCode();
StringWeakHandle handle;
string? result;
bool addingNewHandle = false;
lock (_stringsByHashCode)
{
if (_stringsByHashCode.TryGetValue(hashCode, out handle))
{
result = handle.GetString(ref internable);
if (result != null)
{
cacheHit = true;
return(result);
}
}
else
{
handle = new StringWeakHandle();
addingNewHandle = true;
}
// We don't have the string in the cache - create it.
result = internable.ExpensiveConvertToString();
// Set the handle to reference the new string.
handle.SetString(result);
if (addingNewHandle)
{
// Prevent the dictionary from growing forever with GC handles that don't reference live strings anymore.
if (_stringsByHashCode.Count >= _scavengeThreshold)
{
// Get rid of unused handles.
ScavengeNoLock();
// And do this again when the number of handles reaches double the current after-scavenge number.
_scavengeThreshold = _stringsByHashCode.Count * 2;
}
}
_stringsByHashCode[hashCode] = handle;
}
cacheHit = false;
return(result);
}
/// <summary>
/// Main entrypoint of this cache. Tries to look up a string that matches the given internable. If it succeeds, returns
/// the string and sets cacheHit to true. If the string is not found, calls ExpensiveConvertToString on the internable,
/// adds the resulting string to the cache, and returns it, setting cacheHit to false.
/// </summary>
/// <param name="internable">The internable describing the string we're looking for.</param>
/// <param name="cacheHit">true if match found in cache, false otherwise.</param>
/// <returns>A string matching the given internable.</returns>
public string GetOrCreateEntry(ref InternableString internable, out bool cacheHit)
{
int hashCode = internable.GetHashCode();
StringWeakHandle?handle;
string? result;
// Get the existing handle from the cache and lock it while we're dereferencing it to prevent a race with the Scavenge
// method running on another thread and freeing the handle from underneath us.
if (_stringsByHashCode.TryGetValue(hashCode, out handle))
{
lock (handle)
{
result = handle.GetString(ref internable);
if (result != null)
{
cacheHit = true;
return(result);
}
// We have the handle but it's not referencing the right string - create the right string and store it in the handle.
result = internable.ExpensiveConvertToString();
handle.SetString(result);
cacheHit = false;
return(result);
}
}
// We don't have the handle in the cache - create the right string, store it in the handle, and add the handle to the cache.
result = internable.ExpensiveConvertToString();
handle = new StringWeakHandle();
handle.SetString(result);
_stringsByHashCode.TryAdd(hashCode, handle);
// Remove unused handles if our heuristic indicates that it would be productive.
int scavengeThreshold = _scavengeThreshold;
if (_stringsByHashCode.Count >= scavengeThreshold)
{
// Before we start scavenging set _scavengeThreshold to a high value to effectively lock other threads from
// running Scavenge at the same time.
if (Interlocked.CompareExchange(ref _scavengeThreshold, int.MaxValue, scavengeThreshold) == scavengeThreshold)
{
try
{
// Get rid of unused handles.
Scavenge();
}
finally
{
// And do this again when the number of handles reaches double the current after-scavenge number.
_scavengeThreshold = _stringsByHashCode.Count * 2;
}
}
}
cacheHit = false;
return(result);
}