public void Should_throw_when_retrieving_using_Indexer_when_key_is_null() { string key = null; IsPolicy policy = null; _registry.Invoking(r => policy = r[key]) .Should().Throw <ArgumentNullException>(); }
public void Should_throw_while_retrieving_when_key_does_not_exist_using_Indexer() { string key = Guid.NewGuid().ToString(); IsPolicy outPolicy = null; _registry.Invoking(r => outPolicy = r[key]) .Should().Throw <KeyNotFoundException>(); }
public IProxyConfig <T> For(Expression <Action <T> > methodExpression, IsPolicy policy) { var methodCall = methodExpression.Body as MethodCallExpression; if (methodCall != null) { _policyMapping.Add(mi => mi == methodCall.Method ? policy : null); } return(this); }
private void QueueTasks(int parallelism, bool useCollapser, bool sameKey, IKeyStrategy overrideKeyStrategy = null) { IsPolicy policy = GetPolicy(useCollapser, overrideKeyStrategy); for (int i = 0; i < parallelism; i++) { string key = sameKey ? SharedKey : i.ToString(); Context context = new Context(key); ConcurrentTasks[i] = ExecuteThroughPolicy(policy, context, i, true); } }
protected override Task ExecuteThroughPolicy(IsPolicy policy, Context context, int j, bool gated) { return(Task.Factory.StartNew(() => { if (gated) { QueueTaskAtHoldingGate(); } ((ISyncPolicy)policy).Execute(ctx => UnderlyingExpensiveWork(j), context); }, TaskCreationOptions.LongRunning)); }
protected override Task ExecuteThroughPolicy(IsPolicy policy, Context context, int j, bool gated) { return(Task.Factory.StartNew(async() => { if (gated) { QueueTaskAtHoldingGate(); } return await((IAsyncPolicy <ResultClass>)policy).ExecuteAsync(ctx => { UnderlyingExpensiveWork(j); return Task.FromResult(ResultFactory()); }, context); }, TaskCreationOptions.LongRunning).Unwrap()); }
protected abstract Task ExecuteThroughPolicy(IsPolicy policy, Context context, int j, bool gated);
public IProxyConfig <T> Default(IsPolicy policy) { _defaultPolicy = policy; return(this); }
public IProxyConfig <T> When(Func <MethodInfo, bool> predicate, IsPolicy policy) { _policyMapping.Add(mi => predicate.Invoke(mi) ? policy : null); return(this); }
public IProxyConfig <T> For(string methodName, IsPolicy policy) { _policyMapping.Add(mi => mi.Name == methodName ? policy : null); return(this); }
internal PolicyWrap(Action <Action <Context, CancellationToken>, Context, CancellationToken> policyAction, Policy outer, ISyncPolicy inner) : base(policyAction, outer.ExceptionPredicates) { _outer = outer; _inner = inner; }
public void Use(Policy policy) { _policy = policy; }
public void Use(AsyncPolicy policy) { _policy = policy; }