diff --git a/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs b/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs
index 9e12800c..bc00ecab 100644
--- a/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs
+++ b/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs
@@ -1,13 +1,16 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Atomic
 {
+    /// <summary>
+    /// A class that provides simple, lightweight exactly once initialization for values
+    /// stored in a cache.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
     [DebuggerDisplay("IsValueCreated={IsValueCreated}, Value={ValueIfCreated}")]
     public sealed class AsyncAtomicFactory<K, V>
     {
@@ -16,16 +19,30 @@ public sealed class AsyncAtomicFactory<K, V>
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
         private V value;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AsyncAtomicFactory{K, V}"/> class.
+        /// </summary>
         public AsyncAtomicFactory()
         {
             initializer = new Initializer();
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AsyncAtomicFactory{K, V}"/> class with the
+        /// specified value.
+        /// </summary>
+        /// <param name="value">The value.</param>
         public AsyncAtomicFactory(V value)
         {
             this.value = value;
         }
 
+        /// <summary>
+        /// Gets the value. If <see cref="IsValueCreated"/> is false, calling <see cref="GetValueAsync"/> will force initialization via the <paramref name="valueFactory"/> parameter.
+        /// </summary>
+        /// <param name="key">The key associated with the value.</param>
+        /// <param name="valueFactory">The value factory to use to create the value when it is not initialized.</param>
+        /// <returns>The value.</returns>
         public async ValueTask<V> GetValueAsync(K key, Func<K, Task<V>> valueFactory)
         {
             if (initializer == null)
@@ -36,8 +53,14 @@ public async ValueTask<V> GetValueAsync(K key, Func<K, Task<V>> valueFactory)
             return await CreateValueAsync(key, valueFactory).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Gets a value indicating whether the value has been initialized.
+        /// </summary>
         public bool IsValueCreated => initializer == null;
 
+        /// <summary>
+        /// Gets the value if it has been initialized, else default.
+        /// </summary>
         public V ValueIfCreated
         {
             get
@@ -66,7 +89,7 @@ private async ValueTask<V> CreateValueAsync(K key, Func<K, Task<V>> valueFactory
 
         private class Initializer
         {
-            private object syncLock = new object();
+            private readonly object syncLock = new object();
             private bool isInitialized;
             private Task<V> valueTask;
 
diff --git a/BitFaster.Caching/Atomic/AtomicFactory.cs b/BitFaster.Caching/Atomic/AtomicFactory.cs
index e153cd00..fb390d54 100644
--- a/BitFaster.Caching/Atomic/AtomicFactory.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactory.cs
@@ -1,13 +1,15 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
-using System.Text;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Atomic
 {
+    /// <summary>
+    /// A class that provides simple, lightweight exactly once initialization for values
+    /// stored in a cache.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
     [DebuggerDisplay("IsValueCreated={IsValueCreated}, Value={ValueIfCreated}")]
     public sealed class AtomicFactory<K, V>
     {
@@ -16,16 +18,30 @@ public sealed class AtomicFactory<K, V>
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
         private V value;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AtomicFactory{K, V}"/> class.
+        /// </summary>
         public AtomicFactory()
         {
             initializer = new Initializer();
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AtomicFactory{K, V}"/> class with the
+        /// specified value.
+        /// </summary>
+        /// <param name="value">The value.</param>
         public AtomicFactory(V value)
         {
             this.value = value;
         }
 
+        /// <summary>
+        /// Gets the value. If <see cref="IsValueCreated"/> is false, calling <see cref="GetValue"/> will force initialization via the <paramref name="valueFactory"/> parameter.
+        /// </summary>
+        /// <param name="key">The key associated with the value.</param>
+        /// <param name="valueFactory">The value factory to use to create the value when it is not initialized.</param>
+        /// <returns>The value.</returns>
         public V GetValue(K key, Func<K, V> valueFactory)
         {
             if (initializer == null)
@@ -36,8 +52,14 @@ public V GetValue(K key, Func<K, V> valueFactory)
             return CreateValue(key, valueFactory);
         }
 
+        /// <summary>
+        /// Gets a value indicating whether the value has been initialized.
+        /// </summary>
         public bool IsValueCreated => initializer == null;
 
+        /// <summary>
+        /// Gets the value if it has been initialized, else default.
+        /// </summary>
         public V ValueIfCreated
         {
             get
@@ -66,7 +88,7 @@ private V CreateValue(K key, Func<K, V> valueFactory)
 
         private class Initializer
         {
-            private object syncLock = new object();
+            private readonly object syncLock = new object();
             private bool isInitialized;
             private V value;
 
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs
index b1686c4e..934c9cdd 100644
--- a/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs
@@ -6,6 +6,11 @@
 
 namespace BitFaster.Caching.Atomic
 {
+    /// <summary>
+    /// A cache decorator for working with  <see cref="AsyncAtomicFactory{K, V}"/> wrapped values, giving exactly once initialization.
+    /// </summary>
+    /// <typeparam name="K">The type of keys in the cache.</typeparam>
+    /// <typeparam name="V">The type of values in the cache.</typeparam>
     [DebuggerDisplay("Count = {Count}")]
     public sealed class AtomicFactoryAsyncCache<K, V> : IAsyncCache<K, V>
     {
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
index 9fb08fd0..86f55d4f 100644
--- a/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
@@ -5,12 +5,21 @@
 
 namespace BitFaster.Caching.Atomic
 {
+    /// <summary>
+    /// A cache decorator for working with  <see cref="AtomicFactory{K, V}"/> wrapped values, giving exactly once initialization.
+    /// </summary>
+    /// <typeparam name="K">The type of keys in the cache.</typeparam>
+    /// <typeparam name="V">The type of values in the cache.</typeparam>
     [DebuggerDisplay("Count = {Count}")]
     public sealed class AtomicFactoryCache<K, V> : ICache<K, V>
     {
         private readonly ICache<K, AtomicFactory<K, V>> cache;
         private readonly Optional<ICacheEvents<K, V>> events;
 
+        /// <summary>
+        /// Initializes a new instance of the ScopedCache class with the specified inner cache.
+        /// </summary>
+        /// <param name="cache">The decorated cache.</param>
         public AtomicFactoryCache(ICache<K, AtomicFactory<K, V>> cache)
         {
             if (cache == null)
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs
index c22a7b31..ffb8cb9d 100644
--- a/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs
@@ -7,6 +7,11 @@
 
 namespace BitFaster.Caching.Atomic
 {
+    /// <summary>
+    /// A cache decorator for working with  <see cref="ScopedAsyncAtomicFactory{K, V}"/> wrapped values, giving exactly once initialization.
+    /// </summary>
+    /// <typeparam name="K">The type of keys in the cache.</typeparam>
+    /// <typeparam name="V">The type of values in the cache.</typeparam>
     [DebuggerDisplay("Count = {Count}")]
     public sealed class AtomicFactoryScopedAsyncCache<K, V> : IScopedAsyncCache<K, V> where V : IDisposable
     {
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs
index 42a78adc..ce4c7c8d 100644
--- a/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs
@@ -6,6 +6,11 @@
 
 namespace BitFaster.Caching.Atomic
 {
+    /// <summary>
+    /// A cache decorator for working with  <see cref="ScopedAtomicFactory{K, V}"/> wrapped values, giving exactly once initialization.
+    /// </summary>
+    /// <typeparam name="K">The type of keys in the cache.</typeparam>
+    /// <typeparam name="V">The type of values in the cache.</typeparam>
     [DebuggerDisplay("Count = {Count}")]
     public sealed class AtomicFactoryScopedCache<K, V> : IScopedCache<K, V> where V : IDisposable
     {
diff --git a/BitFaster.Caching/Atomic/ScopedAsyncAtomicFactory.cs b/BitFaster.Caching/Atomic/ScopedAsyncAtomicFactory.cs
index 86809900..c06da3cd 100644
--- a/BitFaster.Caching/Atomic/ScopedAsyncAtomicFactory.cs
+++ b/BitFaster.Caching/Atomic/ScopedAsyncAtomicFactory.cs
@@ -5,22 +5,39 @@
 
 namespace BitFaster.Caching.Atomic
 {
+    /// <summary>
+    /// A class that provides simple, lightweight exactly once initialization for scoped values
+    /// stored in a cache.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
     [DebuggerDisplay("IsValueCreated={initializer == null}, Value={ScopeIfCreated}")]
     public sealed class ScopedAsyncAtomicFactory<K, V> : IScoped<V>, IDisposable where V : IDisposable
     {
         private Scoped<V> scope;
         private Initializer initializer;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ScopedAsyncAtomicFactory{K, V}"/> class.
+        /// </summary>
         public ScopedAsyncAtomicFactory()
         {
             initializer = new Initializer();
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ScopedAsyncAtomicFactory{K, V}"/> class with the
+        /// specified value.
+        /// </summary>
+        /// <param name="value">The value.</param>
         public ScopedAsyncAtomicFactory(V value)
         {
             scope = new Scoped<V>(value);
         }
 
+        /// <summary>
+        /// Gets the scope if it has been initialized, else default.
+        /// </summary>
         public Scoped<V> ScopeIfCreated
         {
             get
@@ -34,6 +51,12 @@ public Scoped<V> ScopeIfCreated
             }
         }
 
+        /// <summary>
+        /// Attempts to create a lifetime for the scoped value. The lifetime guarantees the value is alive until 
+        /// the lifetime is disposed.
+        /// </summary>
+        /// <param name="lifetime">When this method returns, contains the Lifetime that was created, or the default value of the type if the operation failed.</param>
+        /// <returns>true if the Lifetime was created; otherwise false.</returns>
         public bool TryCreateLifetime(out Lifetime<V> lifetime)
         {
             if (scope?.IsDisposed ?? false || initializer != null)
@@ -45,6 +68,13 @@ public bool TryCreateLifetime(out Lifetime<V> lifetime)
             return scope.TryCreateLifetime(out lifetime);
         }
 
+        /// <summary>
+        /// Attempts to create a lifetime for the scoped value. The lifetime guarantees the value is alive until 
+        /// the lifetime is disposed.
+        /// </summary>
+        /// <param name="key">The key associated with the scoped value.</param>
+        /// <param name="valueFactory">The value factory to use to create the scoped value when it is not initialized.</param>
+        /// <returns>true if the Lifetime was created; otherwise false. If the lifetime was created, the new lifetime is also returned.</returns>
         public async ValueTask<(bool success, Lifetime<V> lifetime)> TryCreateLifetimeAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
         {
             // if disposed, return
@@ -73,6 +103,11 @@ private async ValueTask InitializeScopeAsync(K key, Func<K, Task<Scoped<V>>> val
                 initializer = null;
             }
         }
+
+        /// <summary>
+        /// Terminates the scope and disposes the value. Once the scope is terminated, it is no longer
+        /// possible to create new lifetimes for the value.
+        /// </summary>
         public void Dispose()
         {
             var init = initializer;
@@ -90,7 +125,7 @@ public void Dispose()
 
         private class Initializer
         {
-            private object syncLock = new object();
+            private readonly object syncLock = new object();
             private bool isTaskInitialized;
             private bool isTaskCompleted;
             private bool isDisposeRequested;
diff --git a/BitFaster.Caching/Atomic/ScopedAtomicFactory.cs b/BitFaster.Caching/Atomic/ScopedAtomicFactory.cs
index 32a6f46c..ee534ef0 100644
--- a/BitFaster.Caching/Atomic/ScopedAtomicFactory.cs
+++ b/BitFaster.Caching/Atomic/ScopedAtomicFactory.cs
@@ -4,26 +4,55 @@
 
 namespace BitFaster.Caching.Atomic
 {
-    // Requirements:
-    // 1. Exactly once disposal.
-    // 2. Exactly once invocation of value factory (synchronized create).
-    // 3. Resolve race between create dispose init, if disposed is called before value is created, scoped value is disposed for life.
+    /// <summary>
+    /// A class that provides simple, lightweight exactly once initialization for scoped values
+    /// stored in a cache.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
+    /// <remarks>
+    /// Requirements:
+    /// <list type="number">
+    ///    <item>
+    ///        <description>Exactly once disposal.</description>
+    ///    </item>
+    ///    <item>
+    ///        <term>Exactly once invocation of value factory</term>
+    ///        <description>Values are created atomically.</description>
+    ///    </item>
+    ///    <item>
+    ///        <term>Resolve race between create dispose init</term>
+    ///        <description>If disposed is called before value is created, scoped value is disposed for life.</description>
+    ///    </item>
+    ///</list>
+    /// </remarks>
     [DebuggerDisplay("IsValueCreated={initializer == null}, Value={ScopeIfCreated}")]
     public sealed class ScopedAtomicFactory<K, V> : IScoped<V>, IDisposable where V : IDisposable
     {
         private Scoped<V> scope;
         private Initializer initializer;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ScopedAtomicFactory{K, V}"/> class.
+        /// </summary>
         public ScopedAtomicFactory()
         {
             initializer = new Initializer();
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ScopedAtomicFactory{K, V}"/> class with the
+        /// specified value.
+        /// </summary>
+        /// <param name="value">The value.</param>
         public ScopedAtomicFactory(V value)
         {
             scope = new Scoped<V>(value);
         }
 
+        /// <summary>
+        /// Gets the scope if it has been initialized, else default.
+        /// </summary>
         public Scoped<V> ScopeIfCreated
         {
             get
@@ -37,6 +66,12 @@ public Scoped<V> ScopeIfCreated
             }
         }
 
+        /// <summary>
+        /// Attempts to create a lifetime for the scoped value. The lifetime guarantees the value is alive until 
+        /// the lifetime is disposed.
+        /// </summary>
+        /// <param name="lifetime">When this method returns, contains the Lifetime that was created, or the default value of the type if the operation failed.</param>
+        /// <returns>true if the Lifetime was created; otherwise false.</returns>
         public bool TryCreateLifetime(out Lifetime<V> lifetime)
         {
             if (scope?.IsDisposed ?? false || initializer != null)
@@ -48,6 +83,14 @@ public bool TryCreateLifetime(out Lifetime<V> lifetime)
             return scope.TryCreateLifetime(out lifetime);
         }
 
+        /// <summary>
+        /// Attempts to create a lifetime for the scoped value. The lifetime guarantees the value is alive until 
+        /// the lifetime is disposed.
+        /// </summary>
+        /// <param name="key">The key associated with the scoped value.</param>
+        /// <param name="valueFactory">The value factory to use to create the scoped value when it is not initialized.</param>
+        /// <param name="lifetime">When this method returns, contains the Lifetime that was created, or the default value of the type if the operation failed.</param>
+        /// <returns>true if the Lifetime was created; otherwise false.</returns>
         public bool TryCreateLifetime(K key, Func<K, Scoped<V>> valueFactory, out Lifetime<V> lifetime)
         {
             if(scope?.IsDisposed ?? false)
@@ -75,6 +118,11 @@ private void InitializeScope(K key, Func<K, Scoped<V>> valueFactory)
                 initializer = null;
             }
         }
+
+        /// <summary>
+        /// Terminates the scope and disposes the value. Once the scope is terminated, it is no longer
+        /// possible to create new lifetimes for the value.
+        /// </summary>
         public void Dispose()
         {
             var init = initializer;
@@ -89,7 +137,7 @@ public void Dispose()
 
         private class Initializer
         {
-            private object syncLock = new object();
+            private readonly object syncLock = new object();
             private bool isInitialized;
             private Scoped<V> value;
 
diff --git a/BitFaster.Caching/Concurrent/PaddedLong.cs b/BitFaster.Caching/Concurrent/PaddedLong.cs
index fe312b01..b32a5fdc 100644
--- a/BitFaster.Caching/Concurrent/PaddedLong.cs
+++ b/BitFaster.Caching/Concurrent/PaddedLong.cs
@@ -3,16 +3,33 @@
 
 namespace BitFaster.Caching.Concurrent
 {
+    /// <summary>
+    /// A long value padded by the size of a CPU cache line to mitigate false sharing.
+    /// </summary>
     [StructLayout(LayoutKind.Explicit, Size = 2 * Padding.CACHE_LINE_SIZE)] // padding before/between/after fields
     public struct PaddedLong
     {
+        /// <summary>
+        /// The value.
+        /// </summary>
         [FieldOffset(Padding.CACHE_LINE_SIZE)] public long value;
 
+        /// <summary>
+        /// Reads the value of the field, and on systems that require it inserts a memory barrier to 
+        /// prevent reordering of memory operations.
+        /// </summary>
+        /// <returns>The value that was read.</returns>
         public long VolatileRead()
         {
             return Volatile.Read(ref this.value);
         }
 
+        /// <summary>
+        /// Compares the current value with an expected value, if they are equal replaces the current value.
+        /// </summary>
+        /// <param name="expected">The expected value.</param>
+        /// <param name="updated">The updated value.</param>
+        /// <returns>True if the value is updated, otherwise false.</returns>
         public bool CompareAndSwap(long expected, long updated)
         {
             return Interlocked.CompareExchange(ref this.value, updated, expected) == expected;
diff --git a/BitFaster.Caching/Concurrent/Striped64.cs b/BitFaster.Caching/Concurrent/Striped64.cs
index a0403a85..f2e827fa 100644
--- a/BitFaster.Caching/Concurrent/Striped64.cs
+++ b/BitFaster.Caching/Concurrent/Striped64.cs
@@ -182,7 +182,6 @@ protected void LongAccumulate(long x, bool wasUncontended)
                             var r = new Cell(x);    // Optimistically create
                             if (this.cellsBusy == 0 && CasCellsBusy())
                             {
-                                var created = false;
                                 try
                                 {                   // Recheck under lock
                                     Cell[] rs; int m, j;
@@ -191,15 +190,14 @@ protected void LongAccumulate(long x, bool wasUncontended)
                                         rs[j = (m - 1) & h] == null)
                                     {
                                         rs[j] = r;
-                                        created = true;
+                                        break;
                                     }
                                 }
                                 finally
                                 {
                                     VolatileWriteNotBusy();
                                 }
-                                if (created)
-                                    break;
+
                                 continue;           // Slot is now non-empty
                             }
                         }
@@ -236,7 +234,6 @@ protected void LongAccumulate(long x, bool wasUncontended)
                 }
                 else if (this.cellsBusy == 0 && this.Cells == @as && CasCellsBusy())
                 {
-                    var init = false;
                     try
                     {                               // Initialize table
                         if (this.Cells == @as)
@@ -244,15 +241,13 @@ protected void LongAccumulate(long x, bool wasUncontended)
                             var rs = new Cell[2];
                             rs[h & 1] = new Cell(x);
                             this.Cells = rs;
-                            init = true;
+                            break;
                         }
                     }
                     finally
                     {
                         VolatileWriteNotBusy();
                     }
-                    if (init)
-                        break;
                 }
                 // Fall back on using base
                 else if (this.@base.CompareAndSwap(v = this.@base.VolatileRead(), v + x))
diff --git a/BitFaster.Caching/Lfu/Builder/AsyncConcurrentLfuBuilder.cs b/BitFaster.Caching/Lfu/Builder/AsyncConcurrentLfuBuilder.cs
index fe6a99aa..7560229e 100644
--- a/BitFaster.Caching/Lfu/Builder/AsyncConcurrentLfuBuilder.cs
+++ b/BitFaster.Caching/Lfu/Builder/AsyncConcurrentLfuBuilder.cs
@@ -1,9 +1,12 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
+
 namespace BitFaster.Caching.Lfu.Builder
 {
+    /// <summary>
+    /// A builder for creating a ConcurrentLfu as IAsyncCache.
+    /// </summary>
+    /// <typeparam name="K">The type of the cache key.</typeparam>
+    /// <typeparam name="V">The type of the cache value.</typeparam>
+    /// <typeparam name="W">The type of the wrapped cache value.</typeparam>
     public sealed class AsyncConcurrentLfuBuilder<K, V> : LfuBuilderBase<K, V, AsyncConcurrentLfuBuilder<K, V>, IAsyncCache<K, V>>
     {
         internal AsyncConcurrentLfuBuilder(LfuInfo<K> info)
diff --git a/BitFaster.Caching/Lfu/Builder/AtomicAsyncConcurrentLfuBuilder.cs b/BitFaster.Caching/Lfu/Builder/AtomicAsyncConcurrentLfuBuilder.cs
index d00f3215..0d8b4cba 100644
--- a/BitFaster.Caching/Lfu/Builder/AtomicAsyncConcurrentLfuBuilder.cs
+++ b/BitFaster.Caching/Lfu/Builder/AtomicAsyncConcurrentLfuBuilder.cs
@@ -1,10 +1,13 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
+
 using BitFaster.Caching.Atomic;
 
 namespace BitFaster.Caching.Lfu.Builder
 {
+    /// <summary>
+    /// A builder for creating a ConcurrentLfu as IAsyncCache with atomic value creation.
+    /// </summary>
+    /// <typeparam name="K">The type of the cache key.</typeparam>
+    /// <typeparam name="V">The type of the cache value.</typeparam>
     public class AtomicAsyncConcurrentLfuBuilder<K, V> : LfuBuilderBase<K, V, AtomicAsyncConcurrentLfuBuilder<K, V>, IAsyncCache<K, V>>
     {
         private readonly ConcurrentLfuBuilder<K, AsyncAtomicFactory<K, V>> inner;
diff --git a/BitFaster.Caching/Lfu/Builder/AtomicScopedConcurrentLfuBuilder.cs b/BitFaster.Caching/Lfu/Builder/AtomicScopedConcurrentLfuBuilder.cs
index eb0dcc97..51dd1acb 100644
--- a/BitFaster.Caching/Lfu/Builder/AtomicScopedConcurrentLfuBuilder.cs
+++ b/BitFaster.Caching/Lfu/Builder/AtomicScopedConcurrentLfuBuilder.cs
@@ -5,6 +5,11 @@
 
 namespace BitFaster.Caching.Lfu.Builder
 {
+    /// <summary>
+    /// A builder for creating a ConcurrentLfu with scoped values.
+    /// </summary>
+    /// <typeparam name="K">The type of the cache key.</typeparam>
+    /// <typeparam name="V">The type of the cache value.</typeparam>
     public class AtomicScopedConcurrentLfuBuilder<K, V> : LfuBuilderBase<K, V, AtomicScopedConcurrentLfuBuilder<K, V>, IScopedCache<K, V>> where V : IDisposable
     {
         private readonly ConcurrentLfuBuilder<K, ScopedAtomicFactory<K, V>> inner;
diff --git a/BitFaster.Caching/Lfu/Builder/ScopedConcurrentLfuBuilder.cs b/BitFaster.Caching/Lfu/Builder/ScopedConcurrentLfuBuilder.cs
index 31a3730a..afc6107c 100644
--- a/BitFaster.Caching/Lfu/Builder/ScopedConcurrentLfuBuilder.cs
+++ b/BitFaster.Caching/Lfu/Builder/ScopedConcurrentLfuBuilder.cs
@@ -1,9 +1,13 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace BitFaster.Caching.Lfu.Builder
 {
+    /// <summary>
+    /// A builder for creating a ConcurrentLfu with scoped values.
+    /// </summary>
+    /// <typeparam name="K">The type of the cache key.</typeparam>
+    /// <typeparam name="V">The type of the cache value.</typeparam>
+    /// <typeparam name="W">The type of the wrapped cache value.</typeparam>
     public sealed class ScopedConcurrentLfuBuilder<K, V, W> : LfuBuilderBase<K, V, ScopedConcurrentLfuBuilder<K, V, W>, IScopedCache<K, V>> where V : IDisposable where W : IScoped<V>
     {
         private readonly ConcurrentLfuBuilder<K, W> inner;
diff --git a/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs
index c47223f9..110b6b9b 100644
--- a/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs
@@ -1,11 +1,11 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
+
 namespace BitFaster.Caching.Lru.Builder
 {
+    /// <summary>
+    /// A builder for creating a ConcurrentLru.
+    /// </summary>
+    /// <typeparam name="K">The type of the cache key.</typeparam>
+    /// <typeparam name="V">The type of the cache value.</typeparam>
     public sealed class AsyncConcurrentLruBuilder<K, V> : LruBuilderBase<K, V, AsyncConcurrentLruBuilder<K, V>, IAsyncCache<K, V>>
     {
         internal AsyncConcurrentLruBuilder(LruInfo<K> info)
diff --git a/BitFaster.Caching/Lru/Builder/AtomicAsyncConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AtomicAsyncConcurrentLruBuilder.cs
index ab1320c1..d0930c97 100644
--- a/BitFaster.Caching/Lru/Builder/AtomicAsyncConcurrentLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/AtomicAsyncConcurrentLruBuilder.cs
@@ -2,6 +2,11 @@
 
 namespace BitFaster.Caching.Lru.Builder
 {
+    /// <summary>
+    /// A builder for creating a ConcurrentLru as IAsyncCache with atomic value creation.
+    /// </summary>
+    /// <typeparam name="K">The type of the cache key.</typeparam>
+    /// <typeparam name="V">The type of the cache value.</typeparam>
     public class AtomicAsyncConcurrentLruBuilder<K, V> : LruBuilderBase<K, V, AtomicAsyncConcurrentLruBuilder<K, V>, IAsyncCache<K, V>>
     {
         private readonly ConcurrentLruBuilder<K, AsyncAtomicFactory<K, V>> inner;
diff --git a/BitFaster.Caching/Lru/Builder/AtomicConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AtomicConcurrentLruBuilder.cs
index 420dfdf0..a2b65668 100644
--- a/BitFaster.Caching/Lru/Builder/AtomicConcurrentLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/AtomicConcurrentLruBuilder.cs
@@ -2,6 +2,11 @@
 
 namespace BitFaster.Caching.Lru.Builder
 {
+    /// <summary>
+    /// A builder for creating a ConcurrentLru as ICache with atomic value creation.
+    /// </summary>
+    /// <typeparam name="K">The type of the cache key.</typeparam>
+    /// <typeparam name="V">The type of the cache value.</typeparam>
     public class AtomicConcurrentLruBuilder<K, V> : LruBuilderBase<K, V, AtomicConcurrentLruBuilder<K, V>, ICache<K, V>>
     {
         private readonly ConcurrentLruBuilder<K, AtomicFactory<K, V>> inner;
diff --git a/BitFaster.Caching/Lru/Builder/AtomicScopedAsyncConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AtomicScopedAsyncConcurrentLruBuilder.cs
index f545ce54..709cf6aa 100644
--- a/BitFaster.Caching/Lru/Builder/AtomicScopedAsyncConcurrentLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/AtomicScopedAsyncConcurrentLruBuilder.cs
@@ -1,12 +1,13 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using BitFaster.Caching.Atomic;
 
 namespace BitFaster.Caching.Lru.Builder
 {
+    /// <summary>
+    /// A builder for creating a ConcurrentLru with scoped values.
+    /// </summary>
+    /// <typeparam name="K">The type of the cache key.</typeparam>
+    /// <typeparam name="V">The type of the cache value.</typeparam>
     public sealed class AtomicScopedAsyncConcurrentLruBuilder<K, V> : LruBuilderBase<K, V, AtomicScopedAsyncConcurrentLruBuilder<K, V>, IScopedAsyncCache<K, V>> where V : IDisposable
     {
         private readonly AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>> inner;
diff --git a/BitFaster.Caching/Lru/Builder/AtomicScopedConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AtomicScopedConcurrentLruBuilder.cs
index f575c570..fa38c331 100644
--- a/BitFaster.Caching/Lru/Builder/AtomicScopedConcurrentLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/AtomicScopedConcurrentLruBuilder.cs
@@ -3,6 +3,11 @@
 
 namespace BitFaster.Caching.Lru.Builder
 {
+    /// <summary>
+    /// A builder for creating a ConcurrentLru with scoped values.
+    /// </summary>
+    /// <typeparam name="K">The type of the cache key.</typeparam>
+    /// <typeparam name="V">The type of the cache value.</typeparam>
     public class AtomicScopedConcurrentLruBuilder<K, V> : LruBuilderBase<K, V, AtomicScopedConcurrentLruBuilder<K, V>, IScopedCache<K, V>> where V : IDisposable
     {
         private readonly ConcurrentLruBuilder<K, ScopedAtomicFactory<K, V>> inner;
diff --git a/BitFaster.Caching/Lru/Builder/ScopedAsyncConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/ScopedAsyncConcurrentLruBuilder.cs
index 400da06e..7b6140b3 100644
--- a/BitFaster.Caching/Lru/Builder/ScopedAsyncConcurrentLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/ScopedAsyncConcurrentLruBuilder.cs
@@ -2,6 +2,11 @@
 
 namespace BitFaster.Caching.Lru.Builder
 {
+    /// <summary>
+    /// A builder for creating a ConcurrentLru with scoped values.
+    /// </summary>
+    /// <typeparam name="K">The type of the cache key.</typeparam>
+    /// <typeparam name="V">The type of the cache value.</typeparam>
     public sealed class ScopedAsyncConcurrentLruBuilder<K, V> : LruBuilderBase<K, V, ScopedAsyncConcurrentLruBuilder<K, V>, IScopedAsyncCache<K, V>> where V : IDisposable
     {
         private readonly AsyncConcurrentLruBuilder<K, Scoped<V>> inner;
diff --git a/BitFaster.Caching/Lru/Builder/ScopedConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/ScopedConcurrentLruBuilder.cs
index 229a088e..d6fe4708 100644
--- a/BitFaster.Caching/Lru/Builder/ScopedConcurrentLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/ScopedConcurrentLruBuilder.cs
@@ -2,6 +2,12 @@
 
 namespace BitFaster.Caching.Lru.Builder
 {
+    /// <summary>
+    /// A builder for creating a ConcurrentLru with scoped values.
+    /// </summary>
+    /// <typeparam name="K">The type of the cache key.</typeparam>
+    /// <typeparam name="V">The type of the cache value.</typeparam>
+    /// <typeparam name="W">The type of the wrapped cache value.</typeparam>
     public sealed class ScopedConcurrentLruBuilder<K, V, W> : LruBuilderBase<K, V, ScopedConcurrentLruBuilder<K, V, W>, IScopedCache<K, V>> where V : IDisposable where W : IScoped<V>
     {
         private readonly ConcurrentLruBuilder<K, W> inner;