Rename factory

BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs

@@ -16,7 +16,7 @@ internal AsyncConcurrentLruBuilder(LruInfo<K> info)
         ///<inheritdoc/>
         public override IAsyncCache<K, V> Build()
         {
-            return LruFactory<K, V>.CreateConcurrent(this.info) as IAsyncCache<K, V>;
+            return ConcurrentLru.Create<K, V>(this.info) as IAsyncCache<K, V>;
         }
     }
 }

BitFaster.Caching/Lru/LruFactory.cs → BitFaster.Caching/Lru/ConcurrentLru.cs

@@ -1,19 +1,19 @@
-using System.Linq.Expressions;
+
 using BitFaster.Caching.Lru.Builder;
 
 namespace BitFaster.Caching.Lru
 {
     /// <summary>
     /// Factory class for creating ConcurrentLru variants.
     /// </summary>
-    internal static class LruFactory<K, V>
+    internal static class ConcurrentLru
     {
         /// <summary>
         /// Creates a ConcurrentLru instance based on the provided LruInfo.
         /// </summary>
         /// <param name="info">The LruInfo</param>
         /// <returns>A ConcurrentLru</returns>
-        internal static ICache<K, V> CreateConcurrent(LruInfo<K> info)
+        internal static ICache<K, V> Create<K, V>(LruInfo<K> info)
         {
             if (info.TimeToExpireAfterWrite.HasValue && info.TimeToExpireAfterAccess.HasValue)
                 Throw.InvalidOp("Specifying both ExpireAfterWrite and ExpireAfterAccess is not supported.");
@@ -23,13 +23,13 @@ internal static ICache<K, V> CreateConcurrent(LruInfo<K> info)
                 (true, false, false) => new ConcurrentLru<K, V>(info.ConcurrencyLevel, info.Capacity, info.KeyComparer),
                 (true, true, false) => new ConcurrentTLru<K, V>(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value),
                 (false, true, false) => new FastConcurrentTLru<K, V>(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value),
-                (true, false, true) => CreateExpireAfterAccess<TelemetryPolicy<K, V>>(info),
-                (false, false, true) => CreateExpireAfterAccess<NoTelemetryPolicy<K, V>>(info),
+                (true, false, true) => CreateExpireAfterAccess<K, V, TelemetryPolicy<K, V>>(info),
+                (false, false, true) => CreateExpireAfterAccess<K, V, NoTelemetryPolicy<K, V>>(info),
                 _ => new FastConcurrentLru<K, V>(info.ConcurrencyLevel, info.Capacity, info.KeyComparer),
             };
         }
 
-        private static ICache<K, V> CreateExpireAfterAccess<TP>(LruInfo<K> info) where TP : struct, ITelemetryPolicy<K, V>
+        private static ICache<K, V> CreateExpireAfterAccess<K, V, TP>(LruInfo<K> info) where TP : struct, ITelemetryPolicy<K, V>
         {
             return new ConcurrentLruCore<K, V, LongTickCountLruItem<K, V>, AfterAccessLongTicksPolicy<K, V>, TP>(
                 info.ConcurrencyLevel, info.Capacity, info.KeyComparer, new AfterAccessLongTicksPolicy<K, V>(info.TimeToExpireAfterAccess.Value), default);

BitFaster.Caching/Lru/ConcurrentLruBuilder.cs

@@ -40,7 +40,7 @@ internal ConcurrentLruBuilder(LruInfo<K> info)
         ///<inheritdoc/>
         public override ICache<K, V> Build()
         {
-            return LruFactory<K, V>.CreateConcurrent(this.info);
+            return ConcurrentLru.Create<K, V>(this.info);
         }
     }
 }