private CacheItem GetAutoReloadDataWithCacheInner <T>(
string key,
Func <T> dataFactory,
Func <string> eTagFactory,
TimeSpan timeToLive,
TimeSpan dataUpdateDetectInternal,
bool shouldReloadInBackground)
{
if (TryGetDataInner(key, out CacheItem cacheItem) &&
shouldReloadInBackground)
{
var isUpdateProbobalyNeeded = cacheItem.LastETagCheckUtc.AddSafe(dataUpdateDetectInternal) < DateTimeOffset.UtcNow;
if (isUpdateProbobalyNeeded)
{
#pragma warning disable VSTHRD110
Task.Run(() =>
#pragma warning restore VSTHRD110
{
SetOrUpdateLazyData(key, cacheItem, LazyUtils.ToLazy(dataFactory), LazyUtils.ToLazy(eTagFactory), timeToLive, dataUpdateDetectInternal, shouldWaitForLock: false);
});
}
return(cacheItem);
}
return(SetOrUpdateLazyData(key, cacheItem, LazyUtils.ToLazy(dataFactory), LazyUtils.ToLazy(eTagFactory), timeToLive, dataUpdateDetectInternal, shouldWaitForLock: true));
}
public void TestToLazy_AsyncCollection()
{
var lazy = LazyUtils.ToLazy(async() => new List <MemoryStream> {
new MemoryStream(), new MemoryStream(), new MemoryStream()
});
(lazy is IDisposable).Should().BeTrue();
}
public void TestToLazy_Collection()
{
var lazy = LazyUtils.ToLazy(() => new List <int> {
1, 2, 3
});
(lazy is IDisposable).Should().BeTrue();
}
public async Task TestCacheDelete_LazyCollectionDataShouldBeDisposedAsync()
{
ICacheInstance cache = MemoryCache.GetNamedInstance(nameof(TestCacheDelete_LazyDataShouldBeDisposedAsync));
cache.CleanInternal = TimeSpan.FromSeconds(1);
var data = LazyUtils.ToLazy(() => new[] { new DummyDisposable() });
var key = Guid.NewGuid().ToString();
cache.SetData(key, data, TimeSpan.MaxValue);
Console.WriteLine(data.Value.GetHashCode());
cache.TryDeleteKey(key).Should().BeTrue();
data.Value.ForEach(_ => _.IsDisposed.Should().Be(false));
await Task.Delay(cache.CleanInternal.Add(TimeSpan.FromMilliseconds(500)));
cache.CleanIfNeeded();
data.Value.ForEach(_ => _.IsDisposed.Should().Be(true));
}
public void EnsureValueDisposed_NotCreated()
{
var disposable = new DummyDisposable();
disposable.IsDisposed.Should().BeFalse();
var lazyAsync = LazyUtils.ToLazy(() => disposable);
if (lazyAsync is IDisposable disposableLazyAsync)
{
disposableLazyAsync.Dispose();
disposable.IsDisposed.Should().BeFalse();
}
else
{
Assert.Fail("lazy should be disposable");
}
}
public void EnsureValueDisposed_Collection()
{
var disposables = new List <DummyDisposable> {
new DummyDisposable(), new DummyDisposable()
};
disposables.ForEach(_ => _.IsDisposed.Should().BeFalse());
var lazyAsync = LazyUtils.ToLazy(() => disposables);
lazyAsync.Value.Should().NotBeNull();
if (lazyAsync is IDisposable disposableLazyAsync)
{
disposableLazyAsync.Dispose();
disposables.ForEach(_ => _.IsDisposed.Should().BeTrue());
}
else
{
Assert.Fail("lazy should be disposable");
}
}
public async Task HttpGetETagCacheTestsAsync()
{
ICacheInstance cache = MemoryCache.GetNamedInstance(Guid.NewGuid().ToString());
using (var client = new HttpClient())
{
var baseUrl = $"https://httpbin.org/etag/";
var etag = Guid.NewGuid();
int counter1 = 0;
int counter2 = 0;
var lazyResponse = LazyUtils.ToLazy(async() =>
{
Interlocked.Increment(ref counter1);
var request = new HttpRequestMessage(HttpMethod.Get, $"{baseUrl}{etag}");
return(await client.SendAsync(request).ConfigureAwait(false));
});
cache.GetAutoReloadDataWithCache(
baseUrl,
async() =>
{
Interlocked.Increment(ref counter2);
return(await lazyResponse.Value.Content.ReadAsStringAsync().ConfigureAwait(false));
},
() => Task.FromResult(lazyResponse.Value.Headers.ETag?.Tag),
TimeSpan.FromHours(1),
TimeSpan.FromMilliseconds(100));
counter1.Should().Be(1);
counter2.Should().Be(1);
lazyResponse = LazyUtils.ToLazy(async() =>
{
Interlocked.Increment(ref counter1);
var request = new HttpRequestMessage(HttpMethod.Get, $"{baseUrl}{etag}");
return(await client.SendAsync(request).ConfigureAwait(false));
});
cache.GetAutoReloadDataWithCache(
baseUrl,
async() =>
{
Interlocked.Increment(ref counter2);
return(await lazyResponse.Value.Content.ReadAsStringAsync().ConfigureAwait(false));
},
() => Task.FromResult(lazyResponse.Value.Headers.ETag?.Tag),
TimeSpan.FromHours(1),
TimeSpan.FromMilliseconds(100));
counter1.Should().Be(1);
counter2.Should().Be(1);
await Task.Delay(150);
lazyResponse = LazyUtils.ToLazy(async() =>
{
Interlocked.Increment(ref counter1);
var request = new HttpRequestMessage(HttpMethod.Get, $"{baseUrl}{etag}");
return(await client.SendAsync(request).ConfigureAwait(false));
});
cache.GetAutoReloadDataWithCache(
baseUrl,
async() =>
{
Interlocked.Increment(ref counter2);
return(await lazyResponse.Value.Content.ReadAsStringAsync().ConfigureAwait(false));
},
() => Task.FromResult(lazyResponse.Value.Headers.ETag?.Tag),
TimeSpan.FromHours(1),
TimeSpan.FromMilliseconds(100));
counter1.Should().Be(1);
counter2.Should().Be(1);
etag = Guid.NewGuid();
await Task.Delay(50);
lazyResponse = LazyUtils.ToLazy(async() =>
{
Interlocked.Increment(ref counter1);
var request = new HttpRequestMessage(HttpMethod.Get, $"{baseUrl}{etag}");
return(await client.SendAsync(request).ConfigureAwait(false));
});
cache.GetAutoReloadDataWithCache(
baseUrl,
async() =>
{
Interlocked.Increment(ref counter2);
return(await lazyResponse.Value.Content.ReadAsStringAsync().ConfigureAwait(false));
},
() => Task.FromResult(lazyResponse.Value.Headers.ETag?.Tag),
TimeSpan.FromHours(1),
TimeSpan.FromMilliseconds(100));
counter1.Should().Be(2);
counter2.Should().Be(1);
await Task.Delay(150);
lazyResponse = LazyUtils.ToLazy(async() =>
{
Interlocked.Increment(ref counter1);
var request = new HttpRequestMessage(HttpMethod.Get, $"{baseUrl}{etag}");
return(await client.SendAsync(request).ConfigureAwait(false));
});
cache.GetAutoReloadDataWithCache(
baseUrl,
async() =>
{
Interlocked.Increment(ref counter2);
return(await lazyResponse.Value.Content.ReadAsStringAsync().ConfigureAwait(false));
},
() => Task.FromResult(lazyResponse.Value.Headers.ETag?.Tag),
TimeSpan.FromHours(1),
TimeSpan.FromMilliseconds(100));
counter1.Should().Be(3);
counter2.Should().Be(2);
}
}
public void TestToLazy_AsyncDisposable()
{
var lazy = LazyUtils.ToLazy(async() => new MemoryStream());
(lazy is IDisposable).Should().BeTrue();
}
public void TestToLazy_AsyncNonDisposable()
{
var lazy = LazyUtils.ToLazy(async() => 3);
(lazy is IDisposable).Should().BeFalse();
}