Add missing ConfigureAwait(false) to prevent deadlocks (#2367)

* Add missing ConfigureAwait(false) to prevent sync-over-async deadlocks

Fixes #2083

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Add regression tests for sync-over-async deadlock fix

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: alexeyzimarev

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();
+    }
+}