Add missing ConfigureAwait(false) to prevent deadlocks

src/RestSharp/Extensions/HttpResponseExtensions.cs

@@ -32,7 +32,7 @@ public static async Task<string> GetResponseString(this HttpResponseMessage resp
  var encoding = encodingString != null ? TryGetEncoding(encodingString) : clientEncoding;
 
  using var reader = new StreamReader(new MemoryStream(bytes), encoding);
- return await reader.ReadToEndAsync();
+ return await reader.ReadToEndAsync().ConfigureAwait(false);
  Encoding TryGetEncoding(string es) {
  try {
  return Encoding.GetEncoding(es);

src/RestSharp/Response/RestResponse.cs

@@ -54,7 +54,7 @@ async Task<RestResponse> GetDefaultResponse() {
 #endif
 
  var bytes = stream == null ? null : await stream.ReadAsBytes(cancellationToken).ConfigureAwait(false);
- var content = bytes == null ? null : await httpResponse.GetResponseString(bytes, options.Encoding);
+ var content = bytes == null ? null : await httpResponse.GetResponseString(bytes, options.Encoding).ConfigureAwait(false);
 
  return new(request) {
  Content = content,

src/RestSharp/RestClient.Extensions.cs

@@ -45,7 +45,7 @@ public async Task<RestResponse<T>> ExecuteAsync<T>(
  Ensure.NotNull(request, nameof(request));
 
  var response = await client.ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
- return await client.Serializers.Deserialize<T>(request, response, client.Options, cancellationToken);
+ return await client.Serializers.Deserialize<T>(request, response, client.Options, cancellationToken).ConfigureAwait(false);
  }
 
  /// <summary>
@@ -172,9 +172,9 @@ [EnumeratorCancellation] CancellationToken cancellationToken
  using var reader = new StreamReader(stream);
 
 #if NET7_0_OR_GREATER
- while (await reader.ReadLineAsync(cancellationToken) is { } line && !cancellationToken.IsCancellationRequested) {
+ while (await reader.ReadLineAsync(cancellationToken).ConfigureAwait(false) is { } line && !cancellationToken.IsCancellationRequested) {
 #else
- while (await reader.ReadLineAsync() is { } line && !cancellationToken.IsCancellationRequested) {
+ while (await reader.ReadLineAsync().ConfigureAwait(false) is { } line && !cancellationToken.IsCancellationRequested) {
 #endif
  if (string.IsNullOrWhiteSpace(line)) continue;
 

test/RestSharp.Tests.Integrated/SyncRequestTests.cs

@@ -0,0 +1,57 @@
+namespace RestSharp.Tests.Integrated;
+
+#pragma warning disable xUnit1031 // Blocking calls in tests are intentional — we are testing sync-over-async deadlock safety
+
+public sealed class SyncRequestTests(WireMockTestServer server) : IClassFixture<WireMockTestServer> {
+ [Fact]
+ public void Sync_execute_should_not_deadlock() {
+ // Regression test for https://github.com/restsharp/RestSharp/issues/2083
+ // Sync methods (ExecuteGet) could deadlock when await calls inside the pipeline
+ // did not use ConfigureAwait(false), causing continuations to try to marshal
+ // back to a captured SynchronizationContext.
+
+ using var client = new RestClient(server.Url!);
+ var request = new RestRequest("success");
+
+ RestResponse? response = null;
+
+ var completed = Task.Run(() => {
+ response = client.ExecuteGet(request);
+ }).Wait(TimeSpan.FromSeconds(10));
+
+ completed.Should().BeTrue("sync ExecuteGet should complete without deadlocking");
+ response.Should().NotBeNull();
+ response!.IsSuccessStatusCode.Should().BeTrue();
+ }
+
+ [Fact]
+ public void Sync_execute_with_deserialization_should_not_deadlock() {
+ using var client = new RestClient(server.Url!);
+ var request = new RestRequest("success");
+
+ RestResponse<SuccessResponse>? response = null;
+
+ var completed = Task.Run(() => {
+ response = client.ExecuteGet<SuccessResponse>(request);
+ }).Wait(TimeSpan.FromSeconds(10));
+
+ completed.Should().BeTrue("sync ExecuteGet<T> should complete without deadlocking");
+ response.Should().NotBeNull();
+ response!.IsSuccessStatusCode.Should().BeTrue();
+ response.Data.Should().NotBeNull();
+ }
+
+ [Fact]
+ public void Sync_execute_from_multiple_threads_should_not_deadlock() {
+ using var client = new RestClient(server.Url!);
+ const int threadCount = 5;
+
+ var completed = Parallel.For(0, threadCount, _ => {
+ var request = new RestRequest("success");
+ var response = client.ExecuteGet(request);
+ response.IsSuccessStatusCode.Should().BeTrue();
+ });
+
+ completed.IsCompleted.Should().BeTrue();
+ }
+}