more ctor (#34)

bitfaster · web-flow · commit 237b0dd90911 · 2020-06-15T19:24:59.000-07:00
diff --git a/BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs b/BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs
@@ -40,6 +40,14 @@ public void WhenComparerIsNullCtorThrows()
             constructor.Should().Throw<ArgumentNullException>();
         }
 
+        [Fact]
+        public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue()
+        {
+            var x = new ConcurrentTLru<int, int>(3);
+
+            x.GetOrAdd(1, k => k).Should().Be(1);
+        }
+
         [Fact]
 		public void WhenItemIsAddedCountIsCorrect()
 		{
diff --git a/BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs b/BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs
@@ -49,6 +49,14 @@ public void WhenComparerIsNullCtorThrows()
             constructor.Should().Throw<ArgumentNullException>();
         }
 
+        [Fact]
+        public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue()
+        {
+            var x = new ConcurrentLru<int, int>(3);
+
+            x.GetOrAdd(1, k => k).Should().Be(1);
+        }
+
         [Fact]
 		public void WhenItemIsAddedCountIsCorrect()
 		{
diff --git a/BitFaster.Caching.UnitTests/Lru/ConcurrentTLruTests.cs b/BitFaster.Caching.UnitTests/Lru/ConcurrentTLruTests.cs
@@ -21,6 +21,14 @@ public ConcurrentTLruTests()
             lru = new ConcurrentTLru<int, string>(1, capacity, EqualityComparer<int>.Default, timeToLive);
         }
 
+        [Fact]
+        public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue()
+        {
+            var x = new ConcurrentTLru<int, int>(3);
+
+            x.GetOrAdd(1, k => k).Should().Be(1);
+        }
+
         [Fact]
         public async Task WhenItemIsExpiredItIsRemoved()
         {
diff --git a/BitFaster.Caching.UnitTests/Lru/FastConcurrentLruTests.cs b/BitFaster.Caching.UnitTests/Lru/FastConcurrentLruTests.cs
@@ -19,5 +19,13 @@ public void ConstructAddAndRetrieveWithCustomComparerReturnsValue()
             lru.TryGet("FOO", out var value).Should().BeTrue();
             value.Should().Be(1);
         }
+
+        [Fact]
+        public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue()
+        {
+            var x = new FastConcurrentLru<int, int>(3);
+
+            x.GetOrAdd(1, k => k).Should().Be(1);
+        }
     }
 }
diff --git a/BitFaster.Caching.UnitTests/Lru/FastConcurrentTLruTests.cs b/BitFaster.Caching.UnitTests/Lru/FastConcurrentTLruTests.cs
@@ -19,5 +19,13 @@ public void ConstructAddAndRetrieveWithCustomComparerReturnsValue()
             lru.TryGet("FOO", out var value).Should().BeTrue();
             value.Should().Be(1);
         }
+
+        [Fact]
+        public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue()
+        {
+            var x = new FastConcurrentTLru<int, int>(3);
+
+            x.GetOrAdd(1, k => k).Should().Be(1);
+        }
     }
 }
diff --git a/BitFaster.Caching/Lru/ClassicLru.cs b/BitFaster.Caching/Lru/ClassicLru.cs
@@ -26,6 +26,11 @@ public sealed class ClassicLru<K, V> : ICache<K, V>
         private long requestHitCount;
         private long requestTotalCount;
 
+        public ClassicLru(int capacity)
+            : this(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default)
+        { 
+        }
+
         public ClassicLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)
         {
             if (capacity < 3)
diff --git a/BitFaster.Caching/Lru/ConcurrentLru.cs b/BitFaster.Caching/Lru/ConcurrentLru.cs
@@ -8,6 +8,11 @@ namespace BitFaster.Caching.Lru
 {
     public sealed class ConcurrentLru<K, V> : TemplateConcurrentLru<K, V, LruItem<K, V>, LruPolicy<K, V>, HitCounter>
     {
+        public ConcurrentLru(int capacity)
+            : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default, new LruPolicy<K, V>(), new HitCounter())
+        {
+        }
+
         public ConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)
             : base(concurrencyLevel, capacity, comparer, new LruPolicy<K, V>(), new HitCounter())
         {
diff --git a/BitFaster.Caching/Lru/ConcurrentTLru.cs b/BitFaster.Caching/Lru/ConcurrentTLru.cs
@@ -8,6 +8,11 @@ namespace BitFaster.Caching.Lru
 {
     public sealed class ConcurrentTLru<K, V> : TemplateConcurrentLru<K, V, TimeStampedLruItem<K, V>, TLruDateTimePolicy<K, V>, HitCounter>
     {
+        public ConcurrentTLru(int capacity)
+            : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default, new TLruDateTimePolicy<K, V>(), new HitCounter())
+        { 
+        }
+
         public ConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)
             : base(concurrencyLevel, capacity, comparer, new TLruDateTimePolicy<K, V>(timeToLive), new HitCounter())
         {
diff --git a/BitFaster.Caching/Lru/Defaults.cs b/BitFaster.Caching/Lru/Defaults.cs
@@ -0,0 +1,14 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BitFaster.Caching.Lru
+{
+    internal static class Defaults
+    {
+        public static int ConcurrencyLevel
+        {
+            get { return Environment.ProcessorCount; }
+        }
+    }
+}
diff --git a/BitFaster.Caching/Lru/FastConcurrentLru.cs b/BitFaster.Caching/Lru/FastConcurrentLru.cs
@@ -6,6 +6,11 @@ namespace BitFaster.Caching.Lru
 {
     public sealed class FastConcurrentLru<K, V> : TemplateConcurrentLru<K, V, LruItem<K, V>, LruPolicy<K, V>, NullHitCounter>
     {
+        public FastConcurrentLru(int capacity)
+            : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default, new LruPolicy<K, V>(), new NullHitCounter())
+        {
+        }
+
         public FastConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)
             : base(concurrencyLevel, capacity, comparer, new LruPolicy<K, V>(), new NullHitCounter())
         {
diff --git a/BitFaster.Caching/Lru/FastConcurrentTLru.cs b/BitFaster.Caching/Lru/FastConcurrentTLru.cs
@@ -6,6 +6,11 @@ namespace BitFaster.Caching.Lru
 {
     public sealed class FastConcurrentTLru<K, V> : TemplateConcurrentLru<K, V, TickCountLruItem<K, V>, TLruTicksPolicy<K, V>, NullHitCounter>
     {
+        public FastConcurrentTLru(int capacity)
+            : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default, new TLruTicksPolicy<K, V>(), new NullHitCounter())
+        {
+        }
+
         public FastConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)
             : base(concurrencyLevel, capacity, comparer, new TLruTicksPolicy<K, V>(timeToLive), new NullHitCounter())
         {
diff --git a/README.md b/README.md
@@ -23,9 +23,8 @@ High performance, thread-safe in-memory caching primitives for .NET.
 `ConcurrentLru` and `ConcurrentTLru` are intended as a drop in replacement for `ConcurrentDictionary`, and a much faster alternative to the `System.Runtime.Caching.MemoryCache` family of classes (e.g. `HttpRuntime.Cache`, `System.Web.Caching` etc). 
 
 ```csharp
-int concurrency = 4;
 int capacity = 666;
-var lru = new ConcurrentLru<int, SomeItem>(concurrency, capacity, EqualityComparer<int>.Default);
+var lru = new ConcurrentLru<int, SomeItem>(capacity);
 
 var value = lru.GetOrAdd(1, (k) => new SomeItem(k));
 var value = await lru.GetOrAddAsync(0, (k) => Task.FromResult(new SomeItem(k)));
@@ -39,9 +38,8 @@ All cache classes in BitFaster.Caching own the lifetime of cached values, and wi
 To avoid races using objects after they have been disposed by the cache, wrap them with `Scoped`. The call to `CreateLifetime` creates a `Lifetime` that guarantees the scoped object will not be disposed until the lifetime is disposed. `Scoped` is thread safe, and guarantees correct disposal for concurrent lifetimes. 
 
 ```csharp
-int concurrency = 4;
 int capacity = 666;
-var lru = new ConcurrentLru<int, Scoped<SomeDisposable>>(concurrency, capacity, EqualityComparer<int>.Default);
+var lru = new ConcurrentLru<int, Scoped<SomeDisposable>>(capacity);
 var valueFactory = new SomeDisposableValueFactory();
 
 using (var lifetime = lru.GetOrAdd(1, valueFactory.Create).CreateLifetime())

Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,14 @@ public void WhenComparerIsNullCtorThrows()`
`40`	`40`	`constructor.Should().Throw<ArgumentNullException>();`
`41`	`41`	`}`
`42`	`42`
	`43`	`+ [Fact]`
	`44`	`+ public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue()`
	`45`	`+ {`
	`46`	`+ var x = new ConcurrentTLru<int, int>(3);`
	`47`	`+`
	`48`	`+ x.GetOrAdd(1, k => k).Should().Be(1);`
	`49`	`+ }`
	`50`	`+`
`43`	`51`	`[Fact]`
`44`	`52`	`public void WhenItemIsAddedCountIsCorrect()`
`45`	`53`	`{`
Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,14 @@ public void WhenComparerIsNullCtorThrows()`
`49`	`49`	`constructor.Should().Throw<ArgumentNullException>();`
`50`	`50`	`}`
`51`	`51`
	`52`	`+ [Fact]`
	`53`	`+ public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue()`
	`54`	`+ {`
	`55`	`+ var x = new ConcurrentLru<int, int>(3);`
	`56`	`+`
	`57`	`+ x.GetOrAdd(1, k => k).Should().Be(1);`
	`58`	`+ }`
	`59`	`+`
`52`	`60`	`[Fact]`
`53`	`61`	`public void WhenItemIsAddedCountIsCorrect()`
`54`	`62`	`{`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,14 @@ public ConcurrentTLruTests()`
`21`	`21`	`lru = new ConcurrentTLru<int, string>(1, capacity, EqualityComparer<int>.Default, timeToLive);`
`22`	`22`	`}`
`23`	`23`
	`24`	`+ [Fact]`
	`25`	`+ public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue()`
	`26`	`+ {`
	`27`	`+ var x = new ConcurrentTLru<int, int>(3);`
	`28`	`+`
	`29`	`+ x.GetOrAdd(1, k => k).Should().Be(1);`
	`30`	`+ }`
	`31`	`+`
`24`	`32`	`[Fact]`
`25`	`33`	`public async Task WhenItemIsExpiredItIsRemoved()`
`26`	`34`	`{`
Original file line number	Diff line number	Diff line change
`@@ -19,5 +19,13 @@ public void ConstructAddAndRetrieveWithCustomComparerReturnsValue()`
`19`	`19`	`lru.TryGet("FOO", out var value).Should().BeTrue();`
`20`	`20`	`value.Should().Be(1);`
`21`	`21`	`}`
	`22`	`+`
	`23`	`+ [Fact]`
	`24`	`+ public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue()`
	`25`	`+ {`
	`26`	`+ var x = new FastConcurrentLru<int, int>(3);`
	`27`	`+`
	`28`	`+ x.GetOrAdd(1, k => k).Should().Be(1);`
	`29`	`+ }`
`22`	`30`	`}`
`23`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,11 @@ namespace BitFaster.Caching.Lru`
`8`	`8`	`{`
`9`	`9`	`public sealed class ConcurrentLru<K, V> : TemplateConcurrentLru<K, V, LruItem<K, V>, LruPolicy<K, V>, HitCounter>`
`10`	`10`	`{`
	`11`	`+ public ConcurrentLru(int capacity)`
	`12`	`+ : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default, new LruPolicy<K, V>(), new HitCounter())`
	`13`	`+ {`
	`14`	`+ }`
	`15`	`+`
`11`	`16`	`public ConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)`
`12`	`17`	`: base(concurrencyLevel, capacity, comparer, new LruPolicy<K, V>(), new HitCounter())`
`13`	`18`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,11 @@ namespace BitFaster.Caching.Lru`
`8`	`8`	`{`
`9`	`9`	`public sealed class ConcurrentTLru<K, V> : TemplateConcurrentLru<K, V, TimeStampedLruItem<K, V>, TLruDateTimePolicy<K, V>, HitCounter>`
`10`	`10`	`{`
	`11`	`+ public ConcurrentTLru(int capacity)`
	`12`	`+ : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default, new TLruDateTimePolicy<K, V>(), new HitCounter())`
	`13`	`+ {`
	`14`	`+ }`
	`15`	`+`
`11`	`16`	`public ConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)`
`12`	`17`	`: base(concurrencyLevel, capacity, comparer, new TLruDateTimePolicy<K, V>(timeToLive), new HitCounter())`
`13`	`18`	`{`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,11 @@ namespace BitFaster.Caching.Lru`
`6`	`6`	`{`
`7`	`7`	`public sealed class FastConcurrentLru<K, V> : TemplateConcurrentLru<K, V, LruItem<K, V>, LruPolicy<K, V>, NullHitCounter>`
`8`	`8`	`{`
	`9`	`+ public FastConcurrentLru(int capacity)`
	`10`	`+ : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default, new LruPolicy<K, V>(), new NullHitCounter())`
	`11`	`+ {`
	`12`	`+ }`
	`13`	`+`
`9`	`14`	`public FastConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)`
`10`	`15`	`: base(concurrencyLevel, capacity, comparer, new LruPolicy<K, V>(), new NullHitCounter())`
`11`	`16`	`{`