Refactor Reference.Counter to use ConcurrentDictionary for thread safety and improve reference management

Author: IvanMurzak

Assets/_PackageRoot/Runtime/ImageLoader.LoadSpriteRef.cs

@@ -34,7 +34,8 @@ public static Future<Reference<Sprite>> LoadSpriteRef(string url, Vector2 pivot,
             future.LoadingFromSource    (() =>     futureRef.Loading(FutureLoadingFrom.Source));
             future.LoadedFromSource     (sprite => futureRef.Loaded(new Reference<Sprite>(future.Url, sprite), FutureLoadedFrom.Source));
             future.Failed               (futureRef.FailToLoad);
-            futureRef.Canceled          (future.Cancel);
+
+            futureRef.Canceled(future.Cancel);
 
             InternalLoadSprite(future, pivot, textureFormat, ignoreImageNotFoundError);
             return futureRef;
@@ -43,14 +44,13 @@ public static Future<Reference<Sprite>> LoadSpriteRef(string url, Vector2 pivot,
         /// <summary>
         /// Clear all references to all loaded sprites
         /// </summary>
-        /// <returns>Returns sprite asynchronously </returns>
         public static void ClearRef() => Reference<Sprite>.Clear();
 
         /// <summary>
         /// Clear all references to a single loaded sprites by URL
         /// </summary>
         /// <param name="url">URL to the picture, web or local</param>
-        /// <returns>Returns sprite asynchronously </returns>
-        public static void ClearRef(string url) => Reference<Sprite>.Clear(url);
+        /// <returns>Returns operation status boolean</returns>
+        public static bool ClearRef(string url) => Reference<Sprite>.Clear(url);
     }
 }

Assets/_PackageRoot/Runtime/Reference.Counter.cs

@@ -1,20 +1,23 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 
 namespace Extensions.Unity.ImageLoader
 {
     public partial class Reference<T> : IDisposable
     {
-        private volatile static Dictionary<string, int> referenceCounters = new Dictionary<string, int>();
+        private volatile static ConcurrentDictionary<string, int> referenceCounters = new ConcurrentDictionary<string, int>();
         internal static void Clear()
         {
             lock (referenceCounters) referenceCounters.Clear();
             EventOnClearAll?.Invoke();
         }
-        internal static void Clear(string url)
+        internal static bool Clear(string url)
         {
-            lock (referenceCounters) referenceCounters.Remove(url);
+            var result = false;
+            lock (referenceCounters) result = referenceCounters.Remove(url, out var _);
             EventOnClearUrl?.Invoke(url);
+            return result;
         }
         public static int Counter(string url)
         {

Assets/_PackageRoot/Runtime/Reference.cs

@@ -29,7 +29,7 @@ internal Reference(string url, T value)
 
             lock (referenceCounters)
             {
-                referenceCounters[url] = Math.Max(0, referenceCounters.GetValueOrDefault(url, 0)) + 1;
+                referenceCounters.AddOrUpdate(url, 1, (key, oldValue) => oldValue + 1);
                 if (ImageLoader.settings.debugLevel <= DebugLevel.Log)
                     Debug.Log($"[ImageLoader] Ref[id={id}] Reference created [{referenceCounters[url]}] URL={url}");
             }
@@ -62,14 +62,10 @@ public void Dispose()
 
             lock (referenceCounters)
             {
-                if (referenceCounters.ContainsKey(Url))
-                    referenceCounters[Url]--;
+                referenceCounters.AddOrUpdate(Url, 0, (key, oldValue) => oldValue - 1);
 
-                if (referenceCounters.GetValueOrDefault(Url) < 0)
-                {
-                    if (ImageLoader.settings.debugLevel <= DebugLevel.Warning)
-                        Debug.LogError($"[ImageLoader] Ref[id={id}] Reference dispose has negative counter URL={Url}");
-                }
+                if (ImageLoader.settings.debugLevel <= DebugLevel.Warning && referenceCounters.GetValueOrDefault(Url) < 0)
+                    Debug.LogWarning($"[ImageLoader] Ref[id={id}] Reference dispose has negative counter URL={Url}");
 
                 if (Keep)
                 {
@@ -81,7 +77,7 @@ public void Dispose()
                 if (ImageLoader.settings.debugLevel <= DebugLevel.Log)
                     Debug.Log($"[ImageLoader] Ref[id={id}] Reference dispose of URL={Url}");
 
-                if (!referenceCounters.ContainsKey(Url) || referenceCounters[Url] == 0)
+                if (referenceCounters.GetValueOrDefault(Url) == 0)
                     ImageLoader.ClearMemoryCache(Url);
             }
         }