consistent names (#6)

Author: bitfaster

Lightweight.Caching.Benchmarks/LruGetOrAddTest.cs

@@ -38,6 +38,12 @@ public void DictionaryGetOrAdd()
             dictionary.GetOrAdd(1, func);
         }
 
+        [Benchmark()]
+        public DateTime DateTimeUtcNow()
+        {
+            return DateTime.UtcNow;
+        }
+
         [Benchmark]
         public void SegmentedLruGetOrAdd()
         {
@@ -46,28 +52,28 @@ public void SegmentedLruGetOrAdd()
         }
 
         [Benchmark]
-        public void OldLru2GetOrAdd()
+        public void ClassNoTtlPolicyGetOrAdd()
         {
             Func<int, int> func = x => x;
             segmentedLru2.GetOrAdd(1, func);
         }
 
         [Benchmark()]
-        public void ConcurrentLruGetOrAdd()
+        public void ConcurrentLruTemplGetOrAdd()
         {
             Func<int, int> func = x => x;
             concurrentLru.GetOrAdd(1, func);
         }
 
         [Benchmark()]
-        public void ConcurrentLruHitGetOrAdd()
+        public void ConcurrentLruTemplHitGetOrAdd()
         {
             Func<int, int> func = x => x;
             concurrentLruHit.GetOrAdd(1, func);
         }
 
         [Benchmark()]
-        public void ConcurrentLruNoExpireGetOrAdd()
+        public void ConcurrentLruGetOrAdd()
         {
             Func<int, int> func = x => x;
             concurrentLruNoExpire.GetOrAdd(1, func);
@@ -80,12 +86,6 @@ public void ConcurrentLruExpireGetOrAdd()
             concurrentLruExpire.GetOrAdd(1, func);
         }
 
-        [Benchmark()]
-        public DateTime Now()
-        {
-            return DateTime.UtcNow;
-        }
-
         private int MyFunc(int i)
         {
             return i;

Lightweight.Caching/SingletonCache.cs

@@ -14,27 +14,27 @@ public class SingletonCache<TKey, TValue>
 
 		public Handle Acquire(TKey key)
 		{
-			ReferenceCount lockObjectHolder = this.cache.AddOrUpdate(key,
+			ReferenceCount refCount = this.cache.AddOrUpdate(key,
 					(_) => new ReferenceCount(),
-					(_, lockObjectHolder2) => lockObjectHolder2.PlusOneReferenceCountCopy());
+					(_, existingRefCount) => existingRefCount.IncrementCopy());
 
-			return new Handle(key, lockObjectHolder.Value, this);
+			return new Handle(key, refCount.Value, this);
 		}
 
 		private void Release(TKey key)
 		{
 			while (true)
 			{
-				ReferenceCount oldLockObjectHolder = this.cache[key];
-				ReferenceCount newLockObjectHolder = oldLockObjectHolder.MinusOneReferenceCountCopy();
-				if (this.cache.TryUpdate(key, newLockObjectHolder, oldLockObjectHolder))
+				ReferenceCount oldRefCount = this.cache[key];
+				ReferenceCount newRefCount = oldRefCount.DecrementCopy();
+				if (this.cache.TryUpdate(key, newRefCount, oldRefCount))
 				{
-					if (newLockObjectHolder.Count == 0)
+					if (newRefCount.Count == 0)
 					{
 						// This will remove from dictionary only if key and the value with ReferenceCount (== 0) matches (under a lock)
-						if (((IDictionary<TKey, ReferenceCount>)this.cache).Remove(new KeyValuePair<TKey, ReferenceCount>(key, newLockObjectHolder)))
+						if (((IDictionary<TKey, ReferenceCount>)this.cache).Remove(new KeyValuePair<TKey, ReferenceCount>(key, newRefCount)))
 						{
-							if (newLockObjectHolder.Value is IDisposable d)
+							if (newRefCount.Value is IDisposable d)
 							{
 								d.Dispose();
 							}
@@ -89,12 +89,12 @@ public override bool Equals(object obj)
 				return refCount != null && refCount.Value != null && refCount.Value.Equals(this.value) && refCount.referenceCount == this.referenceCount;
 			}
 
-			public ReferenceCount PlusOneReferenceCountCopy()
+			public ReferenceCount IncrementCopy()
 			{
 				return new ReferenceCount(this.value, this.referenceCount + 1);
 			}
 
-			public ReferenceCount MinusOneReferenceCountCopy()
+			public ReferenceCount DecrementCopy()
 			{
 				return new ReferenceCount(this.value, this.referenceCount - 1);
 			}
@@ -104,13 +104,13 @@ public sealed class Handle : IDisposable
 		{
 			private TKey key;
 			private TValue value;
-			private SingletonCache<TKey, TValue> lockObjectCache;
+			private SingletonCache<TKey, TValue> cache;
 
-			public Handle(TKey key, TValue lockObject, SingletonCache<TKey, TValue> lockObjectCache)
+			public Handle(TKey key, TValue value, SingletonCache<TKey, TValue> cache)
 			{
 				this.key = key;
-				this.value = lockObject;
-				this.lockObjectCache = lockObjectCache;
+				this.value = value;
+				this.cache = cache;
 			}
 
 			public TValue Value
@@ -123,10 +123,10 @@ public TValue Value
 
 			public void Dispose()
 			{
-				if (this.lockObjectCache != null)
+				if (this.cache != null)
 				{
-					this.lockObjectCache.Release(this.key);
-					this.lockObjectCache = null;
+					this.cache.Release(this.key);
+					this.cache = null;
 				}
 			}
 		}