diff --git a/BitFaster.Caching.UnitTests/Lfu/ConcurrentLfuTests.cs b/BitFaster.Caching.UnitTests/Lfu/ConcurrentLfuTests.cs
index 082d67c5..49504d53 100644
--- a/BitFaster.Caching.UnitTests/Lfu/ConcurrentLfuTests.cs
+++ b/BitFaster.Caching.UnitTests/Lfu/ConcurrentLfuTests.cs
@@ -848,7 +848,7 @@ private void VerifyHits(int iterations, int minSamples)
         private void LogLru()
         {
 #if DEBUG
-            this.output.WriteLine(cache.FormatLruString());
+            this.output.WriteLine(cache.FormatLfuString());
 #endif        
         }
 
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs
index abf4d24f..b1686c4e 100644
--- a/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs
@@ -12,6 +12,10 @@ public sealed class AtomicFactoryAsyncCache<K, V> : IAsyncCache<K, V>
         private readonly ICache<K, AsyncAtomicFactory<K, V>> cache;
         private readonly Optional<ICacheEvents<K, V>> events;
 
+        /// <summary>
+        /// Initializes a new instance of the AtomicFactoryAsyncCache class with the specified inner cache.
+        /// </summary>
+        /// <param name="cache">The decorated cache.</param>
         public AtomicFactoryAsyncCache(ICache<K, AsyncAtomicFactory<K, V>> cache)
         {
             if (cache == null)
@@ -31,32 +35,41 @@ public AtomicFactoryAsyncCache(ICache<K, AsyncAtomicFactory<K, V>> cache)
             }
         }
 
+        ///<inheritdoc/>
         public int Count => cache.Count;
 
+        ///<inheritdoc/>
         public Optional<ICacheMetrics> Metrics => cache.Metrics;
 
+        ///<inheritdoc/>
         public Optional<ICacheEvents<K, V>> Events => this.events;
 
+        ///<inheritdoc/>
         public ICollection<K> Keys => this.cache.Keys;
 
+        ///<inheritdoc/>
         public CachePolicy Policy => this.cache.Policy;
 
+        ///<inheritdoc/>
         public void AddOrUpdate(K key, V value)
         {
             cache.AddOrUpdate(key, new AsyncAtomicFactory<K, V>(value));
         }
 
+        ///<inheritdoc/>
         public void Clear()
         {
             cache.Clear();
         }
 
+        ///<inheritdoc/>
         public ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
         {
             var synchronized = cache.GetOrAdd(key, _ => new AsyncAtomicFactory<K, V>());
             return synchronized.GetValueAsync(key, valueFactory);
         }
 
+        ///<inheritdoc/>
         public bool TryGet(K key, out V value)
         {
             AsyncAtomicFactory<K, V> output;
@@ -72,16 +85,19 @@ public bool TryGet(K key, out V value)
             return false;
         }
 
+        ///<inheritdoc/>
         public bool TryRemove(K key)
         {
             return cache.TryRemove(key);
         }
 
+        ///<inheritdoc/>
         public bool TryUpdate(K key, V value)
         {
             return cache.TryUpdate(key, new AsyncAtomicFactory<K, V>(value));
         }
 
+        ///<inheritdoc/>
         public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
         {
             foreach (var kvp in this.cache)
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
index 255bdb3f..9fb08fd0 100644
--- a/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
@@ -30,32 +30,41 @@ public AtomicFactoryCache(ICache<K, AtomicFactory<K, V>> cache)
             }
         }
 
+        ///<inheritdoc/>
         public int Count => this.cache.Count;
 
+        ///<inheritdoc/>
         public Optional<ICacheMetrics> Metrics => this.cache.Metrics;
 
+        ///<inheritdoc/>
         public Optional<ICacheEvents<K, V>> Events => this.events;
 
+        ///<inheritdoc/>
         public ICollection<K> Keys => this.cache.Keys;
 
+        ///<inheritdoc/>
         public CachePolicy Policy => this.cache.Policy;
 
+        ///<inheritdoc/>
         public void AddOrUpdate(K key, V value)
         {
             this.cache.AddOrUpdate(key, new AtomicFactory<K, V>(value));
         }
 
+        ///<inheritdoc/>
         public void Clear()
         {
             this.cache.Clear();
         }
 
+        ///<inheritdoc/>
         public V GetOrAdd(K key, Func<K, V> valueFactory)
         {
             var atomicFactory = cache.GetOrAdd(key, _ => new AtomicFactory<K, V>());
             return atomicFactory.GetValue(key, valueFactory);
         }
 
+        ///<inheritdoc/>
         public bool TryGet(K key, out V value)
         {
             AtomicFactory<K, V> output;
@@ -71,16 +80,19 @@ public bool TryGet(K key, out V value)
             return false;
         }
 
+        ///<inheritdoc/>
         public bool TryRemove(K key)
         {
             return cache.TryRemove(key);
         }
 
+        ///<inheritdoc/>
         public bool TryUpdate(K key, V value)
         {
             return cache.TryUpdate(key, new AtomicFactory<K, V>(value));
         }
 
+        ///<inheritdoc/>
         public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
         {
             foreach (var kvp in this.cache)
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs
index 168a9816..c22a7b31 100644
--- a/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs
@@ -13,6 +13,10 @@ public sealed class AtomicFactoryScopedAsyncCache<K, V> : IScopedAsyncCache<K, V
         private readonly ICache<K, ScopedAsyncAtomicFactory<K, V>> cache;
         private readonly Optional<ICacheEvents<K, Scoped<V>>> events;
 
+        /// <summary>
+        /// Initializes a new instance of the AtomicFactoryScopedAsyncCache class with the specified inner cache.
+        /// </summary>
+        /// <param name="cache">The decorated cache.</param>
         public AtomicFactoryScopedAsyncCache(ICache<K, ScopedAsyncAtomicFactory<K, V>> cache)
         {
             if (cache == null)
@@ -31,27 +35,34 @@ public AtomicFactoryScopedAsyncCache(ICache<K, ScopedAsyncAtomicFactory<K, V>> c
             }
         }
 
+        ///<inheritdoc/>
         public int Count => this.cache.Count;
 
+        ///<inheritdoc/>
         public Optional<ICacheMetrics> Metrics => this.cache.Metrics;
 
+        ///<inheritdoc/>
         public Optional<ICacheEvents<K, Scoped<V>>> Events => this.events;
 
+        ///<inheritdoc/>
         public CachePolicy Policy => this.cache.Policy;
 
         ///<inheritdoc/>
         public ICollection<K> Keys => this.cache.Keys;
 
+        ///<inheritdoc/>
         public void AddOrUpdate(K key, V value)
         {
             this.cache.AddOrUpdate(key, new ScopedAsyncAtomicFactory<K, V>(value));
         }
 
+        ///<inheritdoc/>
         public void Clear()
         {
             this.cache.Clear();
         }
 
+        ///<inheritdoc/>
         public async ValueTask<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
         {
             int c = 0;
@@ -76,6 +87,7 @@ public async ValueTask<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scop
             }
         }
 
+        ///<inheritdoc/>
         public bool ScopedTryGet(K key, out Lifetime<V> lifetime)
         {
             if (this.cache.TryGet(key, out var scope))
@@ -90,16 +102,19 @@ public bool ScopedTryGet(K key, out Lifetime<V> lifetime)
             return false;
         }
 
+        ///<inheritdoc/>
         public bool TryRemove(K key)
         {
             return this.cache.TryRemove(key);
         }
 
+        ///<inheritdoc/>
         public bool TryUpdate(K key, V value)
         {
             return this.cache.TryUpdate(key, new ScopedAsyncAtomicFactory<K, V>(value));
         }
 
+        ///<inheritdoc/>
         public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()
         {
             foreach (var kvp in this.cache)
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs
index c61b4f02..42a78adc 100644
--- a/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs
@@ -12,6 +12,10 @@ public sealed class AtomicFactoryScopedCache<K, V> : IScopedCache<K, V> where V
         private readonly ICache<K, ScopedAtomicFactory<K, V>> cache;
         private readonly Optional<ICacheEvents<K, Scoped<V>>> events;
 
+        /// <summary>
+        /// Initializes a new instance of the AtomicFactoryScopedCache class with the specified inner cache.
+        /// </summary>
+        /// <param name="cache">The decorated cache.</param>
         public AtomicFactoryScopedCache(ICache<K, ScopedAtomicFactory<K, V>> cache)
         {
             if (cache == null)
@@ -31,27 +35,34 @@ public AtomicFactoryScopedCache(ICache<K, ScopedAtomicFactory<K, V>> cache)
             }
         }
 
+        ///<inheritdoc/>
         public int Count => this.cache.Count;
 
+        ///<inheritdoc/>
         public Optional<ICacheMetrics> Metrics => this.cache.Metrics;
 
+        ///<inheritdoc/>
         public Optional<ICacheEvents<K, Scoped<V>>> Events => events;
 
+        ///<inheritdoc/>
         public CachePolicy Policy => this.cache.Policy;
 
         ///<inheritdoc/>
         public ICollection<K> Keys => this.cache.Keys;
 
+        ///<inheritdoc/>
         public void AddOrUpdate(K key, V value)
         {
             this.cache.AddOrUpdate(key, new ScopedAtomicFactory<K, V>(value));
         }
 
+        ///<inheritdoc/>
         public void Clear()
         {
             this.cache.Clear();
         }
 
+        ///<inheritdoc/>
         public Lifetime<V> ScopedGetOrAdd(K key, Func<K, Scoped<V>> valueFactory)
         {
             int c = 0;
@@ -74,6 +85,7 @@ public Lifetime<V> ScopedGetOrAdd(K key, Func<K, Scoped<V>> valueFactory)
             }
         }
 
+        ///<inheritdoc/>
         public bool ScopedTryGet(K key, out Lifetime<V> lifetime)
         {
             if (this.cache.TryGet(key, out var scope))
@@ -88,16 +100,19 @@ public bool ScopedTryGet(K key, out Lifetime<V> lifetime)
             return false;
         }
 
+        ///<inheritdoc/>
         public bool TryRemove(K key)
         {
             return this.cache.TryRemove(key);
         }
 
+        ///<inheritdoc/>
         public bool TryUpdate(K key, V value)
         {
             return this.cache.TryUpdate(key, new ScopedAtomicFactory<K, V>(value));
         }
 
+        ///<inheritdoc/>
         public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()
         {
             foreach (var kvp in this.cache)
diff --git a/BitFaster.Caching/Buffers/BufferStatus.cs b/BitFaster.Caching/Buffers/BufferStatus.cs
index e936cf16..cb0479a4 100644
--- a/BitFaster.Caching/Buffers/BufferStatus.cs
+++ b/BitFaster.Caching/Buffers/BufferStatus.cs
@@ -1,14 +1,29 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
+
 namespace BitFaster.Caching.Buffers
 {
+    /// <summary>
+    /// Specifies the status of buffer operations.
+    /// </summary>
     public enum BufferStatus
     {
+        /// <summary>
+        /// The buffer is full.
+        /// </summary>
         Full,
+
+        /// <summary>
+        /// The buffer is empty.
+        /// </summary>
         Empty,
+
+        /// <summary>
+        /// The buffer operation succeeded.
+        /// </summary>
         Success,
+
+        /// <summary>
+        /// The buffer operation was contended.
+        /// </summary>
         Contended,
     }
 }
diff --git a/BitFaster.Caching/Buffers/PaddedHeadAndTail.cs b/BitFaster.Caching/Buffers/PaddedHeadAndTail.cs
index 742b6074..654626b1 100644
--- a/BitFaster.Caching/Buffers/PaddedHeadAndTail.cs
+++ b/BitFaster.Caching/Buffers/PaddedHeadAndTail.cs
@@ -1,9 +1,5 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Drawing;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
-using System.Text;
 
 namespace BitFaster.Caching.Buffers
 {
diff --git a/BitFaster.Caching/Buffers/StripedBufferSize.cs b/BitFaster.Caching/Buffers/StripedBufferSize.cs
index 22fcacd5..a0f873f4 100644
--- a/BitFaster.Caching/Buffers/StripedBufferSize.cs
+++ b/BitFaster.Caching/Buffers/StripedBufferSize.cs
@@ -2,8 +2,16 @@
 
 namespace BitFaster.Caching.Buffers
 {
+    /// <summary>
+    /// Represents the size of a striped buffer.
+    /// </summary>
     public sealed class StripedBufferSize
     {
+        /// <summary>
+        /// Initializes a new instance of the StripedBufferSize class with the specified buffer size and stripe count.
+        /// </summary>
+        /// <param name="bufferSize">The size of each striped buffer.</param>
+        /// <param name="stripeCount">The number of stripes.</param>
         public StripedBufferSize(int bufferSize, int stripeCount)
         {
             if (bufferSize < 1)
@@ -20,8 +28,14 @@ public StripedBufferSize(int bufferSize, int stripeCount)
             StripeCount = BitOps.CeilingPowerOfTwo(stripeCount);
         }
 
+        /// <summary>
+        /// The size of the buffer. Each stripe will be initialized with a buffer of this size.
+        /// </summary>
         public int BufferSize { get; }
 
+        /// <summary>
+        /// The number of stripes.
+        /// </summary>
         public int StripeCount { get; }
     }
 }
diff --git a/BitFaster.Caching/CacheEventProxyBase.cs b/BitFaster.Caching/CacheEventProxyBase.cs
index f4966fc1..acd7b1f4 100644
--- a/BitFaster.Caching/CacheEventProxyBase.cs
+++ b/BitFaster.Caching/CacheEventProxyBase.cs
@@ -1,22 +1,30 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching
 {
+    /// <summary>
+    /// Represents a base class for converting cache events for decorated caches such that the inner cache wrapper
+    /// type can be hidden from the outer cache.
+    /// </summary>
+    /// <typeparam name="K">The type of the key</typeparam>
+    /// <typeparam name="TInner">The inner value type</typeparam>
+    /// <typeparam name="TOuter">The outer value type</typeparam>
     public abstract class CacheEventProxyBase<K, TInner, TOuter> : ICacheEvents<K, TOuter>
     {
         private readonly ICacheEvents<K, TInner> events;
 
         private event EventHandler<ItemRemovedEventArgs<K, TOuter>> itemRemovedProxy;
 
+        /// <summary>
+        /// Initializes a new instance of the CacheEventProxyBase class with the specified inner cache events.
+        /// </summary>
+        /// <param name="events">The inner cache events.</param>
         public CacheEventProxyBase(ICacheEvents<K, TInner> events)
         {
             this.events = events;
         }
 
+        ///<inheritdoc/>
         public event EventHandler<ItemRemovedEventArgs<K, TOuter>> ItemRemoved
         {
             add { this.Register(value); }
@@ -44,6 +52,11 @@ private void OnItemRemoved(object sender, ItemRemovedEventArgs<K, TInner> args)
             itemRemovedProxy(sender, TranslateOnRemoved(args));
         }
 
+        /// <summary>
+        /// Translate the ItemRemovedEventArgs by converting the inner arg type to the outer arg type.
+        /// </summary>
+        /// <param name="inner">The inner arg.</param>
+        /// <returns>The translated arg.</returns>
         protected abstract ItemRemovedEventArgs<K, TOuter> TranslateOnRemoved(ItemRemovedEventArgs<K, TInner> inner);
     }
 }
diff --git a/BitFaster.Caching/CachePolicy.cs b/BitFaster.Caching/CachePolicy.cs
index 75bc6313..91172ba3 100644
--- a/BitFaster.Caching/CachePolicy.cs
+++ b/BitFaster.Caching/CachePolicy.cs
@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
+
 namespace BitFaster.Caching
 {
     /// <summary>
@@ -12,6 +7,11 @@ namespace BitFaster.Caching
     /// </summary>
     public class CachePolicy
     {
+        /// <summary>
+        /// Initializes a new instance of the CachePolicy class with the specified eviction and expire after write policies.
+        /// </summary>
+        /// <param name="eviction">The eviction policy.</param>
+        /// <param name="expireAfterWrite">The expire after write policy.</param>
         public CachePolicy(Optional<IBoundedPolicy> eviction, Optional<ITimePolicy> expireAfterWrite)
         {
             this.Eviction = eviction;
diff --git a/BitFaster.Caching/ICacheEvents.cs b/BitFaster.Caching/ICacheEvents.cs
index a4033ae0..18978f1b 100644
--- a/BitFaster.Caching/ICacheEvents.cs
+++ b/BitFaster.Caching/ICacheEvents.cs
@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching
 {
diff --git a/BitFaster.Caching/Lfu/Builder/AtomicAsyncConcurrentLfuBuilder.cs b/BitFaster.Caching/Lfu/Builder/AtomicAsyncConcurrentLfuBuilder.cs
index a45beae3..d00f3215 100644
--- a/BitFaster.Caching/Lfu/Builder/AtomicAsyncConcurrentLfuBuilder.cs
+++ b/BitFaster.Caching/Lfu/Builder/AtomicAsyncConcurrentLfuBuilder.cs
@@ -15,6 +15,7 @@ internal AtomicAsyncConcurrentLfuBuilder(ConcurrentLfuBuilder<K, AsyncAtomicFact
             this.inner = inner;
         }
 
+        ///<inheritdoc/>
         public override IAsyncCache<K, V> Build()
         {
             var level1 = inner.Build();
diff --git a/BitFaster.Caching/Lfu/Builder/AtomicConcurrentLfuBuilder.cs b/BitFaster.Caching/Lfu/Builder/AtomicConcurrentLfuBuilder.cs
index bcd01ec6..c35bd110 100644
--- a/BitFaster.Caching/Lfu/Builder/AtomicConcurrentLfuBuilder.cs
+++ b/BitFaster.Caching/Lfu/Builder/AtomicConcurrentLfuBuilder.cs
@@ -15,6 +15,7 @@ internal AtomicConcurrentLfuBuilder(ConcurrentLfuBuilder<K, AtomicFactory<K, V>>
             this.inner = inner;
         }
 
+        ///<inheritdoc/>
         public override ICache<K, V> Build()
         {
             var level1 = inner.Build();
diff --git a/BitFaster.Caching/Lfu/Builder/AtomicScopedConcurrentLfuBuilder.cs b/BitFaster.Caching/Lfu/Builder/AtomicScopedConcurrentLfuBuilder.cs
index 4197620f..eb0dcc97 100644
--- a/BitFaster.Caching/Lfu/Builder/AtomicScopedConcurrentLfuBuilder.cs
+++ b/BitFaster.Caching/Lfu/Builder/AtomicScopedConcurrentLfuBuilder.cs
@@ -15,6 +15,7 @@ internal AtomicScopedConcurrentLfuBuilder(ConcurrentLfuBuilder<K, ScopedAtomicFa
             this.inner = inner;
         }
 
+        ///<inheritdoc/>
         public override IScopedCache<K, V> Build()
         {
             var level1 = inner.Build() as ICache<K, ScopedAtomicFactory<K, V>>;
diff --git a/BitFaster.Caching/Lfu/Builder/LfuBuilderBase.cs b/BitFaster.Caching/Lfu/Builder/LfuBuilderBase.cs
index e19b87e9..662cb103 100644
--- a/BitFaster.Caching/Lfu/Builder/LfuBuilderBase.cs
+++ b/BitFaster.Caching/Lfu/Builder/LfuBuilderBase.cs
@@ -1,15 +1,20 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
+using System.Collections.Generic;
 using BitFaster.Caching.Scheduler;
 
 namespace BitFaster.Caching.Lfu.Builder
 {
+    /// <summary>
+    /// Represents the base class to be extended by LFU builder implementations.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
+    /// <typeparam name="TBuilder">The type of the builder.</typeparam>
+    /// <typeparam name="TCacheReturn">The return type of the builder.</typeparam>
     public abstract class LfuBuilderBase<K, V, TBuilder, TCacheReturn> where TBuilder : LfuBuilderBase<K, V, TBuilder, TCacheReturn>
     {
         internal readonly LfuInfo<K> info;
 
-        protected LfuBuilderBase(LfuInfo<K> info)
+        internal LfuBuilderBase(LfuInfo<K> info)
         {
             this.info = info;
         }
@@ -63,7 +68,6 @@ public TBuilder WithKeyComparer(IEqualityComparer<K> comparer)
         /// Use the specified buffer configuration. Smaller buffers consume less memory, larger buffers can
         /// increase concurrent throughput.
         /// </summary>
-        /// <param name="comparer">The buffer configuration to use.</param>
         /// <returns>A ConcurrentLfuBuilder</returns>
         public TBuilder WithBufferConfiguration(LfuBufferSize bufferConfiguration)
         {
diff --git a/BitFaster.Caching/Lfu/Builder/LfuInfo.cs b/BitFaster.Caching/Lfu/Builder/LfuInfo.cs
index 1cfb489e..18201b6a 100644
--- a/BitFaster.Caching/Lfu/Builder/LfuInfo.cs
+++ b/BitFaster.Caching/Lfu/Builder/LfuInfo.cs
@@ -6,7 +6,7 @@
 
 namespace BitFaster.Caching.Lfu.Builder
 {
-    public sealed class LfuInfo<K>
+    internal sealed class LfuInfo<K>
     {
         private LfuBufferSize bufferConfiguration;
 
diff --git a/BitFaster.Caching/Lfu/ConcurrentLfu.cs b/BitFaster.Caching/Lfu/ConcurrentLfu.cs
index 058bdd8e..624a8262 100644
--- a/BitFaster.Caching/Lfu/ConcurrentLfu.cs
+++ b/BitFaster.Caching/Lfu/ConcurrentLfu.cs
@@ -783,7 +783,11 @@ internal class CacheMetrics : ICacheMetrics
         }
 
 #if DEBUG
-        public string FormatLruString()
+        /// <summary>
+        /// Format the LFU as a string by converting all the keys to strings.
+        /// </summary>
+        /// <returns>The LFU formatted as a string.</returns>
+        public string FormatLfuString()
         {
             var sb = new StringBuilder();
 
diff --git a/BitFaster.Caching/Lfu/ConcurrentLfuBuilder.cs b/BitFaster.Caching/Lfu/ConcurrentLfuBuilder.cs
index d5215f8b..d4913ddf 100644
--- a/BitFaster.Caching/Lfu/ConcurrentLfuBuilder.cs
+++ b/BitFaster.Caching/Lfu/ConcurrentLfuBuilder.cs
@@ -3,6 +3,19 @@
 
 namespace BitFaster.Caching.Lfu
 {
+    /// <summary>
+    /// A builder of ICache and IScopedCache instances with the following configuration
+    /// settings:
+    /// - The maximum size.
+    /// - The concurrency level.
+    /// - The key comparer.
+    /// - The buffer sizes.
+    /// 
+    /// The following features can be selected which change the underlying cache implementation: 
+    /// - Scoped IDisposable values.
+    /// </summary>
+    /// <typeparam name="K">The type of keys in the cache.</typeparam>
+    /// <typeparam name="V">The type of values in the cache.</typeparam>
     public sealed class ConcurrentLfuBuilder<K, V> : LfuBuilderBase<K, V, ConcurrentLfuBuilder<K, V>, ICache<K, V>>
     {
         /// <summary>
@@ -18,6 +31,7 @@ internal ConcurrentLfuBuilder(LfuInfo<K> info)
         {
         }
 
+        ///<inheritdoc/>
         public override ICache<K, V> Build()
         {
             return new ConcurrentLfu<K, V>(info.ConcurrencyLevel, info.Capacity, info.Scheduler, info.KeyComparer, info.BufferConfiguration);
diff --git a/BitFaster.Caching/Lfu/ConcurrentLfuBuilderExtensions.cs b/BitFaster.Caching/Lfu/ConcurrentLfuBuilderExtensions.cs
index 1aaf1806..4ee1e69a 100644
--- a/BitFaster.Caching/Lfu/ConcurrentLfuBuilderExtensions.cs
+++ b/BitFaster.Caching/Lfu/ConcurrentLfuBuilderExtensions.cs
@@ -1,11 +1,12 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 using BitFaster.Caching.Atomic;
 using BitFaster.Caching.Lfu.Builder;
 
 namespace BitFaster.Caching.Lfu
 {
+    /// <summary>
+    /// Extension methods to support building all cache variants.
+    /// </summary>
     public static class ConcurrentLfuBuilderExtensions
     {
         /// <summary>
diff --git a/BitFaster.Caching/Lfu/LfuBufferSize.cs b/BitFaster.Caching/Lfu/LfuBufferSize.cs
index a7c16c20..4f7f582c 100644
--- a/BitFaster.Caching/Lfu/LfuBufferSize.cs
+++ b/BitFaster.Caching/Lfu/LfuBufferSize.cs
@@ -4,12 +4,23 @@
 
 namespace BitFaster.Caching.Lfu
 {
+    /// <summary>
+    /// Represents the read and write buffer sizes used to initialize ConcurrentLfu.
+    /// </summary>
     public class LfuBufferSize
     {
+        /// <summary>
+        /// The default buffer size.
+        /// </summary>
         public const int DefaultBufferSize = 128;
 
         private const int MaxWriteBufferTotalSize = 1024;
 
+        /// <summary>
+        /// Initializes a new instance of the LfuBufferSize class with the specified read and write buffer sizes.
+        /// </summary>
+        /// <param name="readBufferSize">The read buffer size.</param>
+        /// <param name="writeBufferSize">The write buffer size.</param>
         public LfuBufferSize(StripedBufferSize readBufferSize, StripedBufferSize writeBufferSize)
         {
             Read = readBufferSize ?? throw new ArgumentNullException(nameof(readBufferSize));
diff --git a/BitFaster.Caching/Lfu/LfuCapacityPartition.cs b/BitFaster.Caching/Lfu/LfuCapacityPartition.cs
index a49c1ecf..f98392d5 100644
--- a/BitFaster.Caching/Lfu/LfuCapacityPartition.cs
+++ b/BitFaster.Caching/Lfu/LfuCapacityPartition.cs
@@ -3,6 +3,9 @@
 
 namespace BitFaster.Caching.Lfu
 {
+    /// <summary>
+    /// Represents the LFU capacity partition. Uses a hill climbing algorithm to optimze partition sizes over time.
+    /// </summary>
     [DebuggerDisplay("{Capacity} ({Window}/{Protected}/{Probation})")]
     public sealed class LfuCapacityPartition
     {
@@ -28,24 +31,48 @@ public sealed class LfuCapacityPartition
         private const double MaxMainPercentage = 0.999d;
         private const double MinMainPercentage = 0.2d;
 
+        /// <summary>
+        /// Initializes a new instance of the LfuCapacityPartition class with the specified total capacity.
+        /// </summary>
+        /// <param name="totalCapacity">The total capacity.</param>
         public LfuCapacityPartition(int totalCapacity)
         {
             this.max = totalCapacity;
             (windowCapacity, protectedCapacity, probationCapacity) = ComputeQueueCapacity(totalCapacity, DefaultMainPercentage);
-            InitializeStepSize(totalCapacity);
+            InitializeStepSize();
 
             previousHitRate = 1.0;
         }
 
+        /// <summary>
+        /// Gets the number of items permitted in the window LRU.
+        /// </summary>
         public int Window => this.windowCapacity;
 
+        /// <summary>
+        /// Gets the number of items permitted in the protected LRU.
+        /// </summary>
         public int Protected => this.protectedCapacity;
 
+        /// <summary>
+        /// Gets the number of items permitted in the probation LRU.
+        /// </summary>
         public int Probation => this.probationCapacity;
 
+        /// <summary>
+        /// Gets the total capacity.
+        /// </summary>
         public int Capacity => this.max;
 
-        // Apply changes to the ratio of window to main, window = recency-biased, main = frequency-biased.
+
+        /// <summary>
+        /// Optimize the size of the window and main LRUs based on changes in hit rate.
+        /// </summary>
+        /// <param name="metrics">The cache metrics.</param>
+        /// <param name="sampleThreshold">The number of cache requests to sample before attempting to optimize LRU sizes.</param>
+        /// <remarks>
+        /// window = recency-biased, main = frequency-biased.
+        /// </remarks>
         public void OptimizePartitioning(ICacheMetrics metrics, int sampleThreshold)
         {
             long newHits = metrics.Hits;
@@ -81,7 +108,7 @@ public void OptimizePartitioning(ICacheMetrics metrics, int sampleThreshold)
             (windowCapacity, protectedCapacity, probationCapacity) = ComputeQueueCapacity(max, mainRatio);
         }
 
-        private void InitializeStepSize(int cacheSize)
+        private void InitializeStepSize()
         {
             stepSize = HillClimberStepPercent;
         }
diff --git a/BitFaster.Caching/Lfu/LfuNode.cs b/BitFaster.Caching/Lfu/LfuNode.cs
index 29734ba5..40028176 100644
--- a/BitFaster.Caching/Lfu/LfuNode.cs
+++ b/BitFaster.Caching/Lfu/LfuNode.cs
@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace BitFaster.Caching.Lfu
+namespace BitFaster.Caching.Lfu
 {
     internal sealed class LfuNode<K, V>
     {
@@ -55,7 +51,7 @@ internal void Invalidate()
         }
     }
 
-    public enum Position
+    internal enum Position
     {
         Window,
         Probation,
diff --git a/BitFaster.Caching/Lru/Builder/AtomicAsyncConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AtomicAsyncConcurrentLruBuilder.cs
index 9a97e3e7..ab1320c1 100644
--- a/BitFaster.Caching/Lru/Builder/AtomicAsyncConcurrentLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/AtomicAsyncConcurrentLruBuilder.cs
@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using BitFaster.Caching.Atomic;
+using BitFaster.Caching.Atomic;
 
 namespace BitFaster.Caching.Lru.Builder
 {
@@ -17,6 +12,7 @@ internal AtomicAsyncConcurrentLruBuilder(ConcurrentLruBuilder<K, AsyncAtomicFact
             this.inner = inner;
         }
 
+        ///<inheritdoc/>
         public override IAsyncCache<K, V> Build()
         {
             var level1 = inner.Build();
diff --git a/BitFaster.Caching/Lru/Builder/AtomicConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AtomicConcurrentLruBuilder.cs
index 703e0899..420dfdf0 100644
--- a/BitFaster.Caching/Lru/Builder/AtomicConcurrentLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/AtomicConcurrentLruBuilder.cs
@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using BitFaster.Caching.Atomic;
+using BitFaster.Caching.Atomic;
 
 namespace BitFaster.Caching.Lru.Builder
 {
@@ -17,6 +12,7 @@ internal AtomicConcurrentLruBuilder(ConcurrentLruBuilder<K, AtomicFactory<K, V>>
             this.inner = inner;
         }
 
+        ///<inheritdoc/>
         public override ICache<K, V> Build()
         {
             var level1 = inner.Build();
diff --git a/BitFaster.Caching/Lru/Builder/AtomicScopedConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AtomicScopedConcurrentLruBuilder.cs
index 6a33b094..f575c570 100644
--- a/BitFaster.Caching/Lru/Builder/AtomicScopedConcurrentLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/AtomicScopedConcurrentLruBuilder.cs
@@ -1,8 +1,4 @@
 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
@@ -17,6 +13,7 @@ internal AtomicScopedConcurrentLruBuilder(ConcurrentLruBuilder<K, ScopedAtomicFa
             this.inner = inner;
         }
 
+        ///<inheritdoc/>
         public override IScopedCache<K, V> Build()
         {
             var level1 = inner.Build() as ICache<K, ScopedAtomicFactory<K, V>>;
diff --git a/BitFaster.Caching/Lru/Builder/LruBuilderBase.cs b/BitFaster.Caching/Lru/Builder/LruBuilderBase.cs
index 5c1b0641..1d6ee379 100644
--- a/BitFaster.Caching/Lru/Builder/LruBuilderBase.cs
+++ b/BitFaster.Caching/Lru/Builder/LruBuilderBase.cs
@@ -1,8 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Lru.Builder
 {
@@ -13,7 +10,7 @@ public abstract class LruBuilderBase<K, V, TBuilder, TCacheReturn> where TBuilde
     {
         internal readonly LruInfo<K> info;
 
-        protected LruBuilderBase(LruInfo<K> info)
+        internal LruBuilderBase(LruInfo<K> info)
         {
             this.info = info;
         }
diff --git a/BitFaster.Caching/Lru/Builder/LruInfo.cs b/BitFaster.Caching/Lru/Builder/LruInfo.cs
index b3156da4..6933ebdd 100644
--- a/BitFaster.Caching/Lru/Builder/LruInfo.cs
+++ b/BitFaster.Caching/Lru/Builder/LruInfo.cs
@@ -1,12 +1,9 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Lru.Builder
 {
-    public sealed class LruInfo<K>
+    internal sealed class LruInfo<K>
     {
         public ICapacityPartition Capacity { get; set; } = new FavorWarmPartition(128);
 
diff --git a/BitFaster.Caching/Lru/Builder/ScopedAsyncConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/ScopedAsyncConcurrentLruBuilder.cs
index f1952876..400da06e 100644
--- a/BitFaster.Caching/Lru/Builder/ScopedAsyncConcurrentLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/ScopedAsyncConcurrentLruBuilder.cs
@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Lru.Builder
 {
diff --git a/BitFaster.Caching/Lru/Builder/ScopedConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/ScopedConcurrentLruBuilder.cs
index ddd0e4cb..229a088e 100644
--- a/BitFaster.Caching/Lru/Builder/ScopedConcurrentLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/ScopedConcurrentLruBuilder.cs
@@ -1,9 +1,4 @@
 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
 {
diff --git a/BitFaster.Caching/Lru/CapacityPartitionExtensions.cs b/BitFaster.Caching/Lru/CapacityPartitionExtensions.cs
index 16a0f840..06d0a7ed 100644
--- a/BitFaster.Caching/Lru/CapacityPartitionExtensions.cs
+++ b/BitFaster.Caching/Lru/CapacityPartitionExtensions.cs
@@ -1,14 +1,17 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Lru
 {
+    /// <summary>
+    /// Extension methods for ICapacityPartition.
+    /// </summary>
     public static class CapacityPartitionExtensions
     {
+        /// <summary>
+        /// Validates the specified capacity partition.
+        /// </summary>
+        /// <param name="capacity">The capacity partition to validate.</param>
+        /// <exception cref="ArgumentOutOfRangeException">Any of the hot, warm or cold capacities is less than 1.</exception>
         public static void Validate(this ICapacityPartition capacity)
         {
             if (capacity.Cold < 1)
diff --git a/BitFaster.Caching/Lru/ClassicLru.cs b/BitFaster.Caching/Lru/ClassicLru.cs
index 8a36cebd..8d2abdeb 100644
--- a/BitFaster.Caching/Lru/ClassicLru.cs
+++ b/BitFaster.Caching/Lru/ClassicLru.cs
@@ -3,7 +3,6 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -27,11 +26,23 @@ public sealed class ClassicLru<K, V> : ICache<K, V>, IAsyncCache<K, V>, IBounded
         private readonly CacheMetrics metrics = new CacheMetrics();
         private readonly CachePolicy policy;
 
+        /// <summary>
+        /// Initializes a new instance of the ClassicLru class with the specified capacity.
+        /// </summary>
+        /// <param name="capacity"></param>
         public ClassicLru(int capacity)
             : this(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default)
         {
         }
 
+        /// <summary>
+        /// Initializes a new instance of the ClassicLru class with the specified concurrencyLevel, capacity and equality comparer.
+        /// </summary>
+        /// <param name="concurrencyLevel">The concurrency level.</param>
+        /// <param name="capacity">The capacity.</param>
+        /// <param name="comparer">The key comparer</param>
+        /// <exception cref="ArgumentOutOfRangeException"></exception>
+        /// <exception cref="ArgumentNullException"></exception>
         public ClassicLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)
         {
             if (capacity < 3)
@@ -58,8 +69,10 @@ public ClassicLru(int concurrencyLevel, int capacity, IEqualityComparer<K> compa
         ///<inheritdoc/>
         public Optional<ICacheMetrics> Metrics => new Optional<ICacheMetrics>(this.metrics);
 
+        ///<inheritdoc/>
         public Optional<ICacheEvents<K, V>> Events => Optional<ICacheEvents<K, V>>.None();
 
+        ///<inheritdoc/>
         public CachePolicy Policy => this.policy;
 
         /// <summary>
diff --git a/BitFaster.Caching/Lru/ConcurrentLru.cs b/BitFaster.Caching/Lru/ConcurrentLru.cs
index 36886f65..13313707 100644
--- a/BitFaster.Caching/Lru/ConcurrentLru.cs
+++ b/BitFaster.Caching/Lru/ConcurrentLru.cs
@@ -20,11 +20,11 @@ public ConcurrentLru(int capacity)
 
         /// <summary>
         /// Initializes a new instance of the ConcurrentLru class that has the specified concurrency level, has the 
-        /// specified initial capacity, and uses the specified IEqualityComparer<T>.
+        /// specified initial capacity, and uses the specified IEqualityComparer.
         /// </summary>
         /// <param name="concurrencyLevel">The estimated number of threads that will update the ConcurrentLru concurrently.</param>
         /// <param name="capacity">The maximum number of elements that the ConcurrentLru can contain.</param>
-        /// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>
+        /// <param name="comparer">The IEqualityComparer implementation to use when comparing keys.</param>
         public ConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)
             : base(concurrencyLevel, new FavorWarmPartition(capacity), comparer, default, default)
         {
@@ -32,11 +32,11 @@ public ConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K> co
 
         /// <summary>
         /// Initializes a new instance of the ConcurrentLru class that has the specified concurrency level, has the 
-        /// specified initial capacity, and uses the specified IEqualityComparer<T>.
+        /// specified initial capacity, and uses the specified IEqualityComparer.
         /// </summary>
         /// <param name="concurrencyLevel">The estimated number of threads that will update the ConcurrentLru concurrently.</param>
         /// <param name="capacity">The maximum number of elements that the ConcurrentLru can contain.</param>
-        /// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>
+        /// <param name="comparer">The IEqualityComparer implementation to use when comparing keys.</param>
         public ConcurrentLru(int concurrencyLevel, ICapacityPartition capacity, IEqualityComparer<K> comparer)
             : base(concurrencyLevel, capacity, comparer, default, default)
         {
diff --git a/BitFaster.Caching/Lru/ConcurrentLruBuilderExtensions.cs b/BitFaster.Caching/Lru/ConcurrentLruBuilderExtensions.cs
index 69038488..9132ecbc 100644
--- a/BitFaster.Caching/Lru/ConcurrentLruBuilderExtensions.cs
+++ b/BitFaster.Caching/Lru/ConcurrentLruBuilderExtensions.cs
@@ -1,13 +1,12 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using BitFaster.Caching.Lru.Builder;
 using BitFaster.Caching.Atomic;
 
 namespace BitFaster.Caching.Lru
 {
+    /// <summary>
+    /// Extension methods to support building all cache variants.
+    /// </summary>
     public static class ConcurrentLruBuilderExtensions
     {
         /// <summary>
diff --git a/BitFaster.Caching/Lru/ConcurrentTLru.cs b/BitFaster.Caching/Lru/ConcurrentTLru.cs
index 58f94d37..829bdf6e 100644
--- a/BitFaster.Caching/Lru/ConcurrentTLru.cs
+++ b/BitFaster.Caching/Lru/ConcurrentTLru.cs
@@ -22,11 +22,11 @@ public ConcurrentTLru(int capacity, TimeSpan timeToLive)
 
         /// <summary>
         /// Initializes a new instance of the ConcurrentTLru class that has the specified concurrency level, has the 
-        /// specified initial capacity, uses the specified IEqualityComparer<T>, and has the specified time to live.
+        /// specified initial capacity, uses the specified IEqualityComparer, and has the specified time to live.
         /// </summary>
         /// <param name="concurrencyLevel">The estimated number of threads that will update the ConcurrentTLru concurrently.</param>
         /// <param name="capacity">The maximum number of elements that the ConcurrentTLru can contain.</param>
-        /// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>
+        /// <param name="comparer">The IEqualityComparer implementation to use when comparing keys.</param>
         /// <param name="timeToLive">The time to live for cached values.</param>
         public ConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)
             : base(concurrencyLevel, new FavorWarmPartition(capacity), comparer, new TLruLongTicksPolicy<K, V>(timeToLive), default)
@@ -35,11 +35,11 @@ public ConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> c
 
         /// <summary>
         /// Initializes a new instance of the ConcurrentTLru class that has the specified concurrency level, has the 
-        /// specified initial capacity, uses the specified IEqualityComparer<T>, and has the specified time to live.
+        /// specified initial capacity, uses the specified IEqualityComparer, and has the specified time to live.
         /// </summary>
         /// <param name="concurrencyLevel">The estimated number of threads that will update the ConcurrentTLru concurrently.</param>
         /// <param name="capacity">The maximum number of elements that the ConcurrentTLru can contain.</param>
-        /// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>
+        /// <param name="comparer">The IEqualityComparer implementation to use when comparing keys.</param>
         /// <param name="timeToLive">The time to live for cached values.</param>
         public ConcurrentTLru(int concurrencyLevel, ICapacityPartition capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)
             : base(concurrencyLevel, capacity, comparer, new TLruLongTicksPolicy<K, V>(timeToLive), default)
diff --git a/BitFaster.Caching/Lru/EqualCapacityPartition.cs b/BitFaster.Caching/Lru/EqualCapacityPartition.cs
index 9417f879..9aaa5d8f 100644
--- a/BitFaster.Caching/Lru/EqualCapacityPartition.cs
+++ b/BitFaster.Caching/Lru/EqualCapacityPartition.cs
@@ -1,9 +1,5 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Lru
 {
@@ -17,6 +13,10 @@ public class EqualCapacityPartition : ICapacityPartition
         private readonly int warmCapacity;
         private readonly int coldCapacity;
 
+        /// <summary>
+        /// Initializes a new instance of the EqualCapacityPartition class with the specified total capacity.
+        /// </summary>
+        /// <param name="totalCapacity">The total capacity.</param>
         public EqualCapacityPartition(int totalCapacity)
         {
             var (hot, warm, cold) = ComputeQueueCapacity(totalCapacity);
@@ -25,10 +25,13 @@ public EqualCapacityPartition(int totalCapacity)
             this.coldCapacity = cold;
         }
 
+        ///<inheritdoc/>
         public int Cold => this.coldCapacity;
 
+        ///<inheritdoc/>
         public int Warm => this.warmCapacity;
 
+        ///<inheritdoc/>
         public int Hot => this.hotCapacity;
 
         private static (int hot, int warm, int cold) ComputeQueueCapacity(int capacity)
diff --git a/BitFaster.Caching/Lru/FastConcurrentLru.cs b/BitFaster.Caching/Lru/FastConcurrentLru.cs
index 86c0b0f2..09662d54 100644
--- a/BitFaster.Caching/Lru/FastConcurrentLru.cs
+++ b/BitFaster.Caching/Lru/FastConcurrentLru.cs
@@ -20,11 +20,11 @@ public FastConcurrentLru(int capacity)
 
         /// <summary>
         /// Initializes a new instance of the FastConcurrentLru class that has the specified concurrency level, has the 
-        /// specified initial capacity, and uses the specified IEqualityComparer<T>.
+        /// specified initial capacity, and uses the specified IEqualityComparer.
         /// </summary>
         /// <param name="concurrencyLevel">The estimated number of threads that will update the FastConcurrentLru concurrently.</param>
         /// <param name="capacity">The maximum number of elements that the FastConcurrentLru can contain.</param>
-        /// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>
+        /// <param name="comparer">The IEqualityComparer implementation to use when comparing keys.</param>
         public FastConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)
             : base(concurrencyLevel, new FavorWarmPartition(capacity), comparer, default, default)
         {
@@ -32,11 +32,11 @@ public FastConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K
 
         /// <summary>
         /// Initializes a new instance of the FastConcurrentLru class that has the specified concurrency level, has the 
-        /// specified initial capacity, and uses the specified IEqualityComparer<T>.
+        /// specified initial capacity, and uses the specified IEqualityComparer.
         /// </summary>
         /// <param name="concurrencyLevel">The estimated number of threads that will update the FastConcurrentLru concurrently.</param>
         /// <param name="capacity">The maximum number of elements that the FastConcurrentLru can contain.</param>
-        /// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>
+        /// <param name="comparer">The IEqualityComparer implementation to use when comparing keys.</param>
         public FastConcurrentLru(int concurrencyLevel, ICapacityPartition capacity, IEqualityComparer<K> comparer)
             : base(concurrencyLevel, capacity, comparer, default, default)
         {
diff --git a/BitFaster.Caching/Lru/FastConcurrentTLru.cs b/BitFaster.Caching/Lru/FastConcurrentTLru.cs
index d437d665..422dab5c 100644
--- a/BitFaster.Caching/Lru/FastConcurrentTLru.cs
+++ b/BitFaster.Caching/Lru/FastConcurrentTLru.cs
@@ -22,11 +22,11 @@ public FastConcurrentTLru(int capacity, TimeSpan timeToLive)
 
         /// <summary>
         /// Initializes a new instance of the FastConcurrentTLru class that has the specified concurrency level, has the 
-        /// specified initial capacity, uses the specified IEqualityComparer<T>, and has the specified time to live.
+        /// specified initial capacity, uses the specified IEqualityComparer, and has the specified time to live.
         /// </summary>
         /// <param name="concurrencyLevel">The estimated number of threads that will update the FastConcurrentTLru concurrently.</param>
         /// <param name="capacity">The maximum number of elements that the FastConcurrentTLru can contain.</param>
-        /// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>
+        /// <param name="comparer">The IEqualityComparer implementation to use when comparing keys.</param>
         /// <param name="timeToLive">The time to live for cached values.</param>
         public FastConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)
             : base(concurrencyLevel, new FavorWarmPartition(capacity), comparer, new TLruLongTicksPolicy<K, V>(timeToLive), default)
@@ -35,11 +35,12 @@ public FastConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<
 
         /// <summary>
         /// Initializes a new instance of the FastConcurrentLru class that has the specified concurrency level, has the 
-        /// specified initial capacity, and uses the specified IEqualityComparer<T>.
+        /// specified initial capacity, and uses the specified IEqualityComparer.
         /// </summary>
         /// <param name="concurrencyLevel">The estimated number of threads that will update the FastConcurrentLru concurrently.</param>
         /// <param name="capacity">The maximum number of elements that the FastConcurrentLru can contain.</param>
-        /// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>
+        /// <param name="comparer">The IEqualityComparer implementation to use when comparing keys.</param>
+        /// <param name="timeToLive">The time to live for cached values.</param>
         public FastConcurrentTLru(int concurrencyLevel, ICapacityPartition capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)
             : base(concurrencyLevel, capacity, comparer, new TLruLongTicksPolicy<K, V>(timeToLive), default)
         {
diff --git a/BitFaster.Caching/Lru/FavorWarmPartition.cs b/BitFaster.Caching/Lru/FavorWarmPartition.cs
index 2ecc649f..5ceb82ee 100644
--- a/BitFaster.Caching/Lru/FavorWarmPartition.cs
+++ b/BitFaster.Caching/Lru/FavorWarmPartition.cs
@@ -14,15 +14,26 @@ public class FavorWarmPartition : ICapacityPartition
         private readonly int warmCapacity;
         private readonly int coldCapacity;
 
-        // Default to 80% capacity allocated to warm queue, 20% split equally for hot and cold.
-        // This favors frequently accessed items.
+        /// <summary>
+        /// Default to 80% capacity allocated to warm queue, 20% split equally for hot and cold.
+        /// This favors frequently accessed items.
+        /// </summary>
         public const double DefaultWarmRatio = 0.8;
 
+        /// <summary>
+        /// Initializes a new instance of the FavorWarmPartition class with the specified capacity and the default warm ratio.
+        /// </summary>
+        /// <param name="totalCapacity">The total capacity.</param>
         public FavorWarmPartition(int totalCapacity)
             : this(totalCapacity, DefaultWarmRatio)
         {
         }
 
+        /// <summary>
+        /// Initializes a new instance of the FavorWarmPartition class with the specified capacity and warm ratio.
+        /// </summary>
+        /// <param name="totalCapacity">The total capacity.</param>
+        /// <param name="warmRatio">The ratio of warm items to hot and cold items.</param>
         public FavorWarmPartition(int totalCapacity, double warmRatio)
         {
             var (hot, warm, cold) = ComputeQueueCapacity(totalCapacity, warmRatio);
@@ -31,10 +42,13 @@ public FavorWarmPartition(int totalCapacity, double warmRatio)
             this.coldCapacity = cold;
         }
 
+        ///<inheritdoc/>
         public int Cold => this.coldCapacity;
 
+        ///<inheritdoc/>
         public int Warm => this.warmCapacity;
 
+        ///<inheritdoc/>
         public int Hot => this.hotCapacity;
 
         private static (int hot, int warm, int cold) ComputeQueueCapacity(int capacity, double warmRatio)
diff --git a/BitFaster.Caching/Lru/IItemPolicy.cs b/BitFaster.Caching/Lru/IItemPolicy.cs
index f36b7967..af6ebdb6 100644
--- a/BitFaster.Caching/Lru/IItemPolicy.cs
+++ b/BitFaster.Caching/Lru/IItemPolicy.cs
@@ -1,29 +1,72 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Lru
 {
+    /// <summary>
+    /// Represents an LRU item policy.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
+    /// <typeparam name="I">The type of the LRU item.</typeparam>
     public interface IItemPolicy<in K, in V, I> where I : LruItem<K, V>
     {
+        /// <summary>
+        /// Creates an LRU item.
+        /// </summary>
+        /// <param name="key">The item key.</param>
+        /// <param name="value">The item value.</param>
+        /// <returns>An LRU item.</returns>
         I CreateItem(K key, V value);
 
+        /// <summary>
+        /// Touch an item on read.
+        /// </summary>
+        /// <param name="item">The item to touch.</param>
         void Touch(I item);
 
+        /// <summary>
+        /// Update an item.
+        /// </summary>
+        /// <param name="item">The item to update.</param>
         void Update(I item);
 
+        /// <summary>
+        /// Determine whether an item should be discarded.
+        /// </summary>
+        /// <param name="item">The item to check.</param>
+        /// <returns>true if the item should be discarded, otherwise false.</returns>
         bool ShouldDiscard(I item);
 
+        /// <summary>
+        /// Gets a value indicating whether this policy can discard items.
+        /// </summary>
+        /// <returns>true if the policy can discard items, otherwise false.</returns>
         bool CanDiscard();
 
+        /// <summary>
+        /// Route a hot item.
+        /// </summary>
+        /// <param name="item">The item to route.</param>
+        /// <returns>The destination for the specified item.</returns>
         ItemDestination RouteHot(I item);
 
+        /// <summary>
+        /// Route a warm item.
+        /// </summary>
+        /// <param name="item">The item to route.</param>
+        /// <returns>The destination for the specified item.</returns>
         ItemDestination RouteWarm(I item);
 
+        /// <summary>
+        /// Route a cold item.
+        /// </summary>
+        /// <param name="item">The item to route.</param>
+        /// <returns>The destination for the specified item.</returns>
         ItemDestination RouteCold(I item);
 
+        /// <summary>
+        /// The item time to live defined by the policy.
+        /// </summary>
         TimeSpan TimeToLive { get; }
     }
 }
diff --git a/BitFaster.Caching/Lru/ITelemetryPolicy.cs b/BitFaster.Caching/Lru/ITelemetryPolicy.cs
index 95793076..311c1ade 100644
--- a/BitFaster.Caching/Lru/ITelemetryPolicy.cs
+++ b/BitFaster.Caching/Lru/ITelemetryPolicy.cs
@@ -1,21 +1,42 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
+
 namespace BitFaster.Caching.Lru
 {
+    /// <summary>
+    /// Represents a telemetry policy.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
     public interface ITelemetryPolicy<K, V> : ICacheMetrics, ICacheEvents<K, V>
     {
+        /// <summary>
+        /// Increment the miss counter.
+        /// </summary>
         void IncrementMiss();
 
+        /// <summary>
+        /// Increment the hit counter.
+        /// </summary>
         void IncrementHit();
 
+        /// <summary>
+        /// Register the removal of an item.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="reason">The reason for removal.</param>
         void OnItemRemoved(K key, V value, ItemRemovedReason reason);
 
+        /// <summary>
+        /// Register the update of an item.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        /// <param name="value">The value.</param>
         void OnItemUpdated(K key, V value);
 
+        /// <summary>
+        /// Set the event source for any events that are fired.
+        /// </summary>
+        /// <param name="source">The event source.</param>
         void SetEventSource(object source);
     }
 }
diff --git a/BitFaster.Caching/Lru/ItemDestination.cs b/BitFaster.Caching/Lru/ItemDestination.cs
index 0741e246..9481ef56 100644
--- a/BitFaster.Caching/Lru/ItemDestination.cs
+++ b/BitFaster.Caching/Lru/ItemDestination.cs
@@ -1,15 +1,24 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
+
 namespace BitFaster.Caching.Lru
 {
+    /// <summary>
+    /// Specifies the destination for routing LRU items.
+    /// </summary>
     public enum ItemDestination
     {
+        /// <summary>
+        /// Route to the warm queue.
+        /// </summary>
         Warm,
+
+        /// <summary>
+        /// Route to the cold queue.
+        /// </summary>
         Cold,
+
+        /// <summary>
+        /// Remove the item.
+        /// </summary>
         Remove
     }	
 }
diff --git a/BitFaster.Caching/Lru/LongTickCountLruItem.cs b/BitFaster.Caching/Lru/LongTickCountLruItem.cs
index 8d182a6f..31de3feb 100644
--- a/BitFaster.Caching/Lru/LongTickCountLruItem.cs
+++ b/BitFaster.Caching/Lru/LongTickCountLruItem.cs
@@ -1,19 +1,28 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
+
 namespace BitFaster.Caching.Lru
 {
+    /// <summary>
+    /// Represents an LRU item that also stores tick count.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
     public class LongTickCountLruItem<K, V> : LruItem<K, V>
     {
+        /// <summary>
+        /// Initializes a new instance of the LongTickCountLruItem class with the specified key and value.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="tickCount">The tick count.</param>
         public LongTickCountLruItem(K key, V value, long tickCount)
             : base(key, value)
         {
             this.TickCount = tickCount;
         }
 
+        /// <summary>
+        /// Gets or sets the tick count.
+        /// </summary>
         public long TickCount { get; set; }
     }
 }
diff --git a/BitFaster.Caching/Lru/LruItem.cs b/BitFaster.Caching/Lru/LruItem.cs
index 2c05ee7f..56944316 100644
--- a/BitFaster.Caching/Lru/LruItem.cs
+++ b/BitFaster.Caching/Lru/LruItem.cs
@@ -1,32 +1,49 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
+
 namespace BitFaster.Caching.Lru
 {
+    /// <summary>
+    /// Represents an LRU item.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
     public class LruItem<K, V>
     {
         private volatile bool wasAccessed;
         private volatile bool wasRemoved;
 
+        /// <summary>
+        /// Initializes a new instance of the LruItem class with the specified key and value.
+        /// </summary>
+        /// <param name="k">The key.</param>
+        /// <param name="v">The value.</param>
         public LruItem(K k, V v)
         {
             this.Key = k;
             this.Value = v;
         }
 
+        /// <summary>
+        /// Gets the key.
+        /// </summary>
         public readonly K Key;
 
+        /// <summary>
+        /// Gets or sets the value.
+        /// </summary>
         public V Value { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether the item was accessed.
+        /// </summary>
         public bool WasAccessed
         {
             get => this.wasAccessed;
             set => this.wasAccessed = value;
         }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether the item was removed.
+        /// </summary>
         public bool WasRemoved
         {
             get => this.wasRemoved;
diff --git a/BitFaster.Caching/Lru/LruPolicy.cs b/BitFaster.Caching/Lru/LruPolicy.cs
index 05b07850..5982b6b9 100644
--- a/BitFaster.Caching/Lru/LruPolicy.cs
+++ b/BitFaster.Caching/Lru/LruPolicy.cs
@@ -1,9 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Lru
 {
@@ -12,37 +8,44 @@ namespace BitFaster.Caching.Lru
     /// </summary>
     public readonly struct LruPolicy<K, V> : IItemPolicy<K, V, LruItem<K, V>>
     {
+        ///<inheritdoc/>
         public TimeSpan TimeToLive => Defaults.Infinite;
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public LruItem<K, V> CreateItem(K key, V value)
         {
             return new LruItem<K, V>(key, value);
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Touch(LruItem<K, V> item)
         {
             item.WasAccessed = true;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Update(LruItem<K, V> item)
         {
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool ShouldDiscard(LruItem<K, V> item)
         {
             return false;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool CanDiscard()
         {
             return false;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ItemDestination RouteHot(LruItem<K, V> item)
         {
@@ -54,6 +57,7 @@ public ItemDestination RouteHot(LruItem<K, V> item)
             return ItemDestination.Cold;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ItemDestination RouteWarm(LruItem<K, V> item)
         {
@@ -65,6 +69,7 @@ public ItemDestination RouteWarm(LruItem<K, V> item)
             return ItemDestination.Cold;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ItemDestination RouteCold(LruItem<K, V> item)
         {
diff --git a/BitFaster.Caching/Lru/NoTelemetryPolicy.cs b/BitFaster.Caching/Lru/NoTelemetryPolicy.cs
index 5bd16826..4c62d951 100644
--- a/BitFaster.Caching/Lru/NoTelemetryPolicy.cs
+++ b/BitFaster.Caching/Lru/NoTelemetryPolicy.cs
@@ -1,26 +1,35 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Lru
 {
+    /// <summary>
+    /// Represents a telemtry policy that does not count or have events (is disabled).
+    /// This enables use of the cache without telemetry where maximum performance is required.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
     public struct NoTelemetryPolicy<K, V> : ITelemetryPolicy<K, V>
     {
+        ///<inheritdoc/>
         public double HitRatio => 0.0;
 
+        ///<inheritdoc/>
         public long Total => 0;
 
+        ///<inheritdoc/>
         public long Hits => 0;
 
+        ///<inheritdoc/>
         public long Misses => 0;
 
+        ///<inheritdoc/>
         public long Updated => 0;
 
+        ///<inheritdoc/>
         public long Evicted => 0;
 
+        ///<inheritdoc/>
         public event EventHandler<ItemRemovedEventArgs<K, V>> ItemRemoved
         {
             // no-op, nothing is registered
@@ -28,26 +37,31 @@ public event EventHandler<ItemRemovedEventArgs<K, V>> ItemRemoved
             remove { }
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void IncrementMiss()
         {
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void IncrementHit()
         {
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnItemRemoved(K key, V value, ItemRemovedReason reason)
         {
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void OnItemUpdated(K key, V value)
         {
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void SetEventSource(object source)
         {
diff --git a/BitFaster.Caching/Lru/TelemetryPolicy.cs b/BitFaster.Caching/Lru/TelemetryPolicy.cs
index e5a3566c..11290d48 100644
--- a/BitFaster.Caching/Lru/TelemetryPolicy.cs
+++ b/BitFaster.Caching/Lru/TelemetryPolicy.cs
@@ -1,10 +1,14 @@
 using System;
 using System.Diagnostics;
-using System.Threading;
 using BitFaster.Caching.Concurrent;
 
 namespace BitFaster.Caching.Lru
 {
+    /// <summary>
+    /// Represents a telemetry policy with counters and events.
+    /// </summary>
+    /// <typeparam name="K">The type of the Key</typeparam>
+    /// <typeparam name="V">The type of the value</typeparam>
     [DebuggerDisplay("Hit = {Hits}, Miss = {Misses}, Upd = {Updated}, Evict = {Evicted}")]
     public struct TelemetryPolicy<K, V> : ITelemetryPolicy<K, V>
     {
@@ -14,30 +18,40 @@ public struct TelemetryPolicy<K, V> : ITelemetryPolicy<K, V>
         private LongAdder updatedCount;
         private object eventSource;
 
+        ///<inheritdoc/>
         public event EventHandler<ItemRemovedEventArgs<K, V>> ItemRemoved;
 
+        ///<inheritdoc/>
         public double HitRatio => Total == 0 ? 0 : (double)Hits / (double)Total;
 
+        ///<inheritdoc/>
         public long Total => this.hitCount.Sum() + this.missCount.Sum();
 
+        ///<inheritdoc/>
         public long Hits => this.hitCount.Sum();
 
+        ///<inheritdoc/>
         public long Misses => this.missCount.Sum();
 
+        ///<inheritdoc/>
         public long Evicted => this.evictedCount.Sum();
 
+        ///<inheritdoc/>
         public long Updated => this.updatedCount.Sum();
 
+        ///<inheritdoc/>
         public void IncrementMiss()
         {
             this.missCount.Increment();
         }
 
+        ///<inheritdoc/>
         public void IncrementHit()
         {
             this.hitCount.Increment();
         }
 
+        ///<inheritdoc/>
         public void OnItemRemoved(K key, V value, ItemRemovedReason reason)
         {
             if (reason == ItemRemovedReason.Evicted)
@@ -49,11 +63,13 @@ public void OnItemRemoved(K key, V value, ItemRemovedReason reason)
             this.ItemRemoved?.Invoke(this.eventSource, new ItemRemovedEventArgs<K, V>(key, value, reason));
         }
 
+        ///<inheritdoc/>
         public void OnItemUpdated(K key, V value)
         {
             this.updatedCount.Increment();
         }
 
+        ///<inheritdoc/>
         public void SetEventSource(object source)
         {
             this.hitCount = new LongAdder();
diff --git a/BitFaster.Caching/Lru/TickCountLruItem.cs b/BitFaster.Caching/Lru/TickCountLruItem.cs
index 43eb06d3..3fae631a 100644
--- a/BitFaster.Caching/Lru/TickCountLruItem.cs
+++ b/BitFaster.Caching/Lru/TickCountLruItem.cs
@@ -1,19 +1,28 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Lru
 {
+    /// <summary>
+    /// Represents an LRU item that also stores tick count.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
     public class TickCountLruItem<K, V> : LruItem<K, V>
     {
+        /// <summary>
+        /// Initializes a new instance of the TickCountLruItem class with the specified key and value.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        /// <param name="value">The value.</param>
         public TickCountLruItem(K key, V value)
             : base(key, value)
         {
             this.TickCount = Environment.TickCount;
         }
 
+        /// <summary>
+        /// Gets or sets the tick count.
+        /// </summary>
         public int TickCount { get; set; }
     }
 }
diff --git a/BitFaster.Caching/Lru/TimeStampedLruItem.cs b/BitFaster.Caching/Lru/TimeStampedLruItem.cs
index 051aaa61..b05fc3c1 100644
--- a/BitFaster.Caching/Lru/TimeStampedLruItem.cs
+++ b/BitFaster.Caching/Lru/TimeStampedLruItem.cs
@@ -1,19 +1,28 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Lru
 {
+    /// <summary>
+    /// Represents an LRU item that also stores the item time stamp.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
     public class TimeStampedLruItem<K, V> : LruItem<K, V>
     {
+        /// <summary>
+        /// Initializes a new instance of the TimeStampedLruItem class with the specified key and value.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        /// <param name="value">The value.</param>
         public TimeStampedLruItem(K key, V value)
             : base(key, value)
         {
             this.TimeStamp = DateTime.UtcNow;
         }
 
+        /// <summary>
+        /// Gets or sets the time stamp.
+        /// </summary>
         public DateTime TimeStamp { get; set; }
     }
 }
diff --git a/BitFaster.Caching/Lru/TlruDateTimePolicy.cs b/BitFaster.Caching/Lru/TlruDateTimePolicy.cs
index 6191918e..effdab1f 100644
--- a/BitFaster.Caching/Lru/TlruDateTimePolicy.cs
+++ b/BitFaster.Caching/Lru/TlruDateTimePolicy.cs
@@ -1,9 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Lru
 {
@@ -15,31 +11,40 @@ namespace BitFaster.Caching.Lru
     {
         private readonly TimeSpan timeToLive;
 
+        ///<inheritdoc/>
         public TimeSpan TimeToLive => timeToLive;
 
+        /// <summary>
+        /// Initializes a new instance of the TLruDateTimePolicy class with the specified time to live.
+        /// </summary>
+        /// <param name="timeToLive">The time to live.</param>
         public TLruDateTimePolicy(TimeSpan timeToLive)
         {
             this.timeToLive = timeToLive;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public TimeStampedLruItem<K, V> CreateItem(K key, V value)
         {
             return new TimeStampedLruItem<K, V>(key, value);
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Touch(TimeStampedLruItem<K, V> item)
         {
             item.WasAccessed = true;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Update(TimeStampedLruItem<K, V> item)
         {
             item.TimeStamp = DateTime.UtcNow;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool ShouldDiscard(TimeStampedLruItem<K, V> item)
         {
@@ -51,12 +56,14 @@ public bool ShouldDiscard(TimeStampedLruItem<K, V> item)
             return false;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool CanDiscard()
         {
             return true;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ItemDestination RouteHot(TimeStampedLruItem<K, V> item)
         {
@@ -73,6 +80,7 @@ public ItemDestination RouteHot(TimeStampedLruItem<K, V> item)
             return ItemDestination.Cold;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ItemDestination RouteWarm(TimeStampedLruItem<K, V> item)
         {
@@ -89,6 +97,7 @@ public ItemDestination RouteWarm(TimeStampedLruItem<K, V> item)
             return ItemDestination.Cold;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ItemDestination RouteCold(TimeStampedLruItem<K, V> item)
         {
diff --git a/BitFaster.Caching/Lru/TlruLongTicksPolicy.cs b/BitFaster.Caching/Lru/TlruLongTicksPolicy.cs
index 599fb99b..6440b14d 100644
--- a/BitFaster.Caching/Lru/TlruLongTicksPolicy.cs
+++ b/BitFaster.Caching/Lru/TlruLongTicksPolicy.cs
@@ -1,10 +1,6 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Lru
 {
@@ -22,29 +18,37 @@ namespace BitFaster.Caching.Lru
         private static readonly double stopwatchAdjustmentFactor = Stopwatch.Frequency / (double)TimeSpan.TicksPerSecond;
         private readonly long timeToLive;
 
+        /// <summary>
+        /// Initializes a new instance of the TLruLongTicksPolicy class with the specified time to live.
+        /// </summary>
+        /// <param name="timeToLive">The time to live.</param>
         public TLruLongTicksPolicy(TimeSpan timeToLive)
         {
             this.timeToLive = ToTicks(timeToLive);
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public LongTickCountLruItem<K, V> CreateItem(K key, V value)
         {
             return new LongTickCountLruItem<K, V>(key, value, Stopwatch.GetTimestamp());
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Touch(LongTickCountLruItem<K, V> item)
         {
             item.WasAccessed = true;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Update(LongTickCountLruItem<K, V> item)
         {
             item.TickCount = Stopwatch.GetTimestamp();
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool ShouldDiscard(LongTickCountLruItem<K, V> item)
         {
@@ -56,12 +60,14 @@ public bool ShouldDiscard(LongTickCountLruItem<K, V> item)
             return false;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool CanDiscard()
         {
             return true;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ItemDestination RouteHot(LongTickCountLruItem<K, V> item)
         {
@@ -78,6 +84,7 @@ public ItemDestination RouteHot(LongTickCountLruItem<K, V> item)
             return ItemDestination.Cold;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ItemDestination RouteWarm(LongTickCountLruItem<K, V> item)
         {
@@ -94,6 +101,7 @@ public ItemDestination RouteWarm(LongTickCountLruItem<K, V> item)
             return ItemDestination.Cold;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ItemDestination RouteCold(LongTickCountLruItem<K, V> item)
         {
@@ -110,13 +118,24 @@ public ItemDestination RouteCold(LongTickCountLruItem<K, V> item)
             return ItemDestination.Remove;
         }
 
+        ///<inheritdoc/>
         public TimeSpan TimeToLive => FromTicks(timeToLive);
 
+        /// <summary>
+        /// Convert from TimeSpan to ticks.
+        /// </summary>
+        /// <param name="timespan">The time represented as a TimeSpan.</param>
+        /// <returns>The time represented as ticks.</returns>
         public static long ToTicks(TimeSpan timespan)
         {
             return (long)(timespan.Ticks * stopwatchAdjustmentFactor);
         }
 
+        /// <summary>
+        /// Convert from ticks to a TimeSpan.
+        /// </summary>
+        /// <param name="ticks">The time represented as ticks.</param>
+        /// <returns>The time represented as a TimeSpan.</returns>
         public static TimeSpan FromTicks(long ticks)
         { 
             return TimeSpan.FromTicks((long)(ticks / stopwatchAdjustmentFactor));
diff --git a/BitFaster.Caching/Lru/TlruTicksPolicy.cs b/BitFaster.Caching/Lru/TlruTicksPolicy.cs
index 532fe8c1..e800cfa1 100644
--- a/BitFaster.Caching/Lru/TlruTicksPolicy.cs
+++ b/BitFaster.Caching/Lru/TlruTicksPolicy.cs
@@ -1,9 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Lru
 {
@@ -20,31 +16,40 @@ namespace BitFaster.Caching.Lru
     {
         private readonly int timeToLive;
 
+        ///<inheritdoc/>
         public TimeSpan TimeToLive => TimeSpan.FromMilliseconds(timeToLive);
 
+        /// <summary>
+        /// Initializes a new instance of the TLruTicksPolicy class with the specified time to live.
+        /// </summary>
+        /// <param name="timeToLive">The time to live.</param>
         public TLruTicksPolicy(TimeSpan timeToLive)
         {
             this.timeToLive = (int)timeToLive.TotalMilliseconds;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public TickCountLruItem<K, V> CreateItem(K key, V value)
         {
             return new TickCountLruItem<K, V>(key, value);
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Touch(TickCountLruItem<K, V> item)
         {
             item.WasAccessed = true;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Update(TickCountLruItem<K, V> item)
         {
             item.TickCount = Environment.TickCount;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool ShouldDiscard(TickCountLruItem<K, V> item)
         {
@@ -56,12 +61,14 @@ public bool ShouldDiscard(TickCountLruItem<K, V> item)
             return false;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool CanDiscard()
         {
             return true;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ItemDestination RouteHot(TickCountLruItem<K, V> item)
         {
@@ -78,6 +85,7 @@ public ItemDestination RouteHot(TickCountLruItem<K, V> item)
             return ItemDestination.Cold;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ItemDestination RouteWarm(TickCountLruItem<K, V> item)
         {
@@ -94,6 +102,7 @@ public ItemDestination RouteWarm(TickCountLruItem<K, V> item)
             return ItemDestination.Cold;
         }
 
+        ///<inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ItemDestination RouteCold(TickCountLruItem<K, V> item)
         {
diff --git a/BitFaster.Caching/Optional.cs b/BitFaster.Caching/Optional.cs
index 34c92307..c00ad92f 100644
--- a/BitFaster.Caching/Optional.cs
+++ b/BitFaster.Caching/Optional.cs
@@ -11,10 +11,17 @@ public class Optional<T>
         private readonly T value;
         private readonly bool hasValue;
 
+        /// <summary>
+        /// Initializes a new instance of the Optional class.
+        /// </summary>
         public Optional()
         {
         }
 
+        /// <summary>
+        /// Initializes a new instance of the Optional class with the specified value.
+        /// </summary>
+        /// <param name="value">The value.</param>
         public Optional(T value)
         {
             this.value = value;
@@ -22,19 +29,19 @@ public Optional(T value)
         }
 
         /// <summary>
-        /// Gets the value of the current Optional<T> object if it has been assigned a valid underlying value.
+        /// Gets the value of the current Optional object if it has been assigned a valid underlying value.
         /// </summary>
         public T Value => this.value;
 
         /// <summary>
-        /// Gets a value indicating whether the current Optional<T> object has a valid value of its underlying type.
+        /// Gets a value indicating whether the current Optional object has a valid value of its underlying type.
         /// </summary>
         public bool HasValue => this.hasValue;
 
         /// <summary>
-        /// Creates an empty Optional<T>.
+        /// Creates an empty Optional.
         /// </summary>
-        /// <returns>An empty Optional<T>.</returns>
+        /// <returns>An empty Optional.</returns>
         public static Optional<T> None()
         {
             return new Optional<T>();
diff --git a/BitFaster.Caching/ReferenceCount.cs b/BitFaster.Caching/ReferenceCount.cs
index 71964d5b..d67a7314 100644
--- a/BitFaster.Caching/ReferenceCount.cs
+++ b/BitFaster.Caching/ReferenceCount.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Text;
 
 namespace BitFaster.Caching
 {
@@ -13,6 +12,11 @@ public class ReferenceCount<TValue> : IEquatable<ReferenceCount<TValue>>
         private readonly TValue value;
         private readonly int count;
 
+        /// <summary>
+        /// Initializes a new instance of the ReferenceCount class with the specified value.
+        /// Initial count is 1.
+        /// </summary>
+        /// <param name="value"></param>
         public ReferenceCount(TValue value)
         {
             this.value = value;
@@ -88,11 +92,23 @@ public override int GetHashCode()
             return hashCode;
         }
 
+        /// <summary>
+        /// Determines whether two ReferenceCount instances have the same value.
+        /// </summary>
+        /// <param name="left">The left ReferernceCount to compare, or null.</param>
+        /// <param name="right">The right ReferernceCount to compare, or null.</param>
+        /// <returns>true if the value of left is the same as the value of right; otherwise, false.</returns>
         public static bool operator ==(ReferenceCount<TValue> left, ReferenceCount<TValue> right)
         {
             return EqualityComparer<ReferenceCount<TValue>>.Default.Equals(left, right);
         }
 
+        /// <summary>
+        /// Determines whether two ReferenceCount instances have different values.
+        /// </summary>
+        /// <param name="left">The left ReferernceCount to compare, or null.</param>
+        /// <param name="right">The right ReferernceCount to compare, or null.</param>
+        /// <returns>true if the value of left is different from the value of right; otherwise, false.</returns>
         public static bool operator !=(ReferenceCount<TValue> left, ReferenceCount<TValue> right)
         {
             return !(left == right);
diff --git a/BitFaster.Caching/Scheduler/BackgroundThreadScheduler.cs b/BitFaster.Caching/Scheduler/BackgroundThreadScheduler.cs
index 7bb1bbdc..cd6d74c6 100644
--- a/BitFaster.Caching/Scheduler/BackgroundThreadScheduler.cs
+++ b/BitFaster.Caching/Scheduler/BackgroundThreadScheduler.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Runtime.Serialization;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using BitFaster.Caching.Buffers;
@@ -19,7 +16,11 @@ namespace BitFaster.Caching.Scheduler
     /// </remarks>
     public sealed class BackgroundThreadScheduler : IScheduler, IDisposable
     {
+        /// <summary>
+        /// The maximum number of work items to store.
+        /// </summary>
         public const int MaxBacklog = 16;
+
         private int count;
         private readonly CancellationTokenSource cts = new CancellationTokenSource();
         private readonly SemaphoreSlim semaphore = new SemaphoreSlim(0, MaxBacklog);
@@ -29,20 +30,28 @@ public sealed class BackgroundThreadScheduler : IScheduler, IDisposable
 
         TaskCompletionSource<bool> completion = new TaskCompletionSource<bool>();
 
+        /// <summary>
+        /// Initializes a new instance of the BackgroundThreadScheduler class.
+        /// </summary>
         public BackgroundThreadScheduler()
         {
             // dedicated thread
             Task.Factory.StartNew(() => Background(), TaskCreationOptions.LongRunning);
         }
 
+        ///<inheritdoc/>
         public Task Completion => completion.Task;
 
+        ///<inheritdoc/>
         public bool IsBackground => true;
 
+        ///<inheritdoc/>
         public long RunCount => count;
 
+        ///<inheritdoc/>
         public Optional<Exception> LastException => lastException;
 
+        ///<inheritdoc/>
         public void Run(Action action)
         {
             if (work.TryAdd(action) == BufferStatus.Success)
@@ -93,6 +102,9 @@ private async Task Background()
             completion.SetResult(true);
         }
 
+        /// <summary>
+        /// Terminate the background thread.
+        /// </summary>
         public void Dispose()
         {
             // prevent hang when cancel runs on the same thread
diff --git a/BitFaster.Caching/Scheduler/ForegroundScheduler.cs b/BitFaster.Caching/Scheduler/ForegroundScheduler.cs
index 70d4a233..4ead6f52 100644
--- a/BitFaster.Caching/Scheduler/ForegroundScheduler.cs
+++ b/BitFaster.Caching/Scheduler/ForegroundScheduler.cs
@@ -9,12 +9,16 @@ public sealed class ForegroundScheduler : IScheduler
     {
         private long count;
 
+        ///<inheritdoc/>
         public bool IsBackground => false;
 
+        ///<inheritdoc/>
         public long RunCount => count;
 
+        ///<inheritdoc/>
         public Optional<Exception> LastException => Optional<Exception>.None();
 
+        ///<inheritdoc/>
         public void Run(Action action)
         {
             count++;
diff --git a/BitFaster.Caching/Scheduler/IScheduler.cs b/BitFaster.Caching/Scheduler/IScheduler.cs
index e58da3ff..2b60ea20 100644
--- a/BitFaster.Caching/Scheduler/IScheduler.cs
+++ b/BitFaster.Caching/Scheduler/IScheduler.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Scheduler
 {
@@ -10,6 +7,9 @@ namespace BitFaster.Caching.Scheduler
     /// </summary>
     public interface IScheduler
     {
+        /// <summary>
+        /// Gets a value indicating whether this scheduler runs tasks in the background.
+        /// </summary>
         bool IsBackground { get; }
 
         /// <summary>
diff --git a/BitFaster.Caching/Scheduler/NullScheduler.cs b/BitFaster.Caching/Scheduler/NullScheduler.cs
index c77d6b81..b84cf3d4 100644
--- a/BitFaster.Caching/Scheduler/NullScheduler.cs
+++ b/BitFaster.Caching/Scheduler/NullScheduler.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Scheduler
 {
@@ -12,12 +9,16 @@ public sealed class NullScheduler : IScheduler
     {
         private long count;
 
+        ///<inheritdoc/>
         public bool IsBackground => false;
 
+        ///<inheritdoc/>
         public long RunCount => count;
 
+        ///<inheritdoc/>
         public Optional<Exception> LastException => Optional<Exception>.None();
 
+        ///<inheritdoc/>
         public void Run(Action action)
         {
             count++;
diff --git a/BitFaster.Caching/Scheduler/ThreadPoolScheduler.cs b/BitFaster.Caching/Scheduler/ThreadPoolScheduler.cs
index 9f08e665..075f5922 100644
--- a/BitFaster.Caching/Scheduler/ThreadPoolScheduler.cs
+++ b/BitFaster.Caching/Scheduler/ThreadPoolScheduler.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Scheduler
@@ -14,12 +11,16 @@ public sealed class ThreadPoolScheduler : IScheduler
         private long count;
         private Optional<Exception> lastException = Optional<Exception>.None();
 
+        ///<inheritdoc/>
         public bool IsBackground => true;
 
+        ///<inheritdoc/>
         public long RunCount => count;
 
+        ///<inheritdoc/>
         public Optional<Exception> LastException => lastException;
 
+        ///<inheritdoc/>
         public void Run(Action action)
         {
             count++;
diff --git a/BitFaster.Caching/Scoped.cs b/BitFaster.Caching/Scoped.cs
index 31705583..6d62bbc0 100644
--- a/BitFaster.Caching/Scoped.cs
+++ b/BitFaster.Caching/Scoped.cs
@@ -27,6 +27,9 @@ public Scoped(T value)
             this.refCount = new ReferenceCount<T>(value);
         }
 
+        /// <summary>
+        /// Gets a value indicating whether the scope is disposed.
+        /// </summary>
         public bool IsDisposed => isDisposed;
 
         /// <summary>
diff --git a/BitFaster.Caching/ScopedAsyncCache.cs b/BitFaster.Caching/ScopedAsyncCache.cs
index c2362dcf..0df0709b 100644
--- a/BitFaster.Caching/ScopedAsyncCache.cs
+++ b/BitFaster.Caching/ScopedAsyncCache.cs
@@ -19,6 +19,11 @@ public sealed class ScopedAsyncCache<K, V> : IScopedAsyncCache<K, V> where V : I
     {
         private readonly IAsyncCache<K, Scoped<V>> cache;
 
+        /// <summary>
+        /// Initializes a new instance of the ScopedAsyncCache class with the specified inner cache.
+        /// </summary>
+        /// <param name="cache">The decorated cache.</param>
+        /// <exception cref="ArgumentNullException"></exception>
         public ScopedAsyncCache(IAsyncCache<K, Scoped<V>> cache)
         {
             if (cache == null)
@@ -106,6 +111,7 @@ public bool TryUpdate(K key, V value)
             return this.cache.TryUpdate(key, new Scoped<V>(value));
         }
 
+        ///<inheritdoc/>
         public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()
         {
             foreach (var kvp in this.cache)
diff --git a/BitFaster.Caching/ScopedCache.cs b/BitFaster.Caching/ScopedCache.cs
index b3ac8fa0..e6713d49 100644
--- a/BitFaster.Caching/ScopedCache.cs
+++ b/BitFaster.Caching/ScopedCache.cs
@@ -18,6 +18,10 @@ public sealed class ScopedCache<K, V> : IScopedCache<K, V> where V : IDisposable
     {
         private readonly ICache<K, Scoped<V>> cache;
 
+        /// <summary>
+        /// Initializes a new instance of the ScopedCache class with the specified inner cache.
+        /// </summary>
+        /// <param name="cache">The decorated cache.</param>
         public ScopedCache(ICache<K, Scoped<V>> cache)
         {
             if (cache == null)
@@ -105,6 +109,7 @@ public bool TryUpdate(K key, V value)
             return this.cache.TryUpdate(key, new Scoped<V>(value));
         }
 
+        ///<inheritdoc/>
         public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()
         {
             foreach (var kvp in this.cache)
diff --git a/BitFaster.Caching/SingletonCache.cs b/BitFaster.Caching/SingletonCache.cs
index 9243a175..93fd330c 100644
--- a/BitFaster.Caching/SingletonCache.cs
+++ b/BitFaster.Caching/SingletonCache.cs
@@ -1,9 +1,6 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching
 {
@@ -29,11 +26,11 @@ public SingletonCache()
 
         /// <summary>
         /// Initializes a new instance of the SingletonCache that has the specified concurrency level, has the 
-        /// specified initial capacity, and uses the specified IEqualityComparer<T>.
+        /// specified initial capacity, and uses the specified IEqualityComparer.
         /// </summary>
         /// <param name="concurrencyLevel">The estimated number of threads that will update the SingletonCache concurrently.</param>
         /// <param name="capacity">The initial number of elements that the SingletonCache can contain.</param>
-        /// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>
+        /// <param name="comparer">The IEqualityComparer implementation to use when comparing keys.</param>
         public SingletonCache(int concurrencyLevel, int capacity, IEqualityComparer<TKey> comparer)
         {
             this.cache = new ConcurrentDictionary<TKey, ReferenceCount<TValue>>(concurrencyLevel, capacity, comparer);
diff --git a/BitFaster.Caching/SingletonCacheExtensions.cs b/BitFaster.Caching/SingletonCacheExtensions.cs
index 4dc8b2d1..d746c971 100644
--- a/BitFaster.Caching/SingletonCacheExtensions.cs
+++ b/BitFaster.Caching/SingletonCacheExtensions.cs
@@ -1,15 +1,16 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
+
 namespace BitFaster.Caching
 {
+    /// <summary>
+    /// Extension methods for the SingletonCache class.
+    /// </summary>
     public static class SingletonCacheExtensions
     {
         /// <summary>
         /// Acquire a singleton value for the specified key. The lifetime guarantees the value is alive and is a singleton 
         /// for the given key until the lifetime is disposed.
         /// </summary>
+        /// <param name="cache">The cache to use.</param>
         /// <param name="key">The key of the item</param>
         /// <returns>A value lifetime</returns>
         public static Lifetime<TValue> Acquire<TKey, TValue>(this SingletonCache<TKey, TValue> cache, TKey key)