Use .NET Memory Caching

Author: fl3pp

ArchUnitNET/ArchUnitNET.csproj

@@ -22,6 +22,7 @@
     <PackageReference Include="Mono.Cecil" Version="0.11.6" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="System.ValueTuple" Version="4.5.0" />
+    <PackageReference Include="System.Runtime.Caching" Version="4.5.0" />
   </ItemGroup>
   <ItemGroup>
     <None Include="../README.md" Pack="true" PackagePath="" />

ArchUnitNET/Domain/ArchitectureCache.cs

@@ -1,28 +1,23 @@
-using System.Collections.Concurrent;
+using System.Runtime.Caching;
 
 namespace ArchUnitNET.Domain
 {
     public class ArchitectureCache
     {
-        protected readonly ConcurrentDictionary<ArchitectureCacheKey, Architecture> Cache =
-            new ConcurrentDictionary<ArchitectureCacheKey, Architecture>();
+        protected readonly MemoryCache _cache = MemoryCache.Default;
 
         protected ArchitectureCache() { }
 
         public static ArchitectureCache Instance { get; } = new ArchitectureCache();
 
         public Architecture TryGetArchitecture(ArchitectureCacheKey architectureCacheKey)
         {
-            return Cache.TryGetValue(architectureCacheKey, out var matchArchitecture)
-                ? matchArchitecture
-                : null;
+            return _cache.Get(architectureCacheKey.ToString()) as Architecture;
         }
 
-        public bool Add(ArchitectureCacheKey architectureCacheKey, Architecture architecture)
+        public void Add(ArchitectureCacheKey architectureCacheKey, Architecture architecture)
         {
-            return Cache.TryAdd(architectureCacheKey, architecture);
+            _cache.Add(architectureCacheKey.ToString(), architecture, new CacheItemPolicy());
         }
-
-        public void Clear() => Cache.Clear();
     }
 }

ArchUnitNET/Domain/ArchitectureCacheKey.cs

@@ -5,48 +5,19 @@
 
 namespace ArchUnitNET.Domain
 {
-    public class ArchitectureCacheKey : IEquatable<ArchitectureCacheKey>
+    public class ArchitectureCacheKey
     {
         private readonly SortedSet<(string moduleName, string filter)> _architectureCacheKey =
             new SortedSet<(string moduleName, string filter)>(new ArchitectureCacheKeyComparer());
 
-        public bool Equals(ArchitectureCacheKey other)
-        {
-            return other != null
-                && _architectureCacheKey.SequenceEqual(other._architectureCacheKey);
-        }
-
         public void Add(string moduleName, string filter)
         {
             _architectureCacheKey.Add((moduleName, filter));
         }
 
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            return obj.GetType() == GetType() && Equals((ArchitectureCacheKey)obj);
-        }
-
-        public override int GetHashCode()
+        public override string ToString()
         {
-            unchecked
-            {
-                var hashCode = 397;
-                _architectureCacheKey.ForEach(tuple =>
-                {
-                    hashCode = (hashCode * 131) ^ tuple.GetHashCode();
-                });
-                return hashCode;
-            }
+            return string.Join(",", _architectureCacheKey);
         }
     }
 

ArchUnitNETTests/Domain/ArchitectureCacheTests.cs

@@ -44,17 +44,5 @@ public void GetExistingArchitecture()
                 _testEmptyArchitecture
             );
         }
-
-        [Fact]
-        public void CacheClear()
-        {
-            _testArchitectureCache.Add(_testArchitectureCacheKey, _testEmptyArchitecture);
-            Assert.Equal(
-                _testArchitectureCache.TryGetArchitecture(_testArchitectureCacheKey),
-                _testEmptyArchitecture
-            );
-            _testArchitectureCache.Clear();
-            Assert.Null(_testArchitectureCache.TryGetArchitecture(_testArchitectureCacheKey));
-        }
     }
 }

ArchUnitNETTests/Domain/TestArchitectureCache.cs

@@ -6,7 +6,7 @@ public class TestArchitectureCache : ArchitectureCache
     {
         public int Size()
         {
-            return Cache.Count;
+            return (int)_cache.GetCount();
         }
     }
 }