ConfigureAwait(false) all async methods

russcam · russcam · commit ebcd9d61435e · 2016-02-05T00:28:49.000+11:00
The context does not need to be captured and should slightly improve performance Closes #1801
diff --git a/src/Elasticsearch.Net/Connection/HttpConnection-CoreFx.cs b/src/Elasticsearch.Net/Connection/HttpConnection-CoreFx.cs
@@ -103,18 +103,18 @@ public virtual async Task<ElasticsearchResponse<TReturn>> RequestAsync<TReturn>(
 			try
 			{
 				var requestMessage = CreateHttpRequestMessage(requestData);
-				var response = await client.SendAsync(requestMessage, requestData.CancellationToken);
+				var response = await client.SendAsync(requestMessage, requestData.CancellationToken).ConfigureAwait(false);
 				builder.StatusCode = (int)response.StatusCode;
 
 				if (response.Content != null)
-					builder.Stream = await response.Content.ReadAsStreamAsync();
+					builder.Stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
 			}
 			catch (HttpRequestException e)
 			{
 				HandleException(builder, e);
 			}
 
-			return await builder.ToResponseAsync();
+			return await builder.ToResponseAsync().ConfigureAwait(false);
 		}
 
 		private void HandleException<TReturn>(ResponseBuilder<TReturn> builder, HttpRequestException exception)
diff --git a/src/Elasticsearch.Net/Connection/HttpConnection.cs b/src/Elasticsearch.Net/Connection/HttpConnection.cs
@@ -157,21 +157,21 @@ public virtual async Task<ElasticsearchResponse<TReturn>> RequestAsync<TReturn>(
 
 				if (data != null)
 				{
-					using (var stream = await request.GetRequestStreamAsync())
+					using (var stream = await request.GetRequestStreamAsync().ConfigureAwait(false))
 					{
 						if (requestData.HttpCompression)
 							using (var zipStream = new GZipStream(stream, CompressionMode.Compress))
-								await data.WriteAsync(zipStream, requestData.ConnectionSettings);
+								await data.WriteAsync(zipStream, requestData.ConnectionSettings).ConfigureAwait(false);
 						else
-							await data.WriteAsync(stream, requestData.ConnectionSettings);
+							await data.WriteAsync(stream, requestData.ConnectionSettings).ConfigureAwait(false);
 					}
 				}
 
 				//http://msdn.microsoft.com/en-us/library/system.net.httpwebresponse.getresponsestream.aspx
 				//Either the stream or the response object needs to be closed but not both although it won't
 				//throw any errors if both are closed atleast one of them has to be Closed.
 				//Since we expose the stream we let closing the stream determining when to close the connection
-				var response = (HttpWebResponse)(await request.GetResponseAsync());
+				var response = (HttpWebResponse)(await request.GetResponseAsync().ConfigureAwait(false));
 				builder.StatusCode = (int)response.StatusCode;
 				builder.Stream = response.GetResponseStream();
 			}
@@ -180,7 +180,7 @@ public virtual async Task<ElasticsearchResponse<TReturn>> RequestAsync<TReturn>(
 				HandleException(builder, e);
 			}
 
-			return await builder.ToResponseAsync();
+			return await builder.ToResponseAsync().ConfigureAwait(false);
 		}
 
 		private void HandleException<TReturn>(ResponseBuilder<TReturn> builder, WebException exception)
diff --git a/src/Elasticsearch.Net/Serialization/ElasticsearchDefaultSerializer.cs b/src/Elasticsearch.Net/Serialization/ElasticsearchDefaultSerializer.cs
@@ -34,7 +34,7 @@ public T Deserialize<T>(Stream stream)
 			using (var ms = new MemoryStream())
 			using (stream)
 			{
-				await stream.CopyToAsync(ms, 8096, cancellationToken);
+				await stream.CopyToAsync(ms, 8096, cancellationToken).ConfigureAwait(false);
 				var buffer = ms.ToArray();
 				if (buffer.Length <= 1)
 					return default(T);
diff --git a/src/Elasticsearch.Net/Transport/Pipeline/RequestPipeline.cs b/src/Elasticsearch.Net/Transport/Pipeline/RequestPipeline.cs
@@ -144,7 +144,7 @@ public void FirstPoolUsage(SemaphoreSlim semaphore)
 		public async Task FirstPoolUsageAsync(SemaphoreSlim semaphore)
 		{
 			if (!this.FirstPoolUsageNeedsSniffing) return;
-			var success = await semaphore.WaitAsync(this._settings.RequestTimeout, this._cancellationToken);
+			var success = await semaphore.WaitAsync(this._settings.RequestTimeout, this._cancellationToken).ConfigureAwait(false);
 			if (!success)
 				throw new PipelineException(PipelineFailure.CouldNotStartSniffOnStartup, (Exception)null);
 
@@ -153,7 +153,7 @@ public async Task FirstPoolUsageAsync(SemaphoreSlim semaphore)
 			{
 				using (this.Audit(SniffOnStartup))
 				{
-					await this.SniffAsync();
+					await this.SniffAsync().ConfigureAwait(false);
 					this._connectionPool.SniffedOnStartup = true;
 				}
 			}
@@ -178,7 +178,7 @@ public async Task SniffOnStaleClusterAsync()
 			if (!StaleClusterState) return;
 			using (this.Audit(AuditEvent.SniffOnStaleCluster))
 			{
-				await this.SniffAsync();
+				await this.SniffAsync().ConfigureAwait(false);
 				this._connectionPool.SniffedOnStartup = true;
 			}
 		}
@@ -263,7 +263,7 @@ public async Task PingAsync(Node node)
 				try
 				{
 					var pingData = CreatePingRequestData(node, audit);
-					var response = await this._connection.RequestAsync<VoidResponse>(pingData);
+					var response = await this._connection.RequestAsync<VoidResponse>(pingData).ConfigureAwait(false);
 					ThrowBadAuthPipelineExceptionWhenNeeded(response);
 					//ping should not silently accept bad but valid http responses
 					if (!response.Success) throw new PipelineException(PipelineFailure.BadResponse);
@@ -301,7 +301,7 @@ public async Task SniffOnConnectionFailureAsync()
 		{
 			if (!this.SniffsOnConnectionFailure) return;
 			using (this.Audit(SniffOnFail))
-				await this.SniffAsync();
+				await this.SniffAsync().ConfigureAwait(false);
 		}
 
 		public void Sniff()
@@ -349,7 +349,7 @@ public async Task SniffAsync()
 					try
 					{
 						var requestData = new RequestData(HttpMethod.GET, path, null, this._settings, this._memoryStreamFactory) { Node = node };
-						var response = await this._connection.RequestAsync<SniffResponse>(requestData);
+						var response = await this._connection.RequestAsync<SniffResponse>(requestData).ConfigureAwait(false);
 						ThrowBadAuthPipelineExceptionWhenNeeded(response);
 						//sniff should not silently accept bad but valid http responses
 						if (!response.Success) throw new PipelineException(PipelineFailure.BadResponse);
@@ -406,7 +406,7 @@ public async Task<ElasticsearchResponse<TReturn>> CallElasticsearchAsync<TReturn
 				ElasticsearchResponse<TReturn> response = null;
 				try
 				{
-					response = await this._connection.RequestAsync<TReturn>(requestData);
+					response = await this._connection.RequestAsync<TReturn>(requestData).ConfigureAwait(false);
 					response.AuditTrail = this.AuditTrail;
 					ThrowBadAuthPipelineExceptionWhenNeeded(response);
 					if (!response.Success) audit.Event = AuditEvent.BadResponse;
diff --git a/src/Elasticsearch.Net/Transport/Pipeline/ResponseBuilder.cs b/src/Elasticsearch.Net/Transport/Pipeline/ResponseBuilder.cs
@@ -36,7 +36,7 @@ public async Task<ElasticsearchResponse<TReturn>> ToResponseAsync()
 		{
 			var response = Initialize(this.StatusCode, this.Exception);
 			if (this.Stream != null)
-				await SetBodyAsync(response, this.Stream);
+				await SetBodyAsync(response, this.Stream).ConfigureAwait(false);
 			Finalize(response);
 			return response;
 		}
@@ -87,19 +87,19 @@ private async Task SetBodyAsync(ElasticsearchResponse<TReturn> response, Stream
 				if (NeedsToEagerReadStream())
 				{
 					var inMemoryStream = this._requestData.MemoryStreamFactory.Create();
-					await stream.CopyToAsync(inMemoryStream, BufferSize, this._requestData.CancellationToken);
+					await stream.CopyToAsync(inMemoryStream, BufferSize, this._requestData.CancellationToken).ConfigureAwait(false);
 					bytes = this.SwapStreams(ref stream, ref inMemoryStream);
 				}
 
 				if (!SetSpecialTypes(stream, response, bytes))
 				{
 					if (this._requestData.CustomConverter != null) response.Body = this._requestData.CustomConverter(response, stream) as TReturn;
-					else response.Body = await this._requestData.ConnectionSettings.Serializer.DeserializeAsync<TReturn>(stream, this._requestData.CancellationToken);
+					else response.Body = await this._requestData.ConnectionSettings.Serializer.DeserializeAsync<TReturn>(stream, this._requestData.CancellationToken).ConfigureAwait(false);
 				}
 			}
 			else if (response.HttpStatusCode != null)
 			{
-				response.ServerError = await ServerError.TryCreateAsync(stream, this._requestData.CancellationToken);
+				response.ServerError = await ServerError.TryCreateAsync(stream, this._requestData.CancellationToken).ConfigureAwait(false);
 			}
 		}
 
diff --git a/src/Elasticsearch.Net/Transport/PostData.cs b/src/Elasticsearch.Net/Transport/PostData.cs
@@ -136,7 +136,7 @@ public void Write(Stream writableStream, IConnectionConfigurationValues settings
 					foreach (var o in _enumerableOfObject)
 					{
 						settings.Serializer.Serialize(o, stream, SerializationFormatting.None);
-						await stream.WriteAsync(new byte[] { (byte)'\n' }, 0, 1, cancellationToken);
+						await stream.WriteAsync(new byte[] { (byte)'\n' }, 0, 1, cancellationToken).ConfigureAwait(false);
 					}
 					break;
 				case PostType.Serializable: 
@@ -152,7 +152,7 @@ public void Write(Stream writableStream, IConnectionConfigurationValues settings
 			if (ms != null)
 			{
 				ms.Position = 0;
-				await ms.CopyToAsync(writableStream, 8096, cancellationToken);
+				await ms.CopyToAsync(writableStream, 8096, cancellationToken).ConfigureAwait(false);
 			}
 			if (this.Type != 0)
 				this.WrittenBytes = ms?.ToArray();
diff --git a/src/Elasticsearch.Net/Transport/Transport.cs b/src/Elasticsearch.Net/Transport/Transport.cs
@@ -64,7 +64,7 @@ public ElasticsearchResponse<TReturn> Request<TReturn>(HttpMethod method, string
 					try
 					{
 						pipeline.SniffOnStaleCluster();
-						Ping(pipeline, node, seenExceptions);
+						Ping(pipeline, node);
 						response = pipeline.CallElasticsearch<TReturn>(requestData);
 						if (!response.SuccessOrKnownError)
 						{
@@ -112,7 +112,7 @@ public async Task<ElasticsearchResponse<TReturn>> RequestAsync<TReturn>(HttpMeth
 		{
 			using (var pipeline = this.PipelineProvider.Create(this.Settings, this.DateTimeProvider, this.MemoryStreamFactory, requestParameters))
 			{
-				await pipeline.FirstPoolUsageAsync(this.Settings.BootstrapLock);
+				await pipeline.FirstPoolUsageAsync(this.Settings.BootstrapLock).ConfigureAwait(false);
 
 				var requestData = new RequestData(method, path, data, this.Settings, requestParameters, this.MemoryStreamFactory);
 				ElasticsearchResponse<TReturn> response = null;
@@ -123,13 +123,13 @@ public async Task<ElasticsearchResponse<TReturn>> RequestAsync<TReturn>(HttpMeth
 					requestData.Node = node;
 					try
 					{
-						await pipeline.SniffOnStaleClusterAsync();
-						await PingAsync(pipeline, node, seenExceptions);
-						response = await pipeline.CallElasticsearchAsync<TReturn>(requestData);
+						await pipeline.SniffOnStaleClusterAsync().ConfigureAwait(false);
+						await PingAsync(pipeline, node).ConfigureAwait(false);
+						response = await pipeline.CallElasticsearchAsync<TReturn>(requestData).ConfigureAwait(false);
 						if (!response.SuccessOrKnownError)
 						{
 							pipeline.MarkDead(node);
-							await pipeline.SniffOnConnectionFailureAsync();
+							await pipeline.SniffOnConnectionFailureAsync().ConfigureAwait(false);
 						}
 					}
 					catch (PipelineException pipelineException) when (!pipelineException.Recoverable)
@@ -167,7 +167,7 @@ public async Task<ElasticsearchResponse<TReturn>> RequestAsync<TReturn>(HttpMeth
 			}
 		}
 
-		private static void Ping(IRequestPipeline pipeline, Node node, List<PipelineException> seenExceptions)
+		private static void Ping(IRequestPipeline pipeline, Node node)
 		{
 			try
 			{
@@ -180,15 +180,15 @@ private static void Ping(IRequestPipeline pipeline, Node node, List<PipelineExce
 			}
 		}
 
-		private static async Task PingAsync(IRequestPipeline pipeline, Node node, List<PipelineException> seenExceptions)
+		private static async Task PingAsync(IRequestPipeline pipeline, Node node)
 		{
 			try
 			{
-				await pipeline.PingAsync(node);
+				await pipeline.PingAsync(node).ConfigureAwait(false);
 			}
 			catch (PipelineException e) when (e.Recoverable)
 			{
-				await pipeline.SniffOnConnectionFailureAsync();
+				await pipeline.SniffOnConnectionFailureAsync().ConfigureAwait(false);
 				e.RethrowKeepingStackTrace();
 			}
 		}
diff --git a/src/Nest/Document/Multiple/MultiGet/ElasticClient-SourceMany.cs b/src/Nest/Document/Multiple/MultiGet/ElasticClient-SourceMany.cs
@@ -78,7 +78,7 @@ public static IEnumerable<T> SourceMany<T>(this IElasticClient client, IEnumerab
 		public static async Task<IEnumerable<T>> SourceManyAsync<T>(this IElasticClient client, IEnumerable<string> ids, string index = null, string type = null)
 			where T : class
 		{
-			var response = await client.MultiGetAsync(s => s.GetMany<T>(ids, (gs, i) => gs.Index(index).Type(type)));
+			var response = await client.MultiGetAsync(s => s.GetMany<T>(ids, (gs, i) => gs.Index(index).Type(type))).ConfigureAwait(false);
 			return response.SourceMany<T>(ids);
 		}
 
diff --git a/src/Nest/Document/Multiple/MultiGet/EllasticClient-GetMany.cs b/src/Nest/Document/Multiple/MultiGet/EllasticClient-GetMany.cs
@@ -59,7 +59,7 @@ public static IEnumerable<IMultiGetHit<T>> GetMany<T>(this IElasticClient client
 		public static async Task<IEnumerable<IMultiGetHit<T>>> GetManyAsync<T>(this IElasticClient client, IEnumerable<string> ids, string index = null, string type = null)
 			where T : class
 		{
-			var response = await client.MultiGetAsync(s => s.GetMany<T>(ids, (gs, i) => gs.Index(index).Type(type)));
+			var response = await client.MultiGetAsync(s => s.GetMany<T>(ids, (gs, i) => gs.Index(index).Type(type))).ConfigureAwait(false);
 			return response.GetMany<T>(ids);
 		}
 
diff --git a/src/Nest/Document/Single/Source/ElasticClient-Source.cs b/src/Nest/Document/Single/Source/ElasticClient-Source.cs
@@ -48,7 +48,7 @@ public Task<T> SourceAsync<T>(DocumentPath<T> document, Func<SourceDescriptor<T>
 		public async Task<T> SourceAsync<T>(ISourceRequest request) where T : class
 		{
 			request.RouteValues.Resolve(ConnectionSettings);
-			var response = await this.LowLevelDispatch.GetSourceDispatchAsync<T>(request);
+			var response = await this.LowLevelDispatch.GetSourceDispatchAsync<T>(request).ConfigureAwait(false);
 			return response.Body;
 		}
 
diff --git a/src/Nest/ElasticClient.cs b/src/Nest/ElasticClient.cs
@@ -72,7 +72,7 @@ Func<TRequest, PostData<object>, Task<ElasticsearchResponse<TResponse>>> dispatc
 			request.RequestParameters.DeserializationOverride(responseGenerator);
 
 			request.RequestParameters.DeserializationOverride(responseGenerator);
-			var response = await dispatch(request, request);
+			var response = await dispatch(request, request).ConfigureAwait(false);
 			return ResultsSelector(response);
 		}
 
diff --git a/src/Nest/Indices/AliasManagement/GetAliases/ElasticClient-GetAliasesPointingToIndex.cs b/src/Nest/Indices/AliasManagement/GetAliases/ElasticClient-GetAliasesPointingToIndex.cs
@@ -23,7 +23,7 @@ public static IList<AliasDefinition> GetAliasesPointingToIndex(this IElasticClie
 		/// <param name="indexName">The exact indexname we want to know aliases of</param>
 		public static async Task<IList<AliasDefinition>> GetAliasesPointingToIndexAsync(this IElasticClient client, string indexName)
 		{
-			var response =  await client.GetAliasAsync(a => a.Index(indexName));
+			var response =  await client.GetAliasAsync(a => a.Index(indexName)).ConfigureAwait(false);
 			return AliasesPointingToIndex(indexName, response);
 		}
 
diff --git a/src/Nest/Indices/AliasManagement/GetAliases/ElasticClient-GetIndicesPointingToAlias.cs b/src/Nest/Indices/AliasManagement/GetAliases/ElasticClient-GetIndicesPointingToAlias.cs
@@ -26,7 +26,7 @@ public static IList<string> GetIndicesPointingToAlias(this IElasticClient client
 		/// <param name="aliasName">The exact alias name</param>
 		public static async Task<IList<string>> GetIndicesPointingToAliasAsync(this IElasticClient client, string aliasName)
 		{
-			var response = await client.GetAliasAsync(a => a.Index(aliasName));
+			var response = await client.GetAliasAsync(a => a.Index(aliasName)).ConfigureAwait(false);
 			return IndicesPointingToAlias(aliasName, response);
 		}
 

Original file line number	Diff line number	Diff line change
`@@ -103,18 +103,18 @@ public virtual async Task<ElasticsearchResponse<TReturn>> RequestAsync<TReturn>(`
`103`	`103`	`try`
`104`	`104`	`{`
`105`	`105`	`var requestMessage = CreateHttpRequestMessage(requestData);`
`106`		`- var response = await client.SendAsync(requestMessage, requestData.CancellationToken);`
	`106`	`+ var response = await client.SendAsync(requestMessage, requestData.CancellationToken).ConfigureAwait(false);`
`107`	`107`	`builder.StatusCode = (int)response.StatusCode;`
`108`	`108`
`109`	`109`	`if (response.Content != null)`
`110`		`- builder.Stream = await response.Content.ReadAsStreamAsync();`
	`110`	`+ builder.Stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);`
`111`	`111`	`}`
`112`	`112`	`catch (HttpRequestException e)`
`113`	`113`	`{`
`114`	`114`	`HandleException(builder, e);`
`115`	`115`	`}`
`116`	`116`
`117`		`- return await builder.ToResponseAsync();`
	`117`	`+ return await builder.ToResponseAsync().ConfigureAwait(false);`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`private void HandleException<TReturn>(ResponseBuilder<TReturn> builder, HttpRequestException exception)`
Original file line number	Diff line number	Diff line change
`@@ -157,21 +157,21 @@ public virtual async Task<ElasticsearchResponse<TReturn>> RequestAsync<TReturn>(`
`157`	`157`
`158`	`158`	`if (data != null)`
`159`	`159`	`{`
`160`		`- using (var stream = await request.GetRequestStreamAsync())`
	`160`	`+ using (var stream = await request.GetRequestStreamAsync().ConfigureAwait(false))`
`161`	`161`	`{`
`162`	`162`	`if (requestData.HttpCompression)`
`163`	`163`	`using (var zipStream = new GZipStream(stream, CompressionMode.Compress))`
`164`		`- await data.WriteAsync(zipStream, requestData.ConnectionSettings);`
	`164`	`+ await data.WriteAsync(zipStream, requestData.ConnectionSettings).ConfigureAwait(false);`
`165`	`165`	`else`
`166`		`- await data.WriteAsync(stream, requestData.ConnectionSettings);`
	`166`	`+ await data.WriteAsync(stream, requestData.ConnectionSettings).ConfigureAwait(false);`
`167`	`167`	`}`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`//http://msdn.microsoft.com/en-us/library/system.net.httpwebresponse.getresponsestream.aspx`
`171`	`171`	`//Either the stream or the response object needs to be closed but not both although it won't`
`172`	`172`	`//throw any errors if both are closed atleast one of them has to be Closed.`
`173`	`173`	`//Since we expose the stream we let closing the stream determining when to close the connection`
`174`		`- var response = (HttpWebResponse)(await request.GetResponseAsync());`
	`174`	`+ var response = (HttpWebResponse)(await request.GetResponseAsync().ConfigureAwait(false));`
`175`	`175`	`builder.StatusCode = (int)response.StatusCode;`
`176`	`176`	`builder.Stream = response.GetResponseStream();`
`177`	`177`	`}`
`@@ -180,7 +180,7 @@ public virtual async Task<ElasticsearchResponse<TReturn>> RequestAsync<TReturn>(`
`180`	`180`	`HandleException(builder, e);`
`181`	`181`	`}`
`182`	`182`
`183`		`- return await builder.ToResponseAsync();`
	`183`	`+ return await builder.ToResponseAsync().ConfigureAwait(false);`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`private void HandleException<TReturn>(ResponseBuilder<TReturn> builder, WebException exception)`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public T Deserialize<T>(Stream stream)`
`34`	`34`	`using (var ms = new MemoryStream())`
`35`	`35`	`using (stream)`
`36`	`36`	`{`
`37`		`- await stream.CopyToAsync(ms, 8096, cancellationToken);`
	`37`	`+ await stream.CopyToAsync(ms, 8096, cancellationToken).ConfigureAwait(false);`
`38`	`38`	`var buffer = ms.ToArray();`
`39`	`39`	`if (buffer.Length <= 1)`
`40`	`40`	`return default(T);`
Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,7 @@ public void FirstPoolUsage(SemaphoreSlim semaphore)`
`144`	`144`	`public async Task FirstPoolUsageAsync(SemaphoreSlim semaphore)`
`145`	`145`	`{`
`146`	`146`	`if (!this.FirstPoolUsageNeedsSniffing) return;`
`147`		`- var success = await semaphore.WaitAsync(this._settings.RequestTimeout, this._cancellationToken);`
	`147`	`+ var success = await semaphore.WaitAsync(this._settings.RequestTimeout, this._cancellationToken).ConfigureAwait(false);`
`148`	`148`	`if (!success)`
`149`	`149`	`throw new PipelineException(PipelineFailure.CouldNotStartSniffOnStartup, (Exception)null);`
`150`	`150`
`@@ -153,7 +153,7 @@ public async Task FirstPoolUsageAsync(SemaphoreSlim semaphore)`
`153`	`153`	`{`
`154`	`154`	`using (this.Audit(SniffOnStartup))`
`155`	`155`	`{`
`156`		`- await this.SniffAsync();`
	`156`	`+ await this.SniffAsync().ConfigureAwait(false);`
`157`	`157`	`this._connectionPool.SniffedOnStartup = true;`
`158`	`158`	`}`
`159`	`159`	`}`
`@@ -178,7 +178,7 @@ public async Task SniffOnStaleClusterAsync()`
`178`	`178`	`if (!StaleClusterState) return;`
`179`	`179`	`using (this.Audit(AuditEvent.SniffOnStaleCluster))`
`180`	`180`	`{`
`181`		`- await this.SniffAsync();`
	`181`	`+ await this.SniffAsync().ConfigureAwait(false);`
`182`	`182`	`this._connectionPool.SniffedOnStartup = true;`
`183`	`183`	`}`
`184`	`184`	`}`
`@@ -263,7 +263,7 @@ public async Task PingAsync(Node node)`
`263`	`263`	`try`
`264`	`264`	`{`
`265`	`265`	`var pingData = CreatePingRequestData(node, audit);`
`266`		`- var response = await this._connection.RequestAsync<VoidResponse>(pingData);`
	`266`	`+ var response = await this._connection.RequestAsync<VoidResponse>(pingData).ConfigureAwait(false);`
`267`	`267`	`ThrowBadAuthPipelineExceptionWhenNeeded(response);`
`268`	`268`	`//ping should not silently accept bad but valid http responses`
`269`	`269`	`if (!response.Success) throw new PipelineException(PipelineFailure.BadResponse);`
`@@ -301,7 +301,7 @@ public async Task SniffOnConnectionFailureAsync()`
`301`	`301`	`{`
`302`	`302`	`if (!this.SniffsOnConnectionFailure) return;`
`303`	`303`	`using (this.Audit(SniffOnFail))`
`304`		`- await this.SniffAsync();`
	`304`	`+ await this.SniffAsync().ConfigureAwait(false);`
`305`	`305`	`}`
`306`	`306`
`307`	`307`	`public void Sniff()`
`@@ -349,7 +349,7 @@ public async Task SniffAsync()`
`349`	`349`	`try`
`350`	`350`	`{`
`351`	`351`	`var requestData = new RequestData(HttpMethod.GET, path, null, this._settings, this._memoryStreamFactory) { Node = node };`
`352`		`- var response = await this._connection.RequestAsync<SniffResponse>(requestData);`
	`352`	`+ var response = await this._connection.RequestAsync<SniffResponse>(requestData).ConfigureAwait(false);`
`353`	`353`	`ThrowBadAuthPipelineExceptionWhenNeeded(response);`
`354`	`354`	`//sniff should not silently accept bad but valid http responses`
`355`	`355`	`if (!response.Success) throw new PipelineException(PipelineFailure.BadResponse);`
`@@ -406,7 +406,7 @@ public async Task<ElasticsearchResponse<TReturn>> CallElasticsearchAsync<TReturn`
`406`	`406`	`ElasticsearchResponse<TReturn> response = null;`
`407`	`407`	`try`
`408`	`408`	`{`
`409`		`- response = await this._connection.RequestAsync<TReturn>(requestData);`
	`409`	`+ response = await this._connection.RequestAsync<TReturn>(requestData).ConfigureAwait(false);`
`410`	`410`	`response.AuditTrail = this.AuditTrail;`
`411`	`411`	`ThrowBadAuthPipelineExceptionWhenNeeded(response);`
`412`	`412`	`if (!response.Success) audit.Event = AuditEvent.BadResponse;`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public async Task<ElasticsearchResponse<TReturn>> ToResponseAsync()`
`36`	`36`	`{`
`37`	`37`	`var response = Initialize(this.StatusCode, this.Exception);`
`38`	`38`	`if (this.Stream != null)`
`39`		`- await SetBodyAsync(response, this.Stream);`
	`39`	`+ await SetBodyAsync(response, this.Stream).ConfigureAwait(false);`
`40`	`40`	`Finalize(response);`
`41`	`41`	`return response;`
`42`	`42`	`}`
`@@ -87,19 +87,19 @@ private async Task SetBodyAsync(ElasticsearchResponse<TReturn> response, Stream`
`87`	`87`	`if (NeedsToEagerReadStream())`
`88`	`88`	`{`
`89`	`89`	`var inMemoryStream = this._requestData.MemoryStreamFactory.Create();`
`90`		`- await stream.CopyToAsync(inMemoryStream, BufferSize, this._requestData.CancellationToken);`
	`90`	`+ await stream.CopyToAsync(inMemoryStream, BufferSize, this._requestData.CancellationToken).ConfigureAwait(false);`
`91`	`91`	`bytes = this.SwapStreams(ref stream, ref inMemoryStream);`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`if (!SetSpecialTypes(stream, response, bytes))`
`95`	`95`	`{`
`96`	`96`	`if (this._requestData.CustomConverter != null) response.Body = this._requestData.CustomConverter(response, stream) as TReturn;`
`97`		`- else response.Body = await this._requestData.ConnectionSettings.Serializer.DeserializeAsync<TReturn>(stream, this._requestData.CancellationToken);`
	`97`	`+ else response.Body = await this._requestData.ConnectionSettings.Serializer.DeserializeAsync<TReturn>(stream, this._requestData.CancellationToken).ConfigureAwait(false);`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`	`else if (response.HttpStatusCode != null)`
`101`	`101`	`{`
`102`		`- response.ServerError = await ServerError.TryCreateAsync(stream, this._requestData.CancellationToken);`
	`102`	`+ response.ServerError = await ServerError.TryCreateAsync(stream, this._requestData.CancellationToken).ConfigureAwait(false);`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ public void Write(Stream writableStream, IConnectionConfigurationValues settings`
`136`	`136`	`foreach (var o in _enumerableOfObject)`
`137`	`137`	`{`
`138`	`138`	`settings.Serializer.Serialize(o, stream, SerializationFormatting.None);`
`139`		`- await stream.WriteAsync(new byte[] { (byte)'\n' }, 0, 1, cancellationToken);`
	`139`	`+ await stream.WriteAsync(new byte[] { (byte)'\n' }, 0, 1, cancellationToken).ConfigureAwait(false);`
`140`	`140`	`}`
`141`	`141`	`break;`
`142`	`142`	`case PostType.Serializable:`
`@@ -152,7 +152,7 @@ public void Write(Stream writableStream, IConnectionConfigurationValues settings`
`152`	`152`	`if (ms != null)`
`153`	`153`	`{`
`154`	`154`	`ms.Position = 0;`
`155`		`- await ms.CopyToAsync(writableStream, 8096, cancellationToken);`
	`155`	`+ await ms.CopyToAsync(writableStream, 8096, cancellationToken).ConfigureAwait(false);`
`156`	`156`	`}`
`157`	`157`	`if (this.Type != 0)`
`158`	`158`	`this.WrittenBytes = ms?.ToArray();`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ public ElasticsearchResponse<TReturn> Request<TReturn>(HttpMethod method, string`
`64`	`64`	`try`
`65`	`65`	`{`
`66`	`66`	`pipeline.SniffOnStaleCluster();`
`67`		`- Ping(pipeline, node, seenExceptions);`
	`67`	`+ Ping(pipeline, node);`
`68`	`68`	`response = pipeline.CallElasticsearch<TReturn>(requestData);`
`69`	`69`	`if (!response.SuccessOrKnownError)`
`70`	`70`	`{`
`@@ -112,7 +112,7 @@ public async Task<ElasticsearchResponse<TReturn>> RequestAsync<TReturn>(HttpMeth`
`112`	`112`	`{`
`113`	`113`	`using (var pipeline = this.PipelineProvider.Create(this.Settings, this.DateTimeProvider, this.MemoryStreamFactory, requestParameters))`
`114`	`114`	`{`
`115`		`- await pipeline.FirstPoolUsageAsync(this.Settings.BootstrapLock);`
	`115`	`+ await pipeline.FirstPoolUsageAsync(this.Settings.BootstrapLock).ConfigureAwait(false);`
`116`	`116`
`117`	`117`	`var requestData = new RequestData(method, path, data, this.Settings, requestParameters, this.MemoryStreamFactory);`
`118`	`118`	`ElasticsearchResponse<TReturn> response = null;`
`@@ -123,13 +123,13 @@ public async Task<ElasticsearchResponse<TReturn>> RequestAsync<TReturn>(HttpMeth`
`123`	`123`	`requestData.Node = node;`
`124`	`124`	`try`
`125`	`125`	`{`
`126`		`- await pipeline.SniffOnStaleClusterAsync();`
`127`		`- await PingAsync(pipeline, node, seenExceptions);`
`128`		`- response = await pipeline.CallElasticsearchAsync<TReturn>(requestData);`
	`126`	`+ await pipeline.SniffOnStaleClusterAsync().ConfigureAwait(false);`
	`127`	`+ await PingAsync(pipeline, node).ConfigureAwait(false);`
	`128`	`+ response = await pipeline.CallElasticsearchAsync<TReturn>(requestData).ConfigureAwait(false);`
`129`	`129`	`if (!response.SuccessOrKnownError)`
`130`	`130`	`{`
`131`	`131`	`pipeline.MarkDead(node);`
`132`		`- await pipeline.SniffOnConnectionFailureAsync();`
	`132`	`+ await pipeline.SniffOnConnectionFailureAsync().ConfigureAwait(false);`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`	`catch (PipelineException pipelineException) when (!pipelineException.Recoverable)`
`@@ -167,7 +167,7 @@ public async Task<ElasticsearchResponse<TReturn>> RequestAsync<TReturn>(HttpMeth`
`167`	`167`	`}`
`168`	`168`	`}`
`169`	`169`
`170`		`- private static void Ping(IRequestPipeline pipeline, Node node, List<PipelineException> seenExceptions)`
	`170`	`+ private static void Ping(IRequestPipeline pipeline, Node node)`
`171`	`171`	`{`
`172`	`172`	`try`
`173`	`173`	`{`
`@@ -180,15 +180,15 @@ private static void Ping(IRequestPipeline pipeline, Node node, List<PipelineExce`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`
`183`		`- private static async Task PingAsync(IRequestPipeline pipeline, Node node, List<PipelineException> seenExceptions)`
	`183`	`+ private static async Task PingAsync(IRequestPipeline pipeline, Node node)`
`184`	`184`	`{`
`185`	`185`	`try`
`186`	`186`	`{`
`187`		`- await pipeline.PingAsync(node);`
	`187`	`+ await pipeline.PingAsync(node).ConfigureAwait(false);`
`188`	`188`	`}`
`189`	`189`	`catch (PipelineException e) when (e.Recoverable)`
`190`	`190`	`{`
`191`		`- await pipeline.SniffOnConnectionFailureAsync();`
	`191`	`+ await pipeline.SniffOnConnectionFailureAsync().ConfigureAwait(false);`
`192`	`192`	`e.RethrowKeepingStackTrace();`
`193`	`193`	`}`
`194`	`194`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ public static IEnumerable<T> SourceMany<T>(this IElasticClient client, IEnumerab`
`78`	`78`	`public static async Task<IEnumerable<T>> SourceManyAsync<T>(this IElasticClient client, IEnumerable<string> ids, string index = null, string type = null)`
`79`	`79`	`where T : class`
`80`	`80`	`{`
`81`		`- var response = await client.MultiGetAsync(s => s.GetMany<T>(ids, (gs, i) => gs.Index(index).Type(type)));`
	`81`	`+ var response = await client.MultiGetAsync(s => s.GetMany<T>(ids, (gs, i) => gs.Index(index).Type(type))).ConfigureAwait(false);`
`82`	`82`	`return response.SourceMany<T>(ids);`
`83`	`83`	`}`
`84`	`84`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ public static IEnumerable<IMultiGetHit<T>> GetMany<T>(this IElasticClient client`
`59`	`59`	`public static async Task<IEnumerable<IMultiGetHit<T>>> GetManyAsync<T>(this IElasticClient client, IEnumerable<string> ids, string index = null, string type = null)`
`60`	`60`	`where T : class`
`61`	`61`	`{`
`62`		`- var response = await client.MultiGetAsync(s => s.GetMany<T>(ids, (gs, i) => gs.Index(index).Type(type)));`
	`62`	`+ var response = await client.MultiGetAsync(s => s.GetMany<T>(ids, (gs, i) => gs.Index(index).Type(type))).ConfigureAwait(false);`
`63`	`63`	`return response.GetMany<T>(ids);`
`64`	`64`	`}`
`65`	`65`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ public Task<T> SourceAsync<T>(DocumentPath<T> document, Func<SourceDescriptor<T>`
`48`	`48`	`public async Task<T> SourceAsync<T>(ISourceRequest request) where T : class`
`49`	`49`	`{`
`50`	`50`	`request.RouteValues.Resolve(ConnectionSettings);`
`51`		`- var response = await this.LowLevelDispatch.GetSourceDispatchAsync<T>(request);`
	`51`	`+ var response = await this.LowLevelDispatch.GetSourceDispatchAsync<T>(request).ConfigureAwait(false);`
`52`	`52`	`return response.Body;`
`53`	`53`	`}`
`54`	`54`