From a62ce3851a105572f356d9f882a00db71de8bda8 Mon Sep 17 00:00:00 2001 From: alexpeck Date: Mon, 15 Jun 2020 19:23:24 -0700 Subject: [PATCH] more ctor --- BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs | 8 ++++++++ .../Lru/ConcurrentLruTests.cs | 8 ++++++++ .../Lru/ConcurrentTLruTests.cs | 8 ++++++++ .../Lru/FastConcurrentLruTests.cs | 8 ++++++++ .../Lru/FastConcurrentTLruTests.cs | 8 ++++++++ BitFaster.Caching/Lru/ClassicLru.cs | 5 +++++ BitFaster.Caching/Lru/ConcurrentLru.cs | 5 +++++ BitFaster.Caching/Lru/ConcurrentTLru.cs | 5 +++++ BitFaster.Caching/Lru/Defaults.cs | 14 ++++++++++++++ BitFaster.Caching/Lru/FastConcurrentLru.cs | 5 +++++ BitFaster.Caching/Lru/FastConcurrentTLru.cs | 5 +++++ README.md | 6 ++---- 12 files changed, 81 insertions(+), 4 deletions(-) create mode 100644 BitFaster.Caching/Lru/Defaults.cs diff --git a/BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs b/BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs index 2c2eee46..819a1fd6 100644 --- a/BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs +++ b/BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs @@ -40,6 +40,14 @@ public void WhenComparerIsNullCtorThrows() constructor.Should().Throw(); } + [Fact] + public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue() + { + var x = new ConcurrentTLru(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 index 63944049..61928e8f 100644 --- a/BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs +++ b/BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs @@ -49,6 +49,14 @@ public void WhenComparerIsNullCtorThrows() constructor.Should().Throw(); } + [Fact] + public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue() + { + var x = new ConcurrentLru(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 index 6b38ac51..acb6e01a 100644 --- a/BitFaster.Caching.UnitTests/Lru/ConcurrentTLruTests.cs +++ b/BitFaster.Caching.UnitTests/Lru/ConcurrentTLruTests.cs @@ -21,6 +21,14 @@ public ConcurrentTLruTests() lru = new ConcurrentTLru(1, capacity, EqualityComparer.Default, timeToLive); } + [Fact] + public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue() + { + var x = new ConcurrentTLru(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 index 8ebc660c..318a8145 100644 --- 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(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 index 45388f49..00e1fa24 100644 --- 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(3); + + x.GetOrAdd(1, k => k).Should().Be(1); + } } } diff --git a/BitFaster.Caching/Lru/ClassicLru.cs b/BitFaster.Caching/Lru/ClassicLru.cs index cf5e59e2..5178858c 100644 --- a/BitFaster.Caching/Lru/ClassicLru.cs +++ b/BitFaster.Caching/Lru/ClassicLru.cs @@ -26,6 +26,11 @@ public sealed class ClassicLru : ICache private long requestHitCount; private long requestTotalCount; + public ClassicLru(int capacity) + : this(Defaults.ConcurrencyLevel, capacity, EqualityComparer.Default) + { + } + public ClassicLru(int concurrencyLevel, int capacity, IEqualityComparer comparer) { if (capacity < 3) diff --git a/BitFaster.Caching/Lru/ConcurrentLru.cs b/BitFaster.Caching/Lru/ConcurrentLru.cs index 2da59b18..aac3023a 100644 --- a/BitFaster.Caching/Lru/ConcurrentLru.cs +++ b/BitFaster.Caching/Lru/ConcurrentLru.cs @@ -8,6 +8,11 @@ namespace BitFaster.Caching.Lru { public sealed class ConcurrentLru : TemplateConcurrentLru, LruPolicy, HitCounter> { + public ConcurrentLru(int capacity) + : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer.Default, new LruPolicy(), new HitCounter()) + { + } + public ConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer comparer) : base(concurrencyLevel, capacity, comparer, new LruPolicy(), new HitCounter()) { diff --git a/BitFaster.Caching/Lru/ConcurrentTLru.cs b/BitFaster.Caching/Lru/ConcurrentTLru.cs index 2168450e..6a96cf3f 100644 --- a/BitFaster.Caching/Lru/ConcurrentTLru.cs +++ b/BitFaster.Caching/Lru/ConcurrentTLru.cs @@ -8,6 +8,11 @@ namespace BitFaster.Caching.Lru { public sealed class ConcurrentTLru : TemplateConcurrentLru, TLruDateTimePolicy, HitCounter> { + public ConcurrentTLru(int capacity) + : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer.Default, new TLruDateTimePolicy(), new HitCounter()) + { + } + public ConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer comparer, TimeSpan timeToLive) : base(concurrencyLevel, capacity, comparer, new TLruDateTimePolicy(timeToLive), new HitCounter()) { diff --git a/BitFaster.Caching/Lru/Defaults.cs b/BitFaster.Caching/Lru/Defaults.cs new file mode 100644 index 00000000..dc059ccd --- /dev/null +++ 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 index fb615006..e69b4db5 100644 --- a/BitFaster.Caching/Lru/FastConcurrentLru.cs +++ b/BitFaster.Caching/Lru/FastConcurrentLru.cs @@ -6,6 +6,11 @@ namespace BitFaster.Caching.Lru { public sealed class FastConcurrentLru : TemplateConcurrentLru, LruPolicy, NullHitCounter> { + public FastConcurrentLru(int capacity) + : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer.Default, new LruPolicy(), new NullHitCounter()) + { + } + public FastConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer comparer) : base(concurrencyLevel, capacity, comparer, new LruPolicy(), new NullHitCounter()) { diff --git a/BitFaster.Caching/Lru/FastConcurrentTLru.cs b/BitFaster.Caching/Lru/FastConcurrentTLru.cs index 49f365ce..145d7bfd 100644 --- a/BitFaster.Caching/Lru/FastConcurrentTLru.cs +++ b/BitFaster.Caching/Lru/FastConcurrentTLru.cs @@ -6,6 +6,11 @@ namespace BitFaster.Caching.Lru { public sealed class FastConcurrentTLru : TemplateConcurrentLru, TLruTicksPolicy, NullHitCounter> { + public FastConcurrentTLru(int capacity) + : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer.Default, new TLruTicksPolicy(), new NullHitCounter()) + { + } + public FastConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer comparer, TimeSpan timeToLive) : base(concurrencyLevel, capacity, comparer, new TLruTicksPolicy(timeToLive), new NullHitCounter()) { diff --git a/README.md b/README.md index 5d7a96c4..edddc63f 100644 --- 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(concurrency, capacity, EqualityComparer.Default); +var lru = new ConcurrentLru(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>(concurrency, capacity, EqualityComparer.Default); +var lru = new ConcurrentLru>(capacity); var valueFactory = new SomeDisposableValueFactory(); using (var lifetime = lru.GetOrAdd(1, valueFactory.Create).CreateLifetime())