Revert "expression body members"

This reverts commit a6f49c7.

src/Polly.Benchmarks/Cache.cs

@@ -96,8 +96,10 @@ public void Put(string key, object value, Ttl ttl)
             _cache.Set(key, value, options);
         }
 
-        public Task<(bool, object)> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext) =>
-            Task.FromResult(TryGet(key));
+        public Task<(bool, object)> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext)
+        {
+            return Task.FromResult(TryGet(key));
+        }
 
         public Task PutAsync(string key, object value, Ttl ttl, CancellationToken cancellationToken, bool continueOnCapturedContext)
         {

src/Polly.Benchmarks/Workloads.cs

@@ -37,10 +37,14 @@ internal static async Task ActionInfiniteAsync(CancellationToken cancellationTok
     internal static Task<T> FuncAsync<T>(CancellationToken cancellationToken) => Task.FromResult<T>(default);
 
     internal static TResult FuncThrows<TResult, TException>()
-        where TException : Exception, new() =>
+        where TException : Exception, new()
+    {
         throw new TException();
+    }
 
     internal static Task<TResult> FuncThrowsAsync<TResult, TException>()
-        where TException : Exception, new() =>
+        where TException : Exception, new()
+    {
         throw new TException();
+    }
 }

src/Polly.Specs/Bulkhead/BulkheadAsyncSpecs.cs

@@ -85,11 +85,15 @@ public void Should_call_onBulkheadRejected_with_passed_context()
 
     #region Bulkhead behaviour
 
-    protected override IBulkheadPolicy GetBulkhead(int maxParallelization, int maxQueuingActions) =>
-        Policy.BulkheadAsync(maxParallelization, maxQueuingActions);
+    protected override IBulkheadPolicy GetBulkhead(int maxParallelization, int maxQueuingActions)
+    {
+        return Policy.BulkheadAsync(maxParallelization, maxQueuingActions);
+    }
 
-    protected override Task ExecuteOnBulkhead(IBulkheadPolicy bulkhead, TraceableAction action) =>
-        action.ExecuteOnBulkheadAsync((AsyncBulkheadPolicy)bulkhead);
+    protected override Task ExecuteOnBulkhead(IBulkheadPolicy bulkhead, TraceableAction action)
+    {
+        return action.ExecuteOnBulkheadAsync((AsyncBulkheadPolicy)bulkhead);
+    }
 
     #endregion
 

src/Polly.Specs/Bulkhead/BulkheadSpecs.cs

@@ -82,11 +82,15 @@ public void Should_call_onBulkheadRejected_with_passed_context()
 
     #region Bulkhead behaviour
 
-    protected override IBulkheadPolicy GetBulkhead(int maxParallelization, int maxQueuingActions) =>
-        Policy.Bulkhead(maxParallelization, maxQueuingActions);
+    protected override IBulkheadPolicy GetBulkhead(int maxParallelization, int maxQueuingActions)
+    {
+        return Policy.Bulkhead(maxParallelization, maxQueuingActions);
+    }
 
-    protected override Task ExecuteOnBulkhead(IBulkheadPolicy bulkhead, TraceableAction action) =>
-        action.ExecuteOnBulkhead((BulkheadPolicy) bulkhead);
+    protected override Task ExecuteOnBulkhead(IBulkheadPolicy bulkhead, TraceableAction action)
+    {
+        return action.ExecuteOnBulkhead((BulkheadPolicy) bulkhead);
+    }
 
     #endregion
 

src/Polly.Specs/Bulkhead/BulkheadTResultAsyncSpecs.cs

@@ -85,6 +85,7 @@ public void Should_call_onBulkheadRejected_with_passed_context()
             contextPassedToOnRejected.Should().NotBeNull();
             contextPassedToOnRejected.OperationKey.Should().Be(operationKey);
             contextPassedToOnRejected.Should().BeSameAs(contextPassedToExecute);
+
         }
     }
 
@@ -93,11 +94,15 @@ public void Should_call_onBulkheadRejected_with_passed_context()
 
     #region Bulkhead behaviour
 
-    protected override IBulkheadPolicy GetBulkhead(int maxParallelization, int maxQueuingActions) =>
-        Policy.BulkheadAsync<ResultPrimitive>(maxParallelization, maxQueuingActions);
+    protected override IBulkheadPolicy GetBulkhead(int maxParallelization, int maxQueuingActions)
+    {
+        return Policy.BulkheadAsync<ResultPrimitive>(maxParallelization, maxQueuingActions);
+    }
 
-    protected override Task ExecuteOnBulkhead(IBulkheadPolicy bulkhead, TraceableAction action) =>
-        action.ExecuteOnBulkheadAsync<ResultPrimitive>((AsyncBulkheadPolicy<ResultPrimitive>)bulkhead);
+    protected override Task ExecuteOnBulkhead(IBulkheadPolicy bulkhead, TraceableAction action)
+    {
+        return action.ExecuteOnBulkheadAsync<ResultPrimitive>((AsyncBulkheadPolicy<ResultPrimitive>)bulkhead);
+    }
 
     #endregion
 

src/Polly.Specs/Bulkhead/BulkheadTResultSpecs.cs

@@ -92,11 +92,15 @@ public void Should_call_onBulkheadRejected_with_passed_context()
 
     #region Bulkhead behaviour
 
-    protected override IBulkheadPolicy GetBulkhead(int maxParallelization, int maxQueuingActions) =>
-        Policy.Bulkhead<ResultPrimitive>(maxParallelization, maxQueuingActions);
+    protected override IBulkheadPolicy GetBulkhead(int maxParallelization, int maxQueuingActions)
+    {
+        return Policy.Bulkhead<ResultPrimitive>(maxParallelization, maxQueuingActions);
+    }
 
-    protected override Task ExecuteOnBulkhead(IBulkheadPolicy bulkhead, TraceableAction action) =>
-        action.ExecuteOnBulkhead<ResultPrimitive>((BulkheadPolicy<ResultPrimitive>) bulkhead);
+    protected override Task ExecuteOnBulkhead(IBulkheadPolicy bulkhead, TraceableAction action)
+    {
+        return action.ExecuteOnBulkhead<ResultPrimitive>((BulkheadPolicy<ResultPrimitive>) bulkhead);
+    }
 
     #endregion
 }

src/Polly.Specs/Helpers/Bulkhead/TraceableAction.cs

@@ -23,7 +23,7 @@ public class TraceableAction : IDisposable
 
     public TraceableActionStatus Status
     {
-        get => _status;
+        get { return _status; }
         set
         {
             _status = value;

src/Polly.Specs/Helpers/Caching/StubCacheKeyStrategy.cs

@@ -10,9 +10,13 @@ internal class StubCacheKeyStrategy : ICacheKeyStrategy
 {
     private readonly Func<Context, string> strategy;
 
-    public StubCacheKeyStrategy(Func<Context, string> strategy) =>
+    public StubCacheKeyStrategy(Func<Context, string> strategy)
+    {
         this.strategy = strategy;
+    }
 
-    public string GetCacheKey(Context context) =>
-        strategy(context);
+    public string GetCacheKey(Context context)
+    {
+        return strategy(context);
+    }
 }

src/Polly.Specs/Helpers/Caching/StubCacheProvider.cs

@@ -42,14 +42,18 @@ public CacheItem(object value, Ttl ttl)
         return (false, null);
     }
 
-    public void Put(string key, object value, Ttl ttl) =>
-        cachedValues[key] = new(value, ttl);
+    public void Put(string key, object value, Ttl ttl)
+    {
+        cachedValues[key] = new CacheItem(value, ttl);
+    }
 
     #region Naive async-over-sync implementation
 
     // Intentionally naive async-over-sync implementation.  Its purpose is to be the simplest thing to support tests of the CachePolicyAsync and CacheEngineAsync, not to be a usable implementation of IAsyncCacheProvider.  
-    public Task<(bool, object)> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext) =>
-        Task.FromResult(TryGet(key));
+    public Task<(bool, object)> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext)
+    {
+        return Task.FromResult(TryGet(key));
+    }
 
     public Task PutAsync(string key, object value, Ttl ttl, CancellationToken cancellationToken, bool continueOnCapturedContext)
     {

src/Polly.Specs/Helpers/Caching/StubErroringCacheProvider.cs

@@ -34,8 +34,10 @@ public void Put(string key, object value, Ttl ttl)
     #region Naive async-over-sync implementation
 
     // Intentionally naive async-over-sync implementation.  Its purpose is to be the simplest thing to support tests of the CachePolicyAsync and CacheEngineAsync, not to be a usable implementation of IAsyncCacheProvider.  
-    public Task<(bool, object)> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext) =>
-        Task.FromResult(TryGet(key));
+    public Task<(bool, object)> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext)
+    {
+        return Task.FromResult(TryGet(key));
+    }
 
     public Task PutAsync(string key, object value, Ttl ttl, CancellationToken cancellationToken, bool continueOnCapturedContext)
     {

src/Polly.Specs/Helpers/ContextualPolicyExtensionsAsync.cs

@@ -29,6 +29,9 @@ public static class ContextualPolicyExtensionsAsync
         }, contextData, cancellationToken);
     }
 
-    public static Task RaiseExceptionAsync<TException>(this AsyncPolicy policy, IDictionary<string, object> contextData, Action<TException, int> configureException = null, CancellationToken cancellationToken = default) where TException : Exception, new() =>
-        policy.RaiseExceptionAsync(1, contextData, configureException, cancellationToken);
+    public static Task RaiseExceptionAsync<TException>(this AsyncPolicy policy, IDictionary<string, object> contextData, Action<TException, int> configureException = null, CancellationToken cancellationToken = default) where TException : Exception, new()
+    {
+        return policy.RaiseExceptionAsync(1, contextData, configureException, cancellationToken);
+    }
+
 }

src/Polly.Specs/Helpers/ContextualPolicyTResultExtensions.cs

@@ -8,8 +8,10 @@ public static class ContextualPolicyTResultExtensions
 {
     public static TResult RaiseResultSequence<TResult>(this Policy<TResult> policy,
         IDictionary<string, object> contextData,
-        params TResult[] resultsToRaise) =>
-        policy.RaiseResultSequence(contextData, resultsToRaise.ToList());
+        params TResult[] resultsToRaise)
+    {
+        return policy.RaiseResultSequence(contextData, resultsToRaise.ToList());
+    }
 
     public static TResult RaiseResultSequence<TResult>(this Policy<TResult> policy,
         IDictionary<string, object> contextData,
@@ -30,8 +32,10 @@ public static TResult RaiseResultSequence<TResult>(this Policy<TResult> policy,
 
     public static PolicyResult<TResult> RaiseResultSequenceOnExecuteAndCapture<TResult>(this Policy<TResult> policy,
         IDictionary<string, object> contextData,
-        params TResult[] resultsToRaise) =>
-        policy.RaiseResultSequenceOnExecuteAndCapture(contextData, resultsToRaise.ToList());
+        params TResult[] resultsToRaise)
+    {
+        return policy.RaiseResultSequenceOnExecuteAndCapture(contextData, resultsToRaise.ToList());
+    }
 
     public static PolicyResult<TResult> RaiseResultSequenceOnExecuteAndCapture<TResult>(this Policy<TResult> policy,
         IDictionary<string, object> contextData,

src/Polly.Specs/Helpers/ContextualPolicyTResultExtensionsAsync.cs

@@ -11,8 +11,10 @@ public static class ContextualPolicyTResultExtensionsAsync
 
     public static Task<TResult> RaiseResultSequenceAsync<TResult>(this AsyncPolicy<TResult> policy,
         IDictionary<string, object> contextData,
-        params TResult[] resultsToRaise) =>
-        policy.RaiseResultSequenceAsync(contextData, CancellationToken.None, resultsToRaise.ToList());
+        params TResult[] resultsToRaise)
+    {
+        return policy.RaiseResultSequenceAsync(contextData, CancellationToken.None, resultsToRaise.ToList());
+    }
 
     public static Task<TResult> RaiseResultSequenceAsync<TResult>(this AsyncPolicy<TResult> policy, IDictionary<string, object> contextData, CancellationToken cancellationToken, IEnumerable<TResult> resultsToRaise)
     {
@@ -29,8 +31,10 @@ public static Task<TResult> RaiseResultSequenceAsync<TResult>(this AsyncPolicy<T
         }, contextData, cancellationToken);
     }
 
-    public static Task<PolicyResult<TResult>> RaiseResultSequenceOnExecuteAndCaptureAsync<TResult>(this AsyncPolicy<TResult> policy, IDictionary<string, object> contextData, params TResult[] resultsToRaise) =>
-        policy.RaiseResultSequenceOnExecuteAndCaptureAsync(contextData, resultsToRaise.ToList());
+    public static Task<PolicyResult<TResult>> RaiseResultSequenceOnExecuteAndCaptureAsync<TResult>(this AsyncPolicy<TResult> policy, IDictionary<string, object> contextData, params TResult[] resultsToRaise)
+    {
+        return policy.RaiseResultSequenceOnExecuteAndCaptureAsync(contextData, resultsToRaise.ToList());
+    }
 
     public static Task<PolicyResult<TResult>> RaiseResultSequenceOnExecuteAndCaptureAsync<TResult>(this AsyncPolicy<TResult> policy, IDictionary<string, object> contextData, IEnumerable<TResult> resultsToRaise)
     {

src/Polly.Specs/Helpers/Custom/AddBehaviourIfHandle/AddBehaviourIfHandlePolicy.cs

@@ -41,13 +41,15 @@ internal AddBehaviourIfHandlePolicy(
         _behaviourIfHandle = behaviourIfHandle ?? throw new ArgumentNullException(nameof(behaviourIfHandle));
     }
 
-    protected override TResult Implementation(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken) =>
-        AddBehaviourIfHandleEngine.Implementation(
+    protected override TResult Implementation(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken)
+    {
+        return AddBehaviourIfHandleEngine.Implementation(
             ExceptionPredicates,
             ResultPredicates,
             _behaviourIfHandle,
             action,
             context,
             cancellationToken
         );
+    }
 }

src/Polly.Specs/Helpers/Custom/AddBehaviourIfHandle/AsyncAddBehaviourIfHandlePolicy.cs

@@ -37,12 +37,16 @@ internal class AsyncAddBehaviourIfHandlePolicy<TResult> : AsyncPolicy<TResult>
     internal AsyncAddBehaviourIfHandlePolicy(
         Func<DelegateResult<TResult>, Task> behaviourIfHandle,
         PolicyBuilder<TResult> policyBuilder)
-        : base(policyBuilder) =>
+        : base(policyBuilder)
+    {
         _behaviourIfHandle = behaviourIfHandle ?? throw new ArgumentNullException(nameof(behaviourIfHandle));
 
+    }
+
     protected override Task<TResult> ImplementationAsync(Func<Context, System.Threading.CancellationToken, Task<TResult>> action, Context context, System.Threading.CancellationToken cancellationToken,
-        bool continueOnCapturedContext) =>
-        AsyncAddBehaviourIfHandleEngine.ImplementationAsync(
+        bool continueOnCapturedContext)
+    {
+        return AsyncAddBehaviourIfHandleEngine.ImplementationAsync(
             ExceptionPredicates,
             ResultPredicates,
             _behaviourIfHandle,
@@ -51,4 +55,5 @@ protected override Task<TResult> ImplementationAsync(Func<Context, System.Thread
             cancellationToken,
             continueOnCapturedContext
         );
+    }
 }

src/Polly.Specs/Helpers/Custom/PreExecute/AsyncPreExecutePolicy.cs

@@ -8,28 +8,40 @@ internal class AsyncPreExecutePolicy : AsyncPolicy
 {
     private Func<Task> _preExecute;
 
-    public static AsyncPreExecutePolicy CreateAsync(Func<Task> preExecute) =>
-        new(preExecute);
+    public static AsyncPreExecutePolicy CreateAsync(Func<Task> preExecute)
+    {
+        return new AsyncPreExecutePolicy(preExecute);
+    }
 
-    internal AsyncPreExecutePolicy(Func<Task> preExecute) =>
+    internal AsyncPreExecutePolicy(Func<Task> preExecute)
+    {
         _preExecute = preExecute ?? throw new ArgumentNullException(nameof(preExecute));
+    }
 
     protected override Task<TResult> ImplementationAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken,
-        bool continueOnCapturedContext) =>
-        AsyncPreExecuteEngine.ImplementationAsync(_preExecute, action, context, cancellationToken, continueOnCapturedContext);
+        bool continueOnCapturedContext)
+    {
+        return AsyncPreExecuteEngine.ImplementationAsync(_preExecute, action, context, cancellationToken, continueOnCapturedContext);
+    }
 }
 
 internal class AsyncPreExecutePolicy<TResult> : AsyncPolicy<TResult>
 {
     private Func<Task> _preExecute;
 
-    public static AsyncPreExecutePolicy<TResult> CreateAsync(Func<Task> preExecute) =>
-        new AsyncPreExecutePolicy<TResult>(preExecute);
+    public static AsyncPreExecutePolicy<TResult> CreateAsync(Func<Task> preExecute)
+    {
+        return new AsyncPreExecutePolicy<TResult>(preExecute);
+    }
 
-    internal AsyncPreExecutePolicy(Func<Task> preExecute) =>
+    internal AsyncPreExecutePolicy(Func<Task> preExecute)
+    {
         _preExecute = preExecute ?? throw new ArgumentNullException(nameof(preExecute));
+    }
 
     protected override Task<TResult> ImplementationAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken,
-        bool continueOnCapturedContext) =>
-        AsyncPreExecuteEngine.ImplementationAsync(_preExecute, action, context, cancellationToken, continueOnCapturedContext);
+        bool continueOnCapturedContext)
+    {
+        return AsyncPreExecuteEngine.ImplementationAsync(_preExecute, action, context, cancellationToken, continueOnCapturedContext);
+    }
 }

src/Polly.Specs/Helpers/Custom/PreExecute/PreExecutePolicy.cs

@@ -7,26 +7,38 @@ internal class PreExecutePolicy : Policy
 {
     private Action _preExecute;
 
-    public static PreExecutePolicy Create(Action preExecute) =>
-        new(preExecute);
+    public static PreExecutePolicy Create(Action preExecute)
+    {
+        return new PreExecutePolicy(preExecute);
+    }
 
-    internal PreExecutePolicy(Action preExecute) =>
+    internal PreExecutePolicy(Action preExecute)
+    {
         _preExecute = preExecute ?? throw new ArgumentNullException(nameof(preExecute));
+    }
 
-    protected override TResult Implementation<TResult>(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken) =>
-        PreExecuteEngine.Implementation(_preExecute, action, context, cancellationToken);
+    protected override TResult Implementation<TResult>(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken)
+    {
+        return PreExecuteEngine.Implementation(_preExecute, action, context, cancellationToken);
+    }
 }
 
 internal class PreExecutePolicy<TResult> : Policy<TResult>
 {
     private Action _preExecute;
 
-    public static PreExecutePolicy<TResult> Create(Action preExecute) =>
-        new PreExecutePolicy<TResult>(preExecute);
+    public static PreExecutePolicy<TResult> Create(Action preExecute)
+    {
+        return new PreExecutePolicy<TResult>(preExecute);
+    }
 
-    internal PreExecutePolicy(Action preExecute) =>
+    internal PreExecutePolicy(Action preExecute)
+    {
         _preExecute = preExecute ?? throw new ArgumentNullException(nameof(preExecute));
+    }
 
-    protected override TResult Implementation(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken) =>
-        PreExecuteEngine.Implementation(_preExecute, action, context, cancellationToken);
+    protected override TResult Implementation(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken)
+    {
+        return PreExecuteEngine.Implementation(_preExecute, action, context, cancellationToken);
+    }
 }