Policy<TResult>
Transient fault handling policies that can be applied to delegates returning results of type TResult.
using Polly.Wrap;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Threading;
namespace Polly
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1
})]
public abstract class Policy<[System.Runtime.CompilerServices.Nullable(2)] TResult> : PolicyBase<TResult>, ISyncPolicy<TResult>, IsPolicy
{
public Policy<TResult> WithPolicyKey(string policyKey)
{
if (policyKeyInternal != null)
throw PolicyBase.PolicyKeyMustBeImmutableException("policyKey");
policyKeyInternal = policyKey;
return this;
}
ISyncPolicy<TResult> ISyncPolicy<TResult>.WithPolicyKey(string policyKey)
{
if (policyKeyInternal != null)
throw PolicyBase.PolicyKeyMustBeImmutableException("policyKey");
policyKeyInternal = policyKey;
return this;
}
public static PolicyBuilder<TResult> Handle<TException>() where TException : Exception
{
return new PolicyBuilder<TResult>((ExceptionPredicate)delegate(Exception exception) {
if (!(exception is TException))
return null;
return exception;
});
}
public static PolicyBuilder<TResult> Handle<TException>(Func<TException, bool> exceptionPredicate) where TException : Exception
{
return new PolicyBuilder<TResult>((ExceptionPredicate)delegate(Exception exception) {
TException val = exception as TException;
if (val == null || !exceptionPredicate(val))
return null;
return exception;
});
}
public static PolicyBuilder<TResult> HandleInner<TException>() where TException : Exception
{
return new PolicyBuilder<TResult>(PolicyBuilder.HandleInner((Exception ex) => ex is TException));
}
public static PolicyBuilder<TResult> HandleInner<TException>(Func<TException, bool> exceptionPredicate) where TException : Exception
{
return new PolicyBuilder<TResult>(PolicyBuilder.HandleInner(delegate(Exception ex) {
TException val = ex as TException;
if (val != null)
return exceptionPredicate(val);
return false;
}));
}
public static PolicyBuilder<TResult> HandleResult(Func<TResult, bool> resultPredicate)
{
return new PolicyBuilder<TResult>(resultPredicate);
}
public static PolicyBuilder<TResult> HandleResult(TResult result)
{
return HandleResult(delegate(TResult r) {
if (object.Equals(r, default(TResult)) || !r.Equals(result)) {
if (object.Equals(r, default(TResult)))
return object.Equals(result, default(TResult));
return false;
}
return true;
});
}
protected abstract TResult Implementation(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken);
[System.Runtime.CompilerServices.NullableContext(1)]
private protected Policy(ExceptionPredicates exceptionPredicates, ResultPredicates<TResult> resultPredicates)
: base(exceptionPredicates, resultPredicates)
{
}
protected Policy([System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})] PolicyBuilder<TResult> policyBuilder = null)
: base(policyBuilder)
{
}
[DebuggerStepThrough]
public TResult Execute(Func<TResult> action)
{
return Execute((Context _, CancellationToken _) => action(), new Context(), DefaultCancellationToken);
}
[DebuggerStepThrough]
public TResult Execute(Func<Context, TResult> action, IDictionary<string, object> contextData)
{
return Execute((Context ctx, CancellationToken _) => action(ctx), new Context(contextData), DefaultCancellationToken);
}
[DebuggerStepThrough]
public TResult Execute(Func<Context, TResult> action, Context context)
{
return Execute((Context ctx, CancellationToken _) => action(ctx), context, DefaultCancellationToken);
}
[DebuggerStepThrough]
public TResult Execute(Func<CancellationToken, TResult> action, CancellationToken cancellationToken)
{
return Execute((Context _, CancellationToken ct) => action(ct), new Context(), cancellationToken);
}
[DebuggerStepThrough]
public TResult Execute(Func<Context, CancellationToken, TResult> action, IDictionary<string, object> contextData, CancellationToken cancellationToken)
{
return Execute(action, new Context(contextData), cancellationToken);
}
[DebuggerStepThrough]
public TResult Execute(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken)
{
if (context != null) {
SetPolicyContext(context, out string priorPolicyWrapKey, out string priorPolicyKey);
try {
return Implementation(action, context, cancellationToken);
} finally {
PolicyBase.RestorePolicyContext(context, priorPolicyWrapKey, priorPolicyKey);
}
}
throw new ArgumentNullException("context");
}
[DebuggerStepThrough]
public PolicyResult<TResult> ExecuteAndCapture(Func<TResult> action)
{
return ExecuteAndCapture((Context _, CancellationToken _) => action(), new Context(), DefaultCancellationToken);
}
[DebuggerStepThrough]
public PolicyResult<TResult> ExecuteAndCapture(Func<Context, TResult> action, IDictionary<string, object> contextData)
{
return ExecuteAndCapture((Context ctx, CancellationToken _) => action(ctx), new Context(contextData), DefaultCancellationToken);
}
[DebuggerStepThrough]
public PolicyResult<TResult> ExecuteAndCapture(Func<Context, TResult> action, Context context)
{
return ExecuteAndCapture((Context ctx, CancellationToken _) => action(ctx), context, DefaultCancellationToken);
}
[DebuggerStepThrough]
public PolicyResult<TResult> ExecuteAndCapture(Func<CancellationToken, TResult> action, CancellationToken cancellationToken)
{
return ExecuteAndCapture((Context _, CancellationToken ct) => action(ct), new Context(), cancellationToken);
}
[DebuggerStepThrough]
public PolicyResult<TResult> ExecuteAndCapture(Func<Context, CancellationToken, TResult> action, IDictionary<string, object> contextData, CancellationToken cancellationToken)
{
return ExecuteAndCapture(action, new Context(contextData), cancellationToken);
}
[DebuggerStepThrough]
public PolicyResult<TResult> ExecuteAndCapture(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken)
{
if (context != null)
try {
TResult val = Execute(action, context, cancellationToken);
if (!base.ResultPredicates.AnyMatch(val))
return PolicyResult<TResult>.Successful(val, context);
return PolicyResult<TResult>.Failure(val, context);
} catch (Exception exception) {
return PolicyResult<TResult>.Failure(exception, PolicyBase.GetExceptionType(base.ExceptionPredicates, exception), context);
}
throw new ArgumentNullException("context");
}
public PolicyWrap<TResult> Wrap(ISyncPolicy innerPolicy)
{
if (innerPolicy == null)
throw new ArgumentNullException("innerPolicy");
return new PolicyWrap<TResult>(this, innerPolicy);
}
public PolicyWrap<TResult> Wrap(ISyncPolicy<TResult> innerPolicy)
{
if (innerPolicy == null)
throw new ArgumentNullException("innerPolicy");
return new PolicyWrap<TResult>(this, innerPolicy);
}
}
}