Use .NET Memory Caching

Signed-off-by: Jann Flepp <[email protected]>

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 = new MemoryCache(nameof(ArchitectureCache));
 
         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/ArchitectureCacheKeyTests.cs

@@ -35,22 +35,10 @@ public ArchitectureCacheKeyTests()
         private readonly ArchitectureCacheKey _duplicateArchitectureCacheKey;
 
         [Fact]
-        public void ArchitectureCacheKeyContentEquivalentsAreEqual()
+        public void ArchitectureCacheKeyContentEquivalentsAreStringEqual()
         {
             object contentEquivalent = new ArchitectureCacheKey();
-            Assert.True(_architectureCacheKey.Equals(contentEquivalent));
-        }
-
-        [Fact]
-        public void ArchitectureCacheKeyDoesNotEqualNull()
-        {
-            Assert.False(_architectureCacheKey.Equals((object)null));
-        }
-
-        [Fact]
-        public void ArchitectureCacheKeyIsEqualToItself()
-        {
-            Assert.True(_architectureCacheKey.Equals(_architectureCacheKey));
+            Assert.Equal(_architectureCacheKey, (ArchitectureCacheKey)contentEquivalent, ArchitectureCacheKeysHaveSameToString);
         }
 
         [Fact]
@@ -62,7 +50,7 @@ public void DuplicateAssemblies()
             duplicateCacheKey.Add(_baseClassModuleName, null);
             duplicateCacheKey.Add(_baseClassModuleName, null);
 
-            Assert.Equal(_architectureCacheKey, duplicateCacheKey);
+            Assert.Equal(_architectureCacheKey, duplicateCacheKey, ArchitectureCacheKeysHaveSameToString);
         }
 
         [Fact]
@@ -75,7 +63,7 @@ public void DuplicateAssembliesDifferentOrder()
             reverseOrderCacheKey.Add(_architectureCacheTestsClassModuleName, null);
             reverseOrderCacheKey.Add(_baseClassModuleName, null);
 
-            Assert.Equal(_architectureCacheKey, reverseOrderCacheKey);
+            Assert.Equal(_architectureCacheKey, reverseOrderCacheKey, ArchitectureCacheKeysHaveSameToString);
         }
 
         [Fact]
@@ -87,7 +75,7 @@ public void DuplicateFilteredNamespaces()
             duplicateCacheKey.Add(_baseClassModuleName, _memberDependencyTests);
             duplicateCacheKey.Add(_baseClassModuleName, _memberDependencyTests);
 
-            Assert.Equal(_architectureCacheKey, duplicateCacheKey);
+            Assert.Equal(_architectureCacheKey, duplicateCacheKey, ArchitectureCacheKeysHaveSameToString);
         }
 
         [Fact]
@@ -100,7 +88,7 @@ public void DuplicateNamespacesDifferentOrder()
             reverseOrderCacheKey.Add(_baseClassModuleName, _attributeDependencyTests);
             reverseOrderCacheKey.Add(_baseClassModuleName, _memberDependencyTests);
 
-            Assert.Equal(_architectureCacheKey, reverseOrderCacheKey);
+            Assert.Equal(_architectureCacheKey, reverseOrderCacheKey, ArchitectureCacheKeysHaveSameToString);
         }
 
         [Fact]
@@ -109,16 +97,21 @@ public void SameArchitecturesProduceSameArchitectureCacheKey()
             _architectureCacheKey.Add(_baseClassModuleName, null);
             _duplicateArchitectureCacheKey.Add(_baseClassModuleName, null);
 
-            Assert.Equal(_architectureCacheKey, _duplicateArchitectureCacheKey);
+            Assert.Equal(_architectureCacheKey, _duplicateArchitectureCacheKey, ArchitectureCacheKeysHaveSameToString);
         }
 
         [Fact]
-        public void SameObjectReferenceIsSameArchitectureCacheKet()
+        public void SameObjectReferenceIsSameArchitectureCacheKey()
         {
             _architectureCacheKey.Add(_baseClassModuleName, null);
             object referenceDuplicate = _architectureCacheKey;
 
             Assert.True(_architectureCacheKey.Equals(referenceDuplicate));
         }
+
+        private static bool ArchitectureCacheKeysHaveSameToString(ArchitectureCacheKey first, ArchitectureCacheKey second)
+        {
+            return first.ToString().Equals(second.ToString());
+        }
     }
 }

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

@@ -4,9 +4,9 @@ namespace ArchUnitNETTests.Domain
 {
     public class TestArchitectureCache : ArchitectureCache
     {
-        public int Size()
+        public long Size()
         {
-            return Cache.Count;
+            return _cache.GetCount();
         }
     }
 }