From fbafd68cd11404708d7124fb0a9246e04f7131e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C4=9Bj=20=C5=A0t=C3=A1gl?= <stagl.matej@centrum.cz>
Date: Wed, 8 Jan 2025 17:51:40 +0100
Subject: [PATCH] make cache DRY

---
 FastCloner/Code/FastClonerCache.cs | 77 +++++++++++++++---------------
 1 file changed, 38 insertions(+), 39 deletions(-)

diff --git a/FastCloner/Code/FastClonerCache.cs b/FastCloner/Code/FastClonerCache.cs
index cc0b3dc..3f8860c 100644
--- a/FastCloner/Code/FastClonerCache.cs
+++ b/FastCloner/Code/FastClonerCache.cs
@@ -4,46 +4,18 @@ namespace FastCloner.Code;
 
 internal static class FastClonerCache
 {
-    private static readonly ConcurrentDictionary<Type, Lazy<object?>> classCache = new ConcurrentDictionary<Type, Lazy<object?>>();
-    private static readonly ConcurrentDictionary<Type, Lazy<object>> structCache = new ConcurrentDictionary<Type, Lazy<object>>();
-    private static readonly ConcurrentDictionary<Type, Lazy<object>> deepClassToCache = new ConcurrentDictionary<Type, Lazy<object>>();
-    private static readonly ConcurrentDictionary<Type, Lazy<object>> shallowClassToCache = new ConcurrentDictionary<Type, Lazy<object>>();
-    private static readonly ConcurrentDictionary<Tuple<Type, Type>, Lazy<object>> typeConvertCache = new ConcurrentDictionary<Tuple<Type, Type>, Lazy<object>>();
-    
-    public static object? GetOrAddClass(Type type, Func<Type, object?> valueFactory)
-    {
-        Lazy<object?> lazy = classCache.GetOrAdd(type, t => new Lazy<object?>(() => valueFactory(t), LazyThreadSafetyMode.ExecutionAndPublication));
-        return lazy.Value;
-    }
-
-    public static object GetOrAddStructAsObject(Type type, Func<Type, object> valueFactory)
-    {
-        Lazy<object> lazy = structCache.GetOrAdd(type, t => new Lazy<object>(() => valueFactory(t), LazyThreadSafetyMode.ExecutionAndPublication));
-        return lazy.Value;
-    }
-
-    public static object GetOrAddDeepClassTo(Type type, Func<Type, object> valueFactory)
-    {
-        Lazy<object> lazy = deepClassToCache.GetOrAdd(type, t => new Lazy<object>(() => valueFactory(t), LazyThreadSafetyMode.ExecutionAndPublication));
-        return lazy.Value;
-    }
-
-    public static object GetOrAddShallowClassTo(Type type, Func<Type, object> valueFactory)
-    {
-        Lazy<object> lazy = shallowClassToCache.GetOrAdd(type, t => new Lazy<object>(() => valueFactory(t), LazyThreadSafetyMode.ExecutionAndPublication));
-        return lazy.Value;
-    }
+    private static readonly ClrCache<object?> classCache = new ClrCache<object?>();
+    private static readonly ClrCache<object> structCache = new ClrCache<object>();
+    private static readonly ClrCache<object> deepClassToCache = new ClrCache<object>();
+    private static readonly ClrCache<object> shallowClassToCache = new ClrCache<object>();
+    private static readonly ConcurrentLazyCache<object> typeConvertCache = new ConcurrentLazyCache<object>();
 
-    public static T GetOrAddConvertor<T>(Type from, Type to, Func<Type, Type, T> adder)
-    {
-        Tuple<Type, Type> key = new Tuple<Type, Type>(from, to);
-        Lazy<object> lazy = typeConvertCache.GetOrAdd(key, tuple => new Lazy<object>(() => adder(tuple.Item1, tuple.Item2), LazyThreadSafetyMode.ExecutionAndPublication));
-        return (T)lazy.Value;
-    }
+    public static object? GetOrAddClass(Type type, Func<Type, object?> valueFactory) => classCache.GetOrAdd(type, valueFactory);
+    public static object GetOrAddStructAsObject(Type type, Func<Type, object> valueFactory) => structCache.GetOrAdd(type, valueFactory);
+    public static object GetOrAddDeepClassTo(Type type, Func<Type, object> valueFactory) => deepClassToCache.GetOrAdd(type, valueFactory);
+    public static object GetOrAddShallowClassTo(Type type, Func<Type, object> valueFactory) => shallowClassToCache.GetOrAdd(type, valueFactory);
+    public static T GetOrAddConvertor<T>(Type from, Type to, Func<Type, Type, T> valueFactory) => (T)typeConvertCache.GetOrAdd(from, to, (f, t) => valueFactory(f, t));
 
-    /// <summary>
-    /// This method can be used when we switch between safe / unsafe variants (for testing)
-    /// </summary>
     public static void ClearCache()
     {
         classCache.Clear();
@@ -52,4 +24,31 @@ public static void ClearCache()
         shallowClassToCache.Clear();
         typeConvertCache.Clear();
     }
-}
\ No newline at end of file
+    
+    private class ClrCache<TValue>
+    {
+        private readonly ConcurrentDictionary<Type, Lazy<TValue>> cache = new ConcurrentDictionary<Type, Lazy<TValue>>();
+
+        public TValue GetOrAdd(Type type, Func<Type, TValue> valueFactory)
+        {
+            Lazy<TValue> lazy = cache.GetOrAdd(type, t => new Lazy<TValue>(() => valueFactory(t), LazyThreadSafetyMode.ExecutionAndPublication));
+            return lazy.Value;
+        }
+
+        public void Clear() => cache.Clear();
+    }
+
+    private class ConcurrentLazyCache<TValue>
+    {
+        private readonly ConcurrentDictionary<Tuple<Type, Type>, Lazy<TValue>> cache = [];
+
+        public TValue GetOrAdd(Type from, Type to, Func<Type, Type, TValue> valueFactory)
+        {
+            Tuple<Type, Type> key = new Tuple<Type, Type>(from, to);
+            Lazy<TValue> lazy = cache.GetOrAdd(key, tuple => new Lazy<TValue>(() => valueFactory(tuple.Item1, tuple.Item2), LazyThreadSafetyMode.ExecutionAndPublication));
+            return lazy.Value;
+        }
+
+        public void Clear() => cache.Clear();
+    }
+}