/// <summary>
/// WeakIntern the given InternableString.
/// </summary>
public string InternableToString(ref InternableString candidate)
{
if (candidate.Length == 0)
{
return(string.Empty);
}
InternResult resultForStatistics = Intern(ref candidate, out string internedString);
#if DEBUG
string expectedString = candidate.ExpensiveConvertToString();
if (!String.Equals(internedString, expectedString))
{
throw new InvalidOperationException(String.Format("Interned string {0} should have been {1}", internedString, expectedString));
}
#endif
if (_internCallCountsByString != null)
{
lock (_internCallCountsByString)
{
switch (resultForStatistics)
{
case InternResult.FoundInWeakStringCache:
_regularInternHits++;
break;
case InternResult.AddedToWeakStringCache:
_regularInternMisses++;
break;
}
_internCallCountsByString.TryGetValue(internedString, out int priorCount);
_internCallCountsByString[internedString] = priorCount + 1;
if (!candidate.ReferenceEquals(internedString))
{
// Reference changed so 'candidate' is now released and should save memory.
_internEliminatedStrings++;
_internEliminatedChars += candidate.Length;
}
}
}
return(internedString);
}
/// <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);
}