public void Should_execute_oncachemiss_but_not_oncacheput_if_cache_does_not_hold_value_and_returned_value_not_worth_caching()
{
const string valueToReturn = null;
const string executionKey = "SomeExecutionKey";
string keyPassedToOnCacheMiss = null;
string keyPassedToOnCachePut = null;
Context contextToExecute = new Context(executionKey);
Context contextPassedToOnCacheMiss = null;
Context contextPassedToOnCachePut = null;
Action <Context, string, Exception> noErrorHandling = (_, __, ___) => { };
Action <Context, string> emptyDelegate = (_, __) => { };
Action <Context, string> onCacheMiss = (ctx, key) => { contextPassedToOnCacheMiss = ctx; keyPassedToOnCacheMiss = key; };
Action <Context, string> onCachePut = (ctx, key) => { contextPassedToOnCachePut = ctx; keyPassedToOnCachePut = key; };
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, new RelativeTtl(TimeSpan.MaxValue), DefaultCacheKeyStrategy.Instance, emptyDelegate, onCacheMiss, onCachePut, noErrorHandling, noErrorHandling);
stubCacheProvider.Get(executionKey).Should().BeNull();
cache.Execute(() => { return(valueToReturn); }, contextToExecute).Should().Be(valueToReturn);
contextPassedToOnCacheMiss.Should().BeSameAs(contextToExecute);
keyPassedToOnCacheMiss.Should().Be(executionKey);
contextPassedToOnCachePut.Should().BeNull();
keyPassedToOnCachePut.Should().BeNull();
}
public void Should_execute_oncachemiss_but_not_oncacheput_if_cache_does_not_hold_value_and_returned_value_not_worth_caching()
{
const string valueToReturn = "valueToReturn";
const string operationKey = "SomeOperationKey";
string keyPassedToOnCacheMiss = null;
string keyPassedToOnCachePut = null;
Context contextToExecute = new Context(operationKey);
Context contextPassedToOnCacheMiss = null;
Context contextPassedToOnCachePut = null;
Action <Context, string, Exception> noErrorHandling = (_, _, _) => { };
Action <Context, string> emptyDelegate = (_, _) => { };
Action <Context, string> onCacheMiss = (ctx, key) => { contextPassedToOnCacheMiss = ctx; keyPassedToOnCacheMiss = key; };
Action <Context, string> onCachePut = (ctx, key) => { contextPassedToOnCachePut = ctx; keyPassedToOnCachePut = key; };
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, new RelativeTtl(TimeSpan.Zero), DefaultCacheKeyStrategy.Instance, emptyDelegate, onCacheMiss, onCachePut, noErrorHandling, noErrorHandling);
(bool cacheHit, object fromCache) = stubCacheProvider.TryGet(operationKey);
cacheHit.Should().BeFalse();
fromCache.Should().BeNull();
cache.Execute(_ => valueToReturn, contextToExecute).Should().Be(valueToReturn);
contextPassedToOnCacheMiss.Should().BeSameAs(contextToExecute);
keyPassedToOnCacheMiss.Should().Be(operationKey);
contextPassedToOnCachePut.Should().BeNull();
keyPassedToOnCachePut.Should().BeNull();
}
public void Should_execute_oncacheget_after_got_from_cache()
{
const string valueToReturnFromCache = "valueToReturnFromCache";
const string valueToReturnFromExecution = "valueToReturnFromExecution";
const string executionKey = "SomeExecutionKey";
string keyPassedToDelegate = null;
Context contextToExecute = new Context(executionKey);
Context contextPassedToDelegate = null;
Action <Context, string, Exception> noErrorHandling = (_, __, ___) => { };
Action <Context, string> emptyDelegate = (_, __) => { };
Action <Context, string> onCacheAction = (ctx, key) => { contextPassedToDelegate = ctx; keyPassedToDelegate = key; };
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, new RelativeTtl(TimeSpan.MaxValue), DefaultCacheKeyStrategy.Instance, onCacheAction, emptyDelegate, emptyDelegate, noErrorHandling, noErrorHandling);
stubCacheProvider.Put(executionKey, valueToReturnFromCache, new Ttl(TimeSpan.MaxValue));
bool delegateExecuted = false;
cache.Execute(() =>
{
delegateExecuted = true;
return(valueToReturnFromExecution);
}, contextToExecute)
.Should().Be(valueToReturnFromCache);
delegateExecuted.Should().BeFalse();
contextPassedToDelegate.Should().BeSameAs(contextToExecute);
keyPassedToDelegate.Should().Be(executionKey);
}
public void Should_call_onError_delegate_if_cache_put_errors()
{
Exception ex = new Exception();
ISyncCacheProvider stubCacheProvider = new StubErroringCacheProvider(getException: null, putException: ex);
Exception exceptionFromCacheProvider = null;
const string valueToReturn = "valueToReturn";
const string operationKey = "SomeOperationKey";
Action <Context, string, Exception> onError = (ctx, key, exc) => { exceptionFromCacheProvider = exc; };
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.MaxValue, onError);
(bool cacheHit1, object fromCache1) = stubCacheProvider.TryGet(operationKey);
cacheHit1.Should().BeFalse();
fromCache1.Should().BeNull();
cache.Execute(ctx => valueToReturn, new Context(operationKey)).Should().Be(valueToReturn);
// error should be captured by onError delegate.
exceptionFromCacheProvider.Should().Be(ex);
// failed to put it in the cache
(bool cacheHit2, object fromCache2) = stubCacheProvider.TryGet(operationKey);
cacheHit2.Should().BeFalse();
fromCache2.Should().BeNull();
}
private static void _06_緩存()
{
var memoryCache = new MemoryCache(new MemoryCacheOptions());
var memoryCacheProvider = new MemoryCacheProvider(memoryCache);
if (s_cachePolicy == null)
{
s_cachePolicy = Policy.Cache(memoryCacheProvider, TimeSpan.FromSeconds(5));
}
var result = s_cachePolicy.Execute(context =>
{
Console.WriteLine("快取過期，更新快取內容");
var names = new List <string>();
var number = FakeData.NumberData.GetNumber(1, 10);
for (var i = 0; i < number; i++)
{
names.Add(FakeData.NameData.GetFullName());
}
return(names);
}, new Context("datakey"));
var json = JsonConvert.SerializeObject(result);
Console.WriteLine($"取得資料:{json}");
Console.WriteLine("隔離策略，完成");
}
public void Should_honour_cancellation_even_if_prior_execution_has_cached()
{
const string valueToReturn = "valueToReturn";
const string operationKey = "SomeOperationKey";
CachePolicy cache = Policy.Cache(new StubCacheProvider(), TimeSpan.MaxValue);
CancellationTokenSource tokenSource = new CancellationTokenSource();
int delegateInvocations = 0;
Func <Context, CancellationToken, string> func = (ctx, ct) =>
{
// delegate does not observe cancellation token; test is whether CacheEngine does.
delegateInvocations++;
return(valueToReturn);
};
cache.Execute(func, new Context(operationKey), tokenSource.Token).Should().Be(valueToReturn);
delegateInvocations.Should().Be(1);
tokenSource.Cancel();
cache.Invoking(policy => policy.Execute(func, new Context(operationKey), tokenSource.Token))
.ShouldThrow <OperationCanceledException>();
delegateInvocations.Should().Be(1);
}
public void Should_call_onError_delegate_if_cache_get_errors()
{
Exception ex = new Exception();
ISyncCacheProvider stubCacheProvider = new StubErroringCacheProvider(getException: ex, putException: null);
Exception exceptionFromCacheProvider = null;
const string valueToReturnFromCache = "valueToReturnFromCache";
const string valueToReturnFromExecution = "valueToReturnFromExecution";
const string operationKey = "SomeOperationKey";
Action <Context, string, Exception> onError = (ctx, key, exc) => { exceptionFromCacheProvider = exc; };
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.MaxValue, onError);
stubCacheProvider.Put(operationKey, valueToReturnFromCache, new Ttl(TimeSpan.MaxValue));
bool delegateExecuted = false;
// Even though value is in cache, get will error; so value is returned from execution.
cache.Execute(ctx =>
{
delegateExecuted = true;
return(valueToReturnFromExecution);
}, new Context(operationKey))
.Should().Be(valueToReturnFromExecution);
delegateExecuted.Should().BeTrue();
// And error should be captured by onError delegate.
exceptionFromCacheProvider.Should().Be(ex);
}
public void Should_execute_delegate_and_put_value_in_cache_but_when_it_expires_execute_delegate_again()
{
const string valueToReturn = "valueToReturn";
const string operationKey = "SomeOperationKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
TimeSpan ttl = TimeSpan.FromMinutes(30);
CachePolicy <string> cache = Policy.Cache <string>(stubCacheProvider, ttl);
(bool cacheHit1, object fromCache1) = stubCacheProvider.TryGet(operationKey);
cacheHit1.Should().BeFalse();
fromCache1.Should().BeNull();
int delegateInvocations = 0;
Func <Context, string> func = _ =>
{
delegateInvocations++;
return(valueToReturn);
};
DateTimeOffset fixedTime = SystemClock.DateTimeOffsetUtcNow();
SystemClock.DateTimeOffsetUtcNow = () => fixedTime;
// First execution should execute delegate and put result in the cache.
cache.Execute(func, new Context(operationKey)).Should().Be(valueToReturn);
delegateInvocations.Should().Be(1);
(bool cacheHit2, object fromCache2) = stubCacheProvider.TryGet(operationKey);
cacheHit2.Should().BeTrue();
fromCache2.Should().Be(valueToReturn);
// Second execution (before cache expires) should get it from the cache - no further delegate execution.
// (Manipulate time so just prior cache expiry).
SystemClock.DateTimeOffsetUtcNow = () => fixedTime.Add(ttl).AddSeconds(-1);
cache.Execute(func, new Context(operationKey)).Should().Be(valueToReturn);
delegateInvocations.Should().Be(1);
// Manipulate time to force cache expiry.
SystemClock.DateTimeOffsetUtcNow = () => fixedTime.Add(ttl).AddSeconds(1);
// Third execution (cache expired) should not get it from the cache - should cause further delegate execution.
cache.Execute(func, new Context(operationKey)).Should().Be(valueToReturn);
delegateInvocations.Should().Be(2);
}
public void Should_always_execute_delegate_if_execution_key_not_set()
{
string valueToReturn = Guid.NewGuid().ToString();
CachePolicy <string> cache = Policy.Cache <string>(new StubCacheProvider(), TimeSpan.MaxValue);
int delegateInvocations = 0;
Func <string> func = () =>
{
delegateInvocations++;
return(valueToReturn);
};
cache.Execute(func /*, no execution key */).Should().Be(valueToReturn);
delegateInvocations.Should().Be(1);
cache.Execute(func /*, no execution key */).Should().Be(valueToReturn);
delegateInvocations.Should().Be(2);
}
/// <summary>
/// Compiles the input linqExpression into a Linq expression tree
/// </summary>
/// <param name="linqExpression">The linqExpression.</param>
/// <returns></returns>
public Action <object, object> CompileAction(LinqExpressionToRun linqExpression)
{
if (linqExpression.Unique) //don't bother caching
{
_counterActionCacheUnique.Increment();
return(_handler.CompileAction(linqExpression));
}
var key = GenerateKey(linqExpression);
return(_cacheActions.Execute(context => _handler.CompileAction(linqExpression), new Context(key)));
}
public void Should_allow_custom_FuncCacheKeyStrategy()
{
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.MaxValue, context => context.ExecutionKey + context["id"]);
object person1 = new object();
stubCacheProvider.Put("person1", person1, new Ttl(TimeSpan.MaxValue));
object person2 = new object();
stubCacheProvider.Put("person2", person2, new Ttl(TimeSpan.MaxValue));
bool funcExecuted = false;
Func <object> func = () => { funcExecuted = true; return(new object()); };
cache.Execute(func, new Context("person", new { id = "1" }.AsDictionary())).Should().BeSameAs(person1);
funcExecuted.Should().BeFalse();
cache.Execute(func, new Context("person", new { id = "2" }.AsDictionary())).Should().BeSameAs(person2);
funcExecuted.Should().BeFalse();
}
public void Should_allow_custom_FuncICacheKeyStrategy()
{
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy <ResultClass> cache = Policy.Cache <ResultClass>(stubCacheProvider, TimeSpan.MaxValue, context => context.ExecutionKey + context["id"]);
object person1 = new ResultClass(ResultPrimitive.Good, "person1");
stubCacheProvider.Put("person1", person1, new Ttl(TimeSpan.MaxValue));
object person2 = new ResultClass(ResultPrimitive.Good, "person2");
stubCacheProvider.Put("person2", person2, new Ttl(TimeSpan.MaxValue));
bool funcExecuted = false;
Func <ResultClass> func = () => { funcExecuted = true; return(new ResultClass(ResultPrimitive.Fault, "should never return this one")); };
cache.Execute(func, new Context("person", new { id = "1" }.AsDictionary())).Should().BeSameAs(person1);
funcExecuted.Should().BeFalse();
cache.Execute(func, new Context("person", new { id = "2" }.AsDictionary())).Should().BeSameAs(person2);
funcExecuted.Should().BeFalse();
}
/// <inheritdoc />
public IReceivedMessageInternal GetNextMessage(List <string> routes)
{
if (routes != null && routes.Count > 0)
{
throw new NotSupportedException("The in-memory transport does not support routes");
}
if (!Queues[_connectionInformation].TryDequeue(out var id))
{
return(null);
}
if (!QueueData[_connectionInformation].TryRemove(id, out var item))
{
return(null);
}
var hasError = false;
try
{
var newMessage = _messageFactory.Create(item.Body, item.Headers);
if (!string.IsNullOrEmpty(item.JobName))
{
var key = GenerateKey(item.JobName);
//add it to the cache
JobLastEventCache.Execute(context => item.JobEventTime, new Context(key));
}
Interlocked.Increment(ref DequeueCounts[_connectionInformation].ProcessedCount);
return(_receivedMessageFactory.Create(newMessage,
new MessageQueueId(id),
new MessageCorrelationId(item.CorrelationId)));
}
catch (Exception error)
{
hasError = true;
//at this point, the record has been de-queued, but it can't be processed.
throw new PoisonMessageException(
"An error has occurred trying to re-assemble a message", error,
new MessageQueueId(id), null, null, null);
}
finally
{
if (!hasError)
{
QueueWorking[_connectionInformation].TryAdd(item.Id, item);
}
}
}
public void Should_execute_delegate_and_put_value_in_cache_for_non_nullable_types_if_cache_does_not_hold_value()
{
const ResultPrimitive valueToReturn = ResultPrimitive.Substitute;
const string operationKey = "SomeOperationKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.MaxValue);
stubCacheProvider.Get(operationKey).Should().BeNull();
cache.Execute(ctx => { return(valueToReturn); }, new Context(operationKey)).Should().Be(valueToReturn);
stubCacheProvider.Get(operationKey).Should().Be(valueToReturn);
}
public void Should_execute_delegate_but_not_put_value_in_cache_if_cache_does_not_hold_value_but_ttl_indicates_not_worth_caching()
{
const string valueToReturn = "valueToReturn";
const string executionKey = "SomeExecutionKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.Zero);
stubCacheProvider.Get(executionKey).Should().BeNull();
cache.Execute(() => { return(valueToReturn); }, new Context(executionKey)).Should().Be(valueToReturn);
stubCacheProvider.Get(executionKey).Should().Be(null);
}
public void Should_execute_delegate_and_put_value_in_cache_if_cache_does_not_hold_value()
{
const string valueToReturn = "valueToReturn";
const string executionKey = "SomeExecutionKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy <string> cache = Policy.Cache <string>(stubCacheProvider, TimeSpan.MaxValue);
stubCacheProvider.Get(executionKey).Should().BeNull();
cache.Execute(() => { return(valueToReturn); }, new Context(executionKey)).Should().Be(valueToReturn);
stubCacheProvider.Get(executionKey).Should().Be(valueToReturn);
}
public void Should_return_value_from_cache_and_not_execute_delegate_if_prior_execution_has_cached()
{
const string valueToReturn = "valueToReturn";
const string executionKey = "SomeExecutionKey";
CachePolicy <string> cache = Policy.Cache <string>(new StubCacheProvider(), TimeSpan.MaxValue);
int delegateInvocations = 0;
Func <string> func = () =>
{
delegateInvocations++;
return(valueToReturn);
};
cache.Execute(func, new Context(executionKey)).Should().Be(valueToReturn);
delegateInvocations.Should().Be(1);
cache.Execute(func, new Context(executionKey)).Should().Be(valueToReturn);
delegateInvocations.Should().Be(1);
cache.Execute(func, new Context(executionKey)).Should().Be(valueToReturn);
delegateInvocations.Should().Be(1);
}
public void Should_not_error_for_executions_on_non_nullable_types_if_cache_does_not_hold_value()
{
const string operationKey = "SomeOperationKey";
bool onErrorCalled = false;
Action <Context, string, Exception> onError = (ctx, key, exc) => { onErrorCalled = true; };
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.MaxValue, onError);
stubCacheProvider.Get(operationKey).Should().BeNull();
ResultPrimitive result = cache.Execute(ctx => ResultPrimitive.Substitute, new Context(operationKey));
onErrorCalled.Should().BeFalse();
}
public void Should_not_execute_oncachemiss_if_dont_query_cache_because_cache_key_not_set()
{
string valueToReturn = Guid.NewGuid().ToString();
Action <Context, string, Exception> noErrorHandling = (_, __, ___) => { };
Action <Context, string> emptyDelegate = (_, __) => { };
bool onCacheMissExecuted = false;
Action <Context, string> onCacheMiss = (ctx, key) => { onCacheMissExecuted = true; };
CachePolicy cache = Policy.Cache(new StubCacheProvider(), new RelativeTtl(TimeSpan.MaxValue), DefaultCacheKeyStrategy.Instance, emptyDelegate, onCacheMiss, emptyDelegate, noErrorHandling, noErrorHandling);
cache.Execute(() => valueToReturn /*, no execution key */).Should().Be(valueToReturn);
onCacheMissExecuted.Should().BeFalse();
}
public void Should_execute_delegate_but_not_put_value_in_cache_if_cache_does_not_hold_value_but_ttl_indicates_not_worth_caching()
{
const string valueToReturn = "valueToReturn";
const string operationKey = "SomeOperationKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.Zero);
(bool cacheHit1, object fromCache1) = stubCacheProvider.TryGet(operationKey);
cacheHit1.Should().BeFalse();
fromCache1.Should().BeNull();
cache.Execute(ctx => { return(valueToReturn); }, new Context(operationKey)).Should().Be(valueToReturn);
(bool cacheHit2, object fromCache2) = stubCacheProvider.TryGet(operationKey);
cacheHit2.Should().BeFalse();
fromCache2.Should().BeNull();
}
public void Should_execute_delegate_and_put_value_in_cache_if_cache_does_not_hold_value__default_for_value_type()
{
ResultPrimitive valueToReturn = default(ResultPrimitive);
const string operationKey = "SomeOperationKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.MaxValue);
(bool cacheHit1, object fromCache1) = stubCacheProvider.TryGet(operationKey);
cacheHit1.Should().BeFalse();
fromCache1.Should().BeNull();
cache.Execute(ctx => { return(valueToReturn); }, new Context(operationKey)).Should().Be(valueToReturn);
(bool cacheHit2, object fromCache2) = stubCacheProvider.TryGet(operationKey);
cacheHit2.Should().BeTrue();
fromCache2.Should().Be(valueToReturn);
}
public void Should_execute_delegate_and_put_value_in_cache_if_cache_does_not_hold_value()
{
const string valueToReturn = "valueToReturn";
const string operationKey = "SomeOperationKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy <string> cache = Policy.Cache <string>(stubCacheProvider, TimeSpan.MaxValue);
(bool cacheHit1, object fromCache1) = stubCacheProvider.TryGet(operationKey);
cacheHit1.Should().BeFalse();
fromCache1.Should().BeNull();
cache.Execute(_ => valueToReturn, new Context(operationKey)).Should().Be(valueToReturn);
(bool cacheHit2, object fromCache2) = stubCacheProvider.TryGet(operationKey);
cacheHit2.Should().BeTrue();
fromCache2.Should().Be(valueToReturn);
}
public async Task <IActionResult> Get()
{
// HttpClient clnt = new HttpClient();
// var response = clnt.GetAsync("http://localhost:7637/api/values").Result;
//Specify the name of the Response. If the method is taking parameter, we can append the actual parameter to cache unique responses separately
Context policyExecutionContext = new Context($"GetUsers");
var response = _cachePolicy.Execute(() => _resilientClient.Get("http://localhost:7637/api/values"), policyExecutionContext);
if (response.IsSuccessStatusCode)
{
var result = response.Content.ReadAsStringAsync();
return(Ok(result));
}
return(StatusCode((int)response.StatusCode, response.Content.ReadAsStringAsync()));
}
public static void Caching()
{
ErrorProneCode errorProneCode = new ErrorProneCode();
var memoryCache = new MemoryCache(new MemoryCacheOptions());
var memoryCacheProvider = new MemoryCacheProvider(memoryCache);
#region caching
CachePolicy <int> cachePolicy =
Policy.Cache <int>(memoryCacheProvider, TimeSpan.FromSeconds(1.5));
for (int loop = 1; loop <= 10; loop++)
{
int result = cachePolicy.Execute(context => errorProneCode.GetSomeNumberThatMightBeCacheable(), new Context("ContextKey"));
Console.WriteLine($"result={result}. cachePolicy executed {loop} time(s). GetSomeNumberThatMightBeCacheable method really called {result} time(s).");
Thread.Sleep(500);
}
#endregion
}
public void Should_return_value_from_cache_and_not_execute_delegate_if_cache_holds_value()
{
const string valueToReturnFromCache = "valueToReturnFromCache";
const string valueToReturnFromExecution = "valueToReturnFromExecution";
const string executionKey = "SomeExecutionKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy <string> cache = Policy.Cache <string>(stubCacheProvider, TimeSpan.MaxValue);
stubCacheProvider.Put(executionKey, valueToReturnFromCache, new Ttl(TimeSpan.MaxValue));
bool delegateExecuted = false;
cache.Execute(() =>
{
delegateExecuted = true;
return(valueToReturnFromExecution);
}, new Context(executionKey))
.Should().Be(valueToReturnFromCache);
delegateExecuted.Should().BeFalse();
}
public void Should_return_value_from_cache_and_not_execute_delegate_if_cache_holds_value__default_for_reference_type()
{
ResultClass valueToReturnFromCache = default;
ResultClass valueToReturnFromExecution = new ResultClass(ResultPrimitive.Good);
const string operationKey = "SomeOperationKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy <ResultClass> cache = Policy.Cache <ResultClass>(stubCacheProvider, TimeSpan.MaxValue);
stubCacheProvider.Put(operationKey, valueToReturnFromCache, new Ttl(TimeSpan.MaxValue));
bool delegateExecuted = false;
cache.Execute(_ =>
{
delegateExecuted = true;
return(valueToReturnFromExecution);
}, new Context(operationKey))
.Should().Be(valueToReturnFromCache);
delegateExecuted.Should().BeFalse();
}
private static void Demo5()
{
// Polly5.9.0 和 Polly6.0.1差异
IMemoryCache memoryCache = new MemoryCache(new MemoryCacheOptions());
ISyncCacheProvider memoryCacheProvider = new Polly.Caching.MemoryCache.MemoryCacheProvider(memoryCache);
CachePolicy policy = Policy.Cache(memoryCacheProvider, TimeSpan.FromSeconds(5));
Random rand = new Random();
while (true)
{
int i = rand.Next(5);
Console.WriteLine("产生" + i);
var context = new Context("doublecache" + i);
int result = policy.Execute(ctx =>
{
Console.WriteLine("Execute计算" + i);
return(i * 2);
}, context);
Console.WriteLine("计算结果：" + result);
Thread.Sleep(500);
}
}
/// <summary>
/// 缓存
/// </summary>
private static void Caching()
{
//Install-Package Microsoft.Extensions.Caching.Memory
Microsoft.Extensions.Caching.Memory.IMemoryCache memoryCache = new Microsoft.Extensions.Caching.Memory.MemoryCache(new Microsoft.Extensions.Caching.Memory.MemoryCacheOptions());
//Install-Package Polly.Caching.MemoryCache
Polly.Caching.MemoryCache.MemoryCacheProvider memoryCacheProvider = new Polly.Caching.MemoryCache.MemoryCacheProvider(memoryCache);
CachePolicy policy = Policy.Cache(memoryCacheProvider, TimeSpan.FromSeconds(5));
Random rand = new Random();
while (true)
{
int i = rand.Next(5);
Console.WriteLine("产生" + i);
var context = new Context("doublecache" + i);
int result = policy.Execute(ctx =>
{
Console.WriteLine("Execute计算" + i);
return(i * 2);
}, context);
Console.WriteLine("计算结果：" + result);
Thread.Sleep(500);
}
}
public void Should_call_onError_delegate_if_cache_put_errors()
{
Exception ex = new Exception();
ISyncCacheProvider stubCacheProvider = new StubErroringCacheProvider(getException: null, putException: ex);
Exception exceptionFromCacheProvider = null;
const string valueToReturn = "valueToReturn";
const string executionKey = "SomeExecutionKey";
Action <Context, string, Exception> onError = (ctx, key, exc) => { exceptionFromCacheProvider = exc; };
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.MaxValue, onError);
stubCacheProvider.Get(executionKey).Should().BeNull();
cache.Execute(() => { return(valueToReturn); }, new Context(executionKey)).Should().Be(valueToReturn);
// error should be captured by onError delegate.
exceptionFromCacheProvider.Should().Be(ex);
// failed to put it in the cache
stubCacheProvider.Get(executionKey).Should().BeNull();
}
/// <inheritdoc />
public IReceivedMessageInternal GetNextMessage(List <string> routes, TimeSpan timeout)
{
if (_complete)
{
return(null);
}
if (routes != null && routes.Count > 0)
{
throw new NotSupportedException("The in-memory transport does not support routes");
}
using (CancellationTokenSource linkedCts =
CancellationTokenSource.CreateLinkedTokenSource(_cancelToken.CancelWorkToken,
_cancelToken.StopWorkToken))
{
Guid id = Guid.Empty;
try
{
if (!Queues[_connectionInformation].TryTake(out id, Convert.ToInt32(timeout.TotalMilliseconds), linkedCts.Token))
{
return(null);
}
}
catch (OperationCanceledException)
{
return(null);
}
if (!QueueData[_connectionInformation].TryRemove(id, out var item))
{
return(null);
}
var hasError = false;
try
{
var newMessage = _messageFactory.Create(item.Body, item.Headers);
if (!string.IsNullOrEmpty(item.JobName))
{
var key = GenerateKey(item.JobName);
//add it to the cache
JobLastEventCache.Execute(context => item.JobEventTime, new Context(key));
}
Interlocked.Increment(ref DequeueCounts[_connectionInformation].ProcessedCount);
return(_receivedMessageFactory.Create(newMessage,
new MessageQueueId(id),
new MessageCorrelationId(item.CorrelationId)));
}
catch (Exception error)
{
hasError = true;
//at this point, the record has been de-queued, but it can't be processed.
throw new PoisonMessageException(
"An error has occurred trying to re-assemble a message", error,
new MessageQueueId(id), null, null, null);
}
finally
{
if (!hasError)
{
QueueWorking[_connectionInformation].TryAdd(item.Id, item);
}
}
}
}
