Skip to content

Commit ab957f2

Browse files
SimonCroppSimonCropp
authored
consistent expression bodied member usage (#1021)
1 parent 3d05c77 commit ab957f2

File tree

167 files changed

+1089
-1423
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

167 files changed

+1089
-1423
lines changed

‎src/Polly.Benchmarks/Bulkhead.cs‎

Lines changed: 11 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -7,38 +7,26 @@ public class Bulkhead
77
private static readonly AsyncPolicy AsyncPolicy = Policy.BulkheadAsync(2);
88

99
[Benchmark]
10-
public void Bulkhead_Synchronous()
11-
{
10+
public void Bulkhead_Synchronous() =>
1211
SyncPolicy.Execute(() => Workloads.Action());
13-
}
1412

1513
[Benchmark]
16-
public Task Bulkhead_Asynchronous()
17-
{
18-
return AsyncPolicy.ExecuteAsync(() => Workloads.ActionAsync());
19-
}
14+
public Task Bulkhead_Asynchronous() =>
15+
AsyncPolicy.ExecuteAsync(() => Workloads.ActionAsync());
2016

2117
[Benchmark]
22-
public Task Bulkhead_Asynchronous_With_CancellationToken()
23-
{
24-
return AsyncPolicy.ExecuteAsync(token => Workloads.ActionAsync(token), CancellationToken.None);
25-
}
18+
public Task Bulkhead_Asynchronous_With_CancellationToken() =>
19+
AsyncPolicy.ExecuteAsync(token => Workloads.ActionAsync(token), CancellationToken.None);
2620

2721
[Benchmark]
28-
public int Bulkhead_Synchronous_With_Result()
29-
{
30-
return SyncPolicy.Execute(() => Workloads.Func<int>());
31-
}
22+
public int Bulkhead_Synchronous_With_Result() =>
23+
SyncPolicy.Execute(() => Workloads.Func<int>());
3224

3325
[Benchmark]
34-
public Task<int> Bulkhead_Asynchronous_With_Result()
35-
{
36-
return AsyncPolicy.ExecuteAsync(() => Workloads.FuncAsync<int>());
37-
}
26+
public Task<int> Bulkhead_Asynchronous_With_Result() =>
27+
AsyncPolicy.ExecuteAsync(() => Workloads.FuncAsync<int>());
3828

3929
[Benchmark]
40-
public Task<int> Bulkhead_Asynchronous_With_Result_With_CancellationToken()
41-
{
42-
return AsyncPolicy.ExecuteAsync(token => Workloads.FuncAsync<int>(token), CancellationToken.None);
43-
}
30+
public Task<int> Bulkhead_Asynchronous_With_Result_With_CancellationToken() =>
31+
AsyncPolicy.ExecuteAsync(token => Workloads.FuncAsync<int>(token), CancellationToken.None);
4432
}

‎src/Polly.Benchmarks/Cache.cs‎

Lines changed: 15 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -25,41 +25,33 @@ public Task GlobalSetup()
2525
}
2626

2727
[Benchmark]
28-
public object Cache_Synchronous_Hit()
29-
{
30-
return SyncPolicyHit.Execute(_ => GetObject(), HitContext);
31-
}
28+
public object Cache_Synchronous_Hit() =>
29+
SyncPolicyHit.Execute(_ => GetObject(), HitContext);
3230

3331
[Benchmark]
34-
public Task<object> Cache_Asynchronous_Hit()
35-
{
36-
return AsyncPolicyHit.ExecuteAsync((_, token) => GetObjectAsync(token), HitContext, CancellationToken.None);
37-
}
32+
public Task<object> Cache_Asynchronous_Hit() =>
33+
AsyncPolicyHit.ExecuteAsync((_, token) => GetObjectAsync(token), HitContext, CancellationToken.None);
3834

3935
[Benchmark]
40-
public object Cache_Synchronous_Miss()
41-
{
42-
return SyncPolicyMiss.Execute(_ => GetObject(), MissContext);
43-
}
36+
public object Cache_Synchronous_Miss() =>
37+
SyncPolicyMiss.Execute(_ => GetObject(), MissContext);
4438

4539
[Benchmark]
46-
public Task<object> Cache_Asynchronous_Miss()
47-
{
48-
return AsyncPolicyMiss.ExecuteAsync((_, token) => GetObjectAsync(token), MissContext, CancellationToken.None);
49-
}
40+
public Task<object> Cache_Asynchronous_Miss() =>
41+
AsyncPolicyMiss.ExecuteAsync((_, token) => GetObjectAsync(token), MissContext, CancellationToken.None);
5042

51-
private static object GetObject() => new object();
43+
private static object GetObject() =>
44+
new object();
5245

53-
private static Task<object> GetObjectAsync(CancellationToken cancellationToken) => Task.FromResult(new object());
46+
private static Task<object> GetObjectAsync(CancellationToken cancellationToken) =>
47+
Task.FromResult(new object());
5448

5549
private sealed class MemoryCacheProvider : ISyncCacheProvider, IAsyncCacheProvider
5650
{
5751
private readonly IMemoryCache _cache;
5852

59-
public MemoryCacheProvider(IMemoryCache memoryCache)
60-
{
53+
public MemoryCacheProvider(IMemoryCache memoryCache) =>
6154
_cache = memoryCache;
62-
}
6355

6456
public (bool, object?) TryGet(string key)
6557
{
@@ -91,10 +83,8 @@ public void Put(string key, object value, Ttl ttl)
9183
_cache.Set(key, value, options);
9284
}
9385

94-
public Task<(bool, object?)> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext)
95-
{
96-
return Task.FromResult(TryGet(key));
97-
}
86+
public Task<(bool, object?)> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext) =>
87+
Task.FromResult(TryGet(key));
9888

9989
public Task PutAsync(string key, object value, Ttl ttl, CancellationToken cancellationToken, bool continueOnCapturedContext)
10090
{

‎src/Polly.Benchmarks/CircuitBreaker.cs‎

Lines changed: 7 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -7,26 +7,18 @@ public class CircuitBreaker
77
private static readonly AsyncPolicy AsyncPolicy = Policy.Handle<InvalidOperationException>().CircuitBreakerAsync(2, TimeSpan.FromMinutes(1));
88

99
[Benchmark]
10-
public void CircuitBreaker_Synchronous_Succeeds()
11-
{
10+
public void CircuitBreaker_Synchronous_Succeeds() =>
1211
SyncPolicy.Execute(() => Workloads.Action());
13-
}
1412

1513
[Benchmark]
16-
public Task CircuitBreaker_Asynchronous_Succeeds()
17-
{
18-
return AsyncPolicy.ExecuteAsync(token => Workloads.ActionAsync(token), CancellationToken.None);
19-
}
14+
public Task CircuitBreaker_Asynchronous_Succeeds() =>
15+
AsyncPolicy.ExecuteAsync(token => Workloads.ActionAsync(token), CancellationToken.None);
2016

2117
[Benchmark]
22-
public int CircuitBreaker_Synchronous_With_Result_Succeeds()
23-
{
24-
return SyncPolicy.Execute(() => Workloads.Func<int>());
25-
}
18+
public int CircuitBreaker_Synchronous_With_Result_Succeeds() =>
19+
SyncPolicy.Execute(() => Workloads.Func<int>());
2620

2721
[Benchmark]
28-
public Task<int> CircuitBreaker_Asynchronous_With_Result_Succeeds()
29-
{
30-
return AsyncPolicy.ExecuteAsync(token => Workloads.FuncAsync<int>(token), CancellationToken.None);
31-
}
22+
public Task<int> CircuitBreaker_Asynchronous_With_Result_Succeeds() =>
23+
AsyncPolicy.ExecuteAsync(token => Workloads.FuncAsync<int>(token), CancellationToken.None);
3224
}

‎src/Polly.Benchmarks/Fallback.cs‎

Lines changed: 8 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -7,26 +7,18 @@ public class Fallback
77
private static readonly AsyncPolicy<int> AsyncPolicy = Policy<int>.Handle<InvalidOperationException>().FallbackAsync(0);
88

99
[Benchmark]
10-
public int Fallback_Synchronous_Succeeds()
11-
{
12-
return SyncPolicy.Execute(() => Workloads.Func<int>());
13-
}
10+
public int Fallback_Synchronous_Succeeds() =>
11+
SyncPolicy.Execute(() => Workloads.Func<int>());
1412

1513
[Benchmark]
16-
public Task<int> Fallback_Asynchronous_Succeeds()
17-
{
18-
return AsyncPolicy.ExecuteAsync(() => Workloads.FuncAsync<int>());
19-
}
14+
public Task<int> Fallback_Asynchronous_Succeeds() =>
15+
AsyncPolicy.ExecuteAsync(() => Workloads.FuncAsync<int>());
2016

2117
[Benchmark]
22-
public int Fallback_Synchronous_Throws()
23-
{
24-
return SyncPolicy.Execute(() => Workloads.FuncThrows<int, InvalidOperationException>());
25-
}
18+
public int Fallback_Synchronous_Throws() =>
19+
SyncPolicy.Execute(() => Workloads.FuncThrows<int, InvalidOperationException>());
2620

2721
[Benchmark]
28-
public Task<int> Fallback_Asynchronous_Throws()
29-
{
30-
return AsyncPolicy.ExecuteAsync(() => Workloads.FuncThrowsAsync<int, InvalidOperationException>());
31-
}
22+
public Task<int> Fallback_Asynchronous_Throws() =>
23+
AsyncPolicy.ExecuteAsync(() => Workloads.FuncThrowsAsync<int, InvalidOperationException>());
3224
}

‎src/Polly.Benchmarks/NoOp.cs‎

Lines changed: 7 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -7,26 +7,18 @@ public class NoOp
77
private static readonly AsyncPolicy AsyncPolicy = Policy.NoOpAsync();
88

99
[Benchmark]
10-
public void NoOp_Synchronous()
11-
{
10+
public void NoOp_Synchronous() =>
1211
SyncPolicy.Execute(() => Workloads.Action());
13-
}
1412

1513
[Benchmark]
16-
public Task NoOp_Asynchronous()
17-
{
18-
return AsyncPolicy.ExecuteAsync(token => Workloads.ActionAsync(token), CancellationToken.None);
19-
}
14+
public Task NoOp_Asynchronous() =>
15+
AsyncPolicy.ExecuteAsync(token => Workloads.ActionAsync(token), CancellationToken.None);
2016

2117
[Benchmark]
22-
public int NoOp_Synchronous_With_Result()
23-
{
24-
return SyncPolicy.Execute(() => Workloads.Func<int>());
25-
}
18+
public int NoOp_Synchronous_With_Result() =>
19+
SyncPolicy.Execute(() => Workloads.Func<int>());
2620

2721
[Benchmark]
28-
public Task<int> NoOp_Asynchronous_With_Result()
29-
{
30-
return AsyncPolicy.ExecuteAsync(token => Workloads.FuncAsync<int>(token), CancellationToken.None);
31-
}
22+
public Task<int> NoOp_Asynchronous_With_Result() =>
23+
AsyncPolicy.ExecuteAsync(token => Workloads.FuncAsync<int>(token), CancellationToken.None);
3224
}

‎src/Polly.Benchmarks/PolicyWrap.cs‎

Lines changed: 7 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -16,26 +16,18 @@ public class PolicyWrap
1616
Policy.BulkheadAsync(2));
1717

1818
[Benchmark]
19-
public void PolicyWrap_Synchronous()
20-
{
19+
public void PolicyWrap_Synchronous() =>
2120
SyncPolicy.Execute(() => Workloads.Action());
22-
}
2321

2422
[Benchmark]
25-
public Task PolicyWrap_Asynchronous()
26-
{
27-
return AsyncPolicy.ExecuteAsync(token => Workloads.ActionAsync(token), CancellationToken.None);
28-
}
23+
public Task PolicyWrap_Asynchronous() =>
24+
AsyncPolicy.ExecuteAsync(token => Workloads.ActionAsync(token), CancellationToken.None);
2925

3026
[Benchmark]
31-
public int PolicyWrap_Synchronous_With_Result()
32-
{
33-
return SyncPolicy.Execute(() => Workloads.Func<int>());
34-
}
27+
public int PolicyWrap_Synchronous_With_Result() =>
28+
SyncPolicy.Execute(() => Workloads.Func<int>());
3529

3630
[Benchmark]
37-
public Task<int> PolicyWrap_Asynchronous_With_Result()
38-
{
39-
return AsyncPolicy.ExecuteAsync(token => Workloads.FuncAsync<int>(token), CancellationToken.None);
40-
}
31+
public Task<int> PolicyWrap_Asynchronous_With_Result() =>
32+
AsyncPolicy.ExecuteAsync(token => Workloads.FuncAsync<int>(token), CancellationToken.None);
4133
}

‎src/Polly.Benchmarks/RateLimit.cs‎

Lines changed: 7 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -7,26 +7,18 @@ public class RateLimit
77
private static readonly AsyncPolicy AsyncPolicy = Policy.RateLimitAsync(20, TimeSpan.FromSeconds(1), int.MaxValue);
88

99
[Benchmark]
10-
public void RateLimit_Synchronous_Succeeds()
11-
{
10+
public void RateLimit_Synchronous_Succeeds() =>
1211
SyncPolicy.Execute(() => Workloads.Action());
13-
}
1412

1513
[Benchmark]
16-
public Task RateLimit_Asynchronous_Succeeds()
17-
{
18-
return AsyncPolicy.ExecuteAsync(() => Workloads.ActionAsync());
19-
}
14+
public Task RateLimit_Asynchronous_Succeeds() =>
15+
AsyncPolicy.ExecuteAsync(() => Workloads.ActionAsync());
2016

2117
[Benchmark]
22-
public int RateLimit_Synchronous_With_Result_Succeeds()
23-
{
24-
return SyncPolicy.Execute(() => Workloads.Func<int>());
25-
}
18+
public int RateLimit_Synchronous_With_Result_Succeeds() =>
19+
SyncPolicy.Execute(() => Workloads.Func<int>());
2620

2721
[Benchmark]
28-
public Task<int> RateLimit_Asynchronous_With_Result_Succeeds()
29-
{
30-
return AsyncPolicy.ExecuteAsync(() => Workloads.FuncAsync<int>());
31-
}
22+
public Task<int> RateLimit_Asynchronous_With_Result_Succeeds() =>
23+
AsyncPolicy.ExecuteAsync(() => Workloads.FuncAsync<int>());
3224
}

‎src/Polly.Benchmarks/Retry.cs‎

Lines changed: 11 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -7,40 +7,28 @@ public class Retry
77
private static readonly AsyncPolicy AsyncPolicy = Policy.Handle<InvalidOperationException>().RetryAsync();
88

99
[Benchmark]
10-
public void Retry_Synchronous_Succeeds()
11-
{
10+
public void Retry_Synchronous_Succeeds() =>
1211
SyncPolicy.Execute(() => Workloads.Action());
13-
}
1412

1513
[Benchmark]
16-
public Task Retry_Asynchronous_Succeeds()
17-
{
18-
return AsyncPolicy.ExecuteAsync(() => Workloads.ActionAsync());
19-
}
14+
public Task Retry_Asynchronous_Succeeds() =>
15+
AsyncPolicy.ExecuteAsync(() => Workloads.ActionAsync());
2016

2117
[Benchmark]
22-
public Task Retry_Asynchronous_Succeeds_With_CancellationToken()
23-
{
24-
return AsyncPolicy.ExecuteAsync(token => Workloads.ActionAsync(token), CancellationToken.None);
25-
}
18+
public Task Retry_Asynchronous_Succeeds_With_CancellationToken() =>
19+
AsyncPolicy.ExecuteAsync(token => Workloads.ActionAsync(token), CancellationToken.None);
2620

2721
[Benchmark]
28-
public int Retry_Synchronous_With_Result_Succeeds()
29-
{
30-
return SyncPolicy.Execute(() => Workloads.Func<int>());
31-
}
22+
public int Retry_Synchronous_With_Result_Succeeds() =>
23+
SyncPolicy.Execute(() => Workloads.Func<int>());
3224

3325
[Benchmark]
34-
public Task<int> Retry_Asynchronous_With_Result_Succeeds()
35-
{
36-
return AsyncPolicy.ExecuteAsync(() => Workloads.FuncAsync<int>());
37-
}
26+
public Task<int> Retry_Asynchronous_With_Result_Succeeds() =>
27+
AsyncPolicy.ExecuteAsync(() => Workloads.FuncAsync<int>());
3828

3929
[Benchmark]
40-
public Task<int> Retry_Asynchronous_With_Result_Succeeds_With_CancellationToken()
41-
{
42-
return AsyncPolicy.ExecuteAsync(token => Workloads.FuncAsync<int>(token), CancellationToken.None);
43-
}
30+
public Task<int> Retry_Asynchronous_With_Result_Succeeds_With_CancellationToken() =>
31+
AsyncPolicy.ExecuteAsync(token => Workloads.FuncAsync<int>(token), CancellationToken.None);
4432

4533
[Benchmark]
4634
public void Retry_Synchronous_Throws_Then_Succeeds()

‎src/Polly.Benchmarks/Timeout.cs‎

Lines changed: 13 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -7,44 +7,30 @@ public class Timeout
77
private static readonly AsyncPolicy AsyncPolicy = Policy.TimeoutAsync(TimeSpan.FromMilliseconds(1));
88

99
[Benchmark]
10-
public void Timeout_Synchronous_Succeeds()
11-
{
10+
public void Timeout_Synchronous_Succeeds() =>
1211
SyncPolicy.Execute(() => Workloads.Action());
13-
}
1412

1513
[Benchmark]
16-
public Task Timeout_Asynchronous_Succeeds()
17-
{
18-
return AsyncPolicy.ExecuteAsync(() => Workloads.ActionAsync());
19-
}
14+
public Task Timeout_Asynchronous_Succeeds() =>
15+
AsyncPolicy.ExecuteAsync(() => Workloads.ActionAsync());
2016

2117
[Benchmark]
22-
public Task Timeout_Asynchronous_Succeeds_With_CancellationToken()
23-
{
24-
return AsyncPolicy.ExecuteAsync(token => Workloads.ActionAsync(token), CancellationToken.None);
25-
}
18+
public Task Timeout_Asynchronous_Succeeds_With_CancellationToken() =>
19+
AsyncPolicy.ExecuteAsync(token => Workloads.ActionAsync(token), CancellationToken.None);
2620

2721
[Benchmark]
28-
public int Timeout_Synchronous_With_Result_Succeeds()
29-
{
30-
return SyncPolicy.Execute(() => Workloads.Func<int>());
31-
}
22+
public int Timeout_Synchronous_With_Result_Succeeds() =>
23+
SyncPolicy.Execute(() => Workloads.Func<int>());
3224

3325
[Benchmark]
34-
public Task<int> Timeout_Asynchronous_With_Result_Succeeds()
35-
{
36-
return AsyncPolicy.ExecuteAsync(() => Workloads.FuncAsync<int>());
37-
}
26+
public Task<int> Timeout_Asynchronous_With_Result_Succeeds() =>
27+
AsyncPolicy.ExecuteAsync(() => Workloads.FuncAsync<int>());
3828

3929
[Benchmark]
40-
public Task<int> Timeout_Asynchronous_With_Result_Succeeds_With_CancellationToken()
41-
{
42-
return AsyncPolicy.ExecuteAsync(token => Workloads.FuncAsync<int>(token), CancellationToken.None);
43-
}
30+
public Task<int> Timeout_Asynchronous_With_Result_Succeeds_With_CancellationToken() =>
31+
AsyncPolicy.ExecuteAsync(token => Workloads.FuncAsync<int>(token), CancellationToken.None);
4432

4533
[Benchmark]
46-
public Task Timeout_Asynchronous_Times_Out_Optimistic()
47-
{
48-
return AsyncPolicy.ExecuteAsync(token => Workloads.ActionInfiniteAsync(token), CancellationToken.None);
49-
}
34+
public Task Timeout_Asynchronous_Times_Out_Optimistic() =>
35+
AsyncPolicy.ExecuteAsync(token => Workloads.ActionInfiniteAsync(token), CancellationToken.None);
5036
}

0 commit comments

Comments
 (0)