Skip to content

Commit 33215f2

Browse files
james-fairbairnjames-fairbairn
authored
Configure await false everywhere(#247)
refactor: configure await false everywhere
1 parent d25f5ec commit 33215f2

14 files changed

+102
-103
lines changed

‎src/Enyim.Caching/DistributedCache.cs

+11-11
Original file line numberDiff line numberDiff line change
@@ -24,11 +24,11 @@ byte[] IDistributedCache.Get(string key)
2424

2525
async Task<byte[]> IDistributedCache.GetAsync(string key, CancellationToken token = default)
2626
{
27-
var value = await GetValueAsync<byte[]>(key);
27+
var value = await GetValueAsync<byte[]>(key).ConfigureAwait(false);
2828

2929
if (value != null)
3030
{
31-
await RefreshAsync(key);
31+
await RefreshAsync(key).ConfigureAwait(false);
3232
}
3333

3434
return value;
@@ -58,17 +58,17 @@ void IDistributedCache.Set(string key, byte[] value, DistributedCacheEntryOption
5858
{
5959
if (!HasSlidingExpiration(options))
6060
{
61-
await PerformStoreAsync(StoreMode.Set, key, value, 0);
61+
await PerformStoreAsync(StoreMode.Set, key, value, 0).ConfigureAwait(false);
6262
return;
6363
}
6464

6565
var expiration = GetExpiration(options);
66-
await PerformStoreAsync(StoreMode.Set, key, value, expiration);
66+
await PerformStoreAsync(StoreMode.Set, key, value, expiration).ConfigureAwait(false);
6767

6868
if (options.SlidingExpiration.HasValue)
6969
{
7070
var sldExp = options.SlidingExpiration.Value;
71-
await AddAsync(GetSlidingExpirationKey(key), sldExp.ToString(), sldExp);
71+
await AddAsync(GetSlidingExpirationKey(key), sldExp.ToString(), sldExp).ConfigureAwait(false);
7272
}
7373
}
7474

@@ -108,15 +108,15 @@ public void Refresh(string key)
108108
public async Task RefreshAsync(string key, CancellationToken token = default)
109109
{
110110
var sldExpKey = GetSlidingExpirationKey(key);
111-
var sldExpStr = await GetValueAsync<string>(sldExpKey);
111+
var sldExpStr = await GetValueAsync<string>(sldExpKey).ConfigureAwait(false);
112112
if (!string.IsNullOrEmpty(sldExpStr)
113113
&& TimeSpan.TryParse(sldExpStr, out var sldExp))
114114
{
115-
var value = (await GetAsync(key)).Value;
115+
var value = (await GetAsync(key).ConfigureAwait(false)).Value;
116116
if (value != null)
117117
{
118-
await ReplaceAsync(key, value, sldExp);
119-
await ReplaceAsync(sldExpKey, sldExpStr, sldExp);
118+
await ReplaceAsync(key, value, sldExp).ConfigureAwait(false);
119+
await ReplaceAsync(sldExpKey, sldExpStr, sldExp).ConfigureAwait(false);
120120
}
121121
}
122122
}
@@ -129,8 +129,8 @@ void IDistributedCache.Remove(string key)
129129

130130
async Task IDistributedCache.RemoveAsync(string key, CancellationToken token = default)
131131
{
132-
await RemoveAsync(key);
133-
await RemoveAsync(GetSlidingExpirationKey(key));
132+
await RemoveAsync(key).ConfigureAwait(false);
133+
await RemoveAsync(GetSlidingExpirationKey(key)).ConfigureAwait(false);
134134
}
135135

136136
private uint GetExpiration(DistributedCacheEntryOptions options)

‎src/Enyim.Caching/Memcached/MemcachedNode.cs

+22-22
Original file line numberDiff line numberDiff line change
@@ -214,7 +214,7 @@ public async Task<IPooledSocketResult> AcquireAsync()
214214
var result = new PooledSocketResult();
215215
if (!_isInitialized)
216216
{
217-
if (!await poolInitSemaphore.WaitAsync(_initPoolTimeout))
217+
if (!await poolInitSemaphore.WaitAsync(_initPoolTimeout).ConfigureAwait(false))
218218
{
219219
return result.Fail("Timeout to poolInitSemaphore.Wait", _logger) as PooledSocketResult;
220220
}
@@ -224,7 +224,7 @@ public async Task<IPooledSocketResult> AcquireAsync()
224224
if (!_isInitialized)
225225
{
226226
var startTime = DateTime.Now;
227-
await _internalPoolImpl.InitPoolAsync();
227+
await _internalPoolImpl.InitPoolAsync().ConfigureAwait(false);
228228
_isInitialized = true;
229229

230230
if (_logger.IsEnabled(LogLevel.Information))
@@ -242,7 +242,7 @@ public async Task<IPooledSocketResult> AcquireAsync()
242242

243243
try
244244
{
245-
return await _internalPoolImpl.AcquireAsync();
245+
return await _internalPoolImpl.AcquireAsync().ConfigureAwait(false);
246246
}
247247
catch (Exception e)
248248
{
@@ -397,7 +397,7 @@ internal async Task InitPoolAsync()
397397
{
398398
try
399399
{
400-
_freeItems.Push(await CreateSocketAsync());
400+
_freeItems.Push(await CreateSocketAsync().ConfigureAwait(false));
401401
}
402402
catch (Exception ex)
403403
{
@@ -423,7 +423,7 @@ internal async Task InitPoolAsync()
423423

424424
private async Task<PooledSocket> CreateSocketAsync()
425425
{
426-
var ps = await _ownerNode.CreateSocketAsync();
426+
var ps = await _ownerNode.CreateSocketAsync().ConfigureAwait(false);
427427
ps.CleanupCallback = ReleaseSocket;
428428

429429
return ps;
@@ -586,7 +586,7 @@ public async Task<IPooledSocketResult> AcquireAsync()
586586

587587
PooledSocket socket = null;
588588

589-
if (!await _semaphore.WaitAsync(_queueTimeout))
589+
if (!await _semaphore.WaitAsync(_queueTimeout).ConfigureAwait(false))
590590
{
591591
message = "Pool is full, timeouting. " + _endPoint;
592592
if (_isDebugEnabled) _logger.LogDebug(message);
@@ -616,9 +616,9 @@ public async Task<IPooledSocketResult> AcquireAsync()
616616
{
617617
var resetTask = socket.ResetAsync();
618618

619-
if (await Task.WhenAny(resetTask, Task.Delay(_receiveTimeout)) == resetTask)
619+
if (await Task.WhenAny(resetTask, Task.Delay(_receiveTimeout)).ConfigureAwait(false) == resetTask)
620620
{
621-
await resetTask;
621+
await resetTask.ConfigureAwait(false);
622622
}
623623
else
624624
{
@@ -662,7 +662,7 @@ public async Task<IPooledSocketResult> AcquireAsync()
662662
{
663663
// okay, create the new item
664664
var startTime = DateTime.Now;
665-
socket = await CreateSocketAsync();
665+
socket = await CreateSocketAsync().ConfigureAwait(false);
666666

667667
if (_logger.IsEnabled(LogLevel.Information))
668668
{
@@ -927,13 +927,13 @@ protected internal virtual async Task<PooledSocket> CreateSocketAsync()
927927
{
928928
try
929929
{
930-
return await CreateSocketInternalAsync();
930+
return await CreateSocketInternalAsync().ConfigureAwait(false);
931931
}
932932
catch
933933
{
934934
try
935935
{
936-
return await CreateSocketInternalAsync();
936+
return await CreateSocketInternalAsync().ConfigureAwait(false);
937937
}
938938
catch (Exception ex)
939939
{
@@ -951,7 +951,7 @@ private async Task<PooledSocket> CreateSocketInternalAsync()
951951
#else
952952
_useSslStream, _useIPv6);
953953
#endif
954-
await ps.ConnectAsync();
954+
await ps.ConnectAsync().ConfigureAwait(false);
955955
return ps;
956956
}
957957

@@ -1018,7 +1018,7 @@ protected virtual async Task<IPooledSocketResult> ExecuteOperationAsync(IOperati
10181018
_logger.LogDebug($"ExecuteOperationAsync({op})");
10191019
}
10201020

1021-
var result = await AcquireAsync();
1021+
var result = await AcquireAsync().ConfigureAwait(false);
10221022
if (result.Success && result.HasValue)
10231023
{
10241024
try
@@ -1034,13 +1034,13 @@ protected virtual async Task<IPooledSocketResult> ExecuteOperationAsync(IOperati
10341034
}
10351035

10361036
var writeSocketTask = pooledSocket.WriteAsync(b);
1037-
if (await Task.WhenAny(writeSocketTask, Task.Delay(_config.ConnectionTimeout)) != writeSocketTask)
1037+
if (await Task.WhenAny(writeSocketTask, Task.Delay(_config.ConnectionTimeout)).ConfigureAwait(false) != writeSocketTask)
10381038
{
10391039
result.Fail("Timeout to pooledSocket.WriteAsync");
10401040
return result;
10411041
}
10421042

1043-
await writeSocketTask;
1043+
await writeSocketTask.ConfigureAwait(false);
10441044

10451045
//if Get, call BinaryResponse
10461046
if (_logger.IsEnabled(LogLevel.Debug))
@@ -1049,13 +1049,13 @@ protected virtual async Task<IPooledSocketResult> ExecuteOperationAsync(IOperati
10491049
}
10501050

10511051
var readResponseTask = op.ReadResponseAsync(pooledSocket);
1052-
if (await Task.WhenAny(readResponseTask, Task.Delay(_config.ConnectionTimeout)) != readResponseTask)
1052+
if (await Task.WhenAny(readResponseTask, Task.Delay(_config.ConnectionTimeout)).ConfigureAwait(false) != readResponseTask)
10531053
{
10541054
result.Fail($"Timeout to ReadResponseAsync(pooledSocket) for {op}");
10551055
return result;
10561056
}
10571057

1058-
var readResult = await readResponseTask;
1058+
var readResult = await readResponseTask.ConfigureAwait(false);
10591059
if (readResult.Success)
10601060
{
10611061
result.Pass();
@@ -1103,22 +1103,22 @@ protected virtual async Task<IPooledSocketResult> ExecuteOperationAsync(IOperati
11031103

11041104
protected virtual async Task<bool> ExecuteOperationAsync(IOperation op, Action<bool> next)
11051105
{
1106-
var socket = (await AcquireAsync()).Value;
1106+
var socket = (await AcquireAsync().ConfigureAwait(false)).Value;
11071107
if (socket == null) return false;
11081108

11091109
//key(string) to buffer(btye[])
11101110
var b = op.GetBuffer();
11111111

11121112
try
11131113
{
1114-
await socket.WriteAsync(b);
1114+
await socket.WriteAsync(b).ConfigureAwait(false);
11151115

11161116
var rrs = await op.ReadResponseAsync(socket, readSuccess =>
11171117
{
11181118
((IDisposable)socket).Dispose();
11191119

11201120
next(readSuccess);
1121-
});
1121+
}).ConfigureAwait(false);
11221122

11231123
return rrs;
11241124
}
@@ -1164,12 +1164,12 @@ IOperationResult IMemcachedNode.Execute(IOperation op)
11641164

11651165
async Task<IOperationResult> IMemcachedNode.ExecuteAsync(IOperation op)
11661166
{
1167-
return await ExecuteOperationAsync(op);
1167+
return await ExecuteOperationAsync(op).ConfigureAwait(false);
11681168
}
11691169

11701170
async Task<bool> IMemcachedNode.ExecuteAsync(IOperation op, Action<bool> next)
11711171
{
1172-
return await ExecuteOperationAsync(op, next);
1172+
return await ExecuteOperationAsync(op, next).ConfigureAwait(false);
11731173
}
11741174

11751175
event Action<IMemcachedNode> IMemcachedNode.Failed

‎src/Enyim.Caching/Memcached/PooledSocket.cs

+10-12
Original file line numberDiff line numberDiff line change
@@ -156,9 +156,9 @@ public async Task<bool> ConnectAsync()
156156
{
157157
var connTask = _socket.ConnectAsync(_endpoint);
158158

159-
if (await Task.WhenAny(connTask, Task.Delay(_connectionTimeout)) == connTask)
159+
if (await Task.WhenAny(connTask, Task.Delay(_connectionTimeout)).ConfigureAwait(false) == connTask)
160160
{
161-
await connTask;
161+
await connTask.ConfigureAwait(false);
162162
}
163163
else
164164
{
@@ -174,7 +174,7 @@ public async Task<bool> ConnectAsync()
174174
{
175175
var ep = GetIPEndPoint(_endpoint);
176176
if (_isSocketDisposed) return false;
177-
await _socket.ConnectAsync(ep.Address, ep.Port);
177+
await _socket.ConnectAsync(ep.Address, ep.Port).ConfigureAwait(false);
178178
}
179179

180180
if (_socket != null)
@@ -200,7 +200,7 @@ await _sslStream.AuthenticateAsClientAsync(
200200
#else
201201
((DnsEndPoint)_endpoint).Host
202202
#endif
203-
);
203+
).ConfigureAwait(false);
204204
}
205205
else
206206
{
@@ -253,8 +253,6 @@ public void Reset()
253253

254254
public async Task ResetAsync()
255255
{
256-
// await _inputStream.FlushAsync();
257-
258256
int available = _socket.Available;
259257

260258
if (available > 0)
@@ -268,7 +266,7 @@ public async Task ResetAsync()
268266

269267
byte[] data = new byte[available];
270268

271-
await ReadAsync(data, 0, available);
269+
await ReadAsync(data, 0, available).ConfigureAwait(false);
272270
}
273271

274272
if (_logger.IsEnabled(LogLevel.Debug))
@@ -428,8 +426,8 @@ public async Task ReadAsync(byte[] buffer, int offset, int count)
428426
try
429427
{
430428
int currentRead = (_useSslStream
431-
? await _sslStream.ReadAsync(buffer, offset, shouldRead)
432-
: await _inputStream.ReadAsync(buffer, offset, shouldRead));
429+
? await _sslStream.ReadAsync(buffer, offset, shouldRead).ConfigureAwait(false)
430+
: await _inputStream.ReadAsync(buffer, offset, shouldRead).ConfigureAwait(false));
433431
if (currentRead == count)
434432
break;
435433
if (currentRead < 1)
@@ -578,14 +576,14 @@ public async Task WriteAsync(IList<ArraySegment<byte>> buffers)
578576
{
579577
foreach (var buf in buffers)
580578
{
581-
await _sslStream.WriteAsync(buf.Array, 0, buf.Count);
579+
await _sslStream.WriteAsync(buf.Array, 0, buf.Count).ConfigureAwait(false);
582580
}
583581

584-
await _sslStream.FlushAsync();
582+
await _sslStream.FlushAsync().ConfigureAwait(false);
585583
}
586584
else
587585
{
588-
var bytesTransferred = await _socket.SendAsync(buffers, SocketFlags.None);
586+
var bytesTransferred = await _socket.SendAsync(buffers, SocketFlags.None).ConfigureAwait(false);
589587
if (bytesTransferred <= 0)
590588
{
591589
_isAlive = false;

‎src/Enyim.Caching/Memcached/Protocol/Binary/BinaryNode.cs

+5-5
Original file line numberDiff line numberDiff line change
@@ -58,9 +58,9 @@ protected internal override PooledSocket CreateSocket()
5858

5959
protected internal override async Task<PooledSocket> CreateSocketAsync()
6060
{
61-
var retval = await base.CreateSocketAsync();
61+
var retval = await base.CreateSocketAsync().ConfigureAwait(false);
6262

63-
if (_authenticationProvider != null && !(await AuthAsync(retval)))
63+
if (_authenticationProvider != null && !await AuthAsync(retval).ConfigureAwait(false))
6464
{
6565
_logger.LogError("Authentication failed: " + EndPoint);
6666

@@ -105,15 +105,15 @@ private async Task<bool> AuthAsync(PooledSocket socket)
105105
{
106106
SaslStep currentStep = new SaslStart(_authenticationProvider);
107107

108-
await socket.WriteAsync(currentStep.GetBuffer());
108+
await socket.WriteAsync(currentStep.GetBuffer()).ConfigureAwait(false);
109109

110-
while (!(await currentStep.ReadResponseAsync(socket)).Success)
110+
while (!(await currentStep.ReadResponseAsync(socket).ConfigureAwait(false)).Success)
111111
{
112112
// challenge-response authentication
113113
if (currentStep.StatusCode == 0x21)
114114
{
115115
currentStep = new SaslContinue(_authenticationProvider, currentStep.Data);
116-
await socket.WriteAsync(currentStep.GetBuffer());
116+
await socket.WriteAsync(currentStep.GetBuffer()).ConfigureAwait(false);
117117
}
118118
else
119119
{

‎src/Enyim.Caching/Memcached/Protocol/Binary/BinaryResponse.cs

+2-2
Original file line numberDiff line numberDiff line change
@@ -80,7 +80,7 @@ public async Task<bool> ReadAsync(PooledSocket socket)
8080
if (!socket.IsAlive) return false;
8181

8282
var header = new byte[HeaderLength];
83-
await socket.ReadAsync(header, 0, header.Length);
83+
await socket.ReadAsync(header, 0, header.Length).ConfigureAwait(false);
8484

8585
int dataLength, extraLength;
8686

@@ -89,7 +89,7 @@ public async Task<bool> ReadAsync(PooledSocket socket)
8989
if (dataLength > 0)
9090
{
9191
var data = new byte[dataLength];
92-
await socket.ReadAsync(data, 0, dataLength);
92+
await socket.ReadAsync(data, 0, dataLength).ConfigureAwait(false);
9393

9494
Extra = new ArraySegment<byte>(data, 0, extraLength);
9595
Data = new ArraySegment<byte>(data, extraLength, data.Length - extraLength);

‎src/Enyim.Caching/Memcached/Protocol/Binary/BinarySingleItemOperation.cs

+1-1
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ protected internal override IOperationResult ReadResponse(PooledSocket socket)
4747
protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
4848
{
4949
var response = new BinaryResponse();
50-
var retval = await response.ReadAsync(socket);
50+
var retval = await response.ReadAsync(socket).ConfigureAwait(false);
5151

5252
Cas = response.CAS;
5353
StatusCode = response.StatusCode;

‎src/Enyim.Caching/Memcached/Protocol/Binary/FlushOperation.cs

+1-1
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,7 @@ protected internal override IOperationResult ReadResponse(PooledSocket socket)
3636
protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
3737
{
3838
var response = new BinaryResponse();
39-
var retval = await response.ReadAsync(socket);
39+
var retval = await response.ReadAsync(socket).ConfigureAwait(false);
4040

4141
StatusCode = StatusCode;
4242
var result = new BinaryOperationResult()

0 commit comments

Comments
 (0)