Replaced one line methods with expression-bodied members.

Removed useless empty lines.
App-vNext · Jan 27, 2019 · 72543fc · 72543fc
1 parent 263973c
commit 72543fc
Show file tree

Hide file tree

Showing 3 changed files with 5 additions and 15 deletions.
diff --git a/src/Polly.Shared/Fallback/AsyncFallbackPolicy.cs b/src/Polly.Shared/Fallback/AsyncFallbackPolicy.cs
@@ -49,9 +49,8 @@ protected override Task ImplementationAsync(
         /// <inheritdoc/>
         protected override Task<TResult> ImplementationAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken,
             bool continueOnCapturedContext)
-        {
+            => 
             throw new InvalidOperationException($"You have executed the generic .Execute<{nameof(TResult)}> method on a non-generic {nameof(FallbackPolicy)}.  A non-generic {nameof(FallbackPolicy)} only defines a fallback action which returns void; it can never return a substitute {nameof(TResult)} value.  To use {nameof(FallbackPolicy)} to provide fallback {nameof(TResult)} values you must define a generic fallback policy {nameof(FallbackPolicy)}<{nameof(TResult)}>.  For example, define the policy as Policy<{nameof(TResult)}>.Handle<Whatever>.Fallback<{nameof(TResult)}>(/* some {nameof(TResult)} value or Func<..., {nameof(TResult)}> */);");
-        }
     }
 
     /// <summary>
@@ -78,8 +77,7 @@ Func<DelegateResult<TResult>, Context, CancellationToken, Task<TResult>> fallbac
         [DebuggerStepThrough]
         protected override Task<TResult> ImplementationAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken,
             bool continueOnCapturedContext)
-        {
-            return AsyncFallbackEngine.ImplementationAsync(
+            => AsyncFallbackEngine.ImplementationAsync(
                 action,
                 context,
                 cancellationToken,
@@ -88,6 +86,5 @@ protected override Task<TResult> ImplementationAsync(Func<Context, CancellationT
                 _onFallbackAsync,
                 _fallbackAction,
                 continueOnCapturedContext);
-        }
     }
 }
diff --git a/src/Polly.Shared/Fallback/FallbackPolicy.cs b/src/Polly.Shared/Fallback/FallbackPolicy.cs
@@ -26,22 +26,18 @@ internal FallbackPolicy(
         /// <inheritdoc/>
         [DebuggerStepThrough]
         protected override void Implementation(Action<Context, CancellationToken> action, Context context, CancellationToken cancellationToken)
-        {
-            FallbackEngine.Implementation<EmptyStruct>(
+            => FallbackEngine.Implementation<EmptyStruct>(
                 (ctx, token) => { action(ctx, token); return EmptyStruct.Instance; }, 
                 context, 
                 cancellationToken, 
                 ExceptionPredicates,
                 ResultPredicates<EmptyStruct>.None,
                 (outcome, ctx) => _onFallback(outcome.Exception, ctx),
                 (outcome, ctx, ct) => { _fallbackAction(outcome.Exception, ctx, ct); return EmptyStruct.Instance; });
-        }
 
         /// <inheritdoc/>
         protected override TResult Implementation<TResult>(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken)
-        {
-            throw new InvalidOperationException($"You have executed the generic .Execute<{nameof(TResult)}> method on a non-generic {nameof(FallbackPolicy)}.  A non-generic {nameof(FallbackPolicy)} only defines a fallback action which returns void; it can never return a substitute {nameof(TResult)} value.  To use {nameof(FallbackPolicy)} to provide fallback {nameof(TResult)} values you must define a generic fallback policy {nameof(FallbackPolicy)}<{nameof(TResult)}>.  For example, define the policy as Policy<{nameof(TResult)}>.Handle<Whatever>.Fallback<{nameof(TResult)}>(/* some {nameof(TResult)} value or Func<..., {nameof(TResult)}> */);");
-        }
+            => throw new InvalidOperationException($"You have executed the generic .Execute<{nameof(TResult)}> method on a non-generic {nameof(FallbackPolicy)}.  A non-generic {nameof(FallbackPolicy)} only defines a fallback action which returns void; it can never return a substitute {nameof(TResult)} value.  To use {nameof(FallbackPolicy)} to provide fallback {nameof(TResult)} values you must define a generic fallback policy {nameof(FallbackPolicy)}<{nameof(TResult)}>.  For example, define the policy as Policy<{nameof(TResult)}>.Handle<Whatever>.Fallback<{nameof(TResult)}>(/* some {nameof(TResult)} value or Func<..., {nameof(TResult)}> */);");
     }
 
     /// <summary>
@@ -66,15 +62,13 @@ Func<DelegateResult<TResult>, Context, CancellationToken, TResult> fallbackActio
         /// <inheritdoc/>
         [DebuggerStepThrough]
         protected override TResult Implementation(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken)
-        {
-            return FallbackEngine.Implementation(
+            => FallbackEngine.Implementation(
                 action,
                 context,
                 cancellationToken,
                 ExceptionPredicates,
                 ResultPredicates,
                 _onFallback,
                 _fallbackAction);
-        }
     }
 }
diff --git a/src/Polly.Shared/Fallback/IFallbackPolicy.cs b/src/Polly.Shared/Fallback/IFallbackPolicy.cs
@@ -13,6 +13,5 @@ public interface IFallbackPolicy : IsPolicy
     /// </summary>
     public interface IFallbackPolicy<TResult> : IFallbackPolicy
     {
-
     }
 }