Implementations of new HttpContent sync methods.

src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Decompression.cs

@@ -65,6 +65,9 @@ public static IEnumerable<object[]> DecompressedResponse_MethodSpecified_Decompr
             }
         }
 
+        private HttpRequestMessage CreateRequest(HttpMethod method, Uri uri, Version version) =>
+            new HttpRequestMessage(method, uri) { Version = version };
+
         [Theory]
         [MemberData(nameof(DecompressedResponse_MethodSpecified_DecompressedContentReturned_MemberData))]
         public async Task DecompressedResponse_MethodSpecified_DecompressedContentReturned(
@@ -163,11 +166,17 @@ await server.AcceptConnectionAsync(async connection =>
         [Theory, MemberData(nameof(RemoteServersAndCompressionUris))]
         public async Task GetAsync_SetAutomaticDecompression_ContentDecompressed(Configuration.Http.RemoteServer remoteServer, Uri uri)
         {
+            // Sync API supported only up to HTTP/1.1
+            if (!TestAsync && remoteServer.HttpVersion.Major >= 2)
+            {
+                return;
+            }
+
             HttpClientHandler handler = CreateHttpClientHandler();
             handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer, handler))
             {
-                using (HttpResponseMessage response = await client.GetAsync(uri))
+                using (HttpResponseMessage response = await client.SendAsync(TestAsync, CreateRequest(HttpMethod.Get, uri, remoteServer.HttpVersion)))
                 {
                     Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                     string responseContent = await response.Content.ReadAsStringAsync();
@@ -185,10 +194,16 @@ public async Task GetAsync_SetAutomaticDecompression_ContentDecompressed(Configu
         [Theory, MemberData(nameof(RemoteServersAndCompressionUris))]
         public async Task GetAsync_SetAutomaticDecompression_HeadersRemoved(Configuration.Http.RemoteServer remoteServer, Uri uri)
         {
+            // Sync API supported only up to HTTP/1.1
+            if (!TestAsync && remoteServer.HttpVersion.Major >= 2)
+            {
+                return;
+            }
+
             HttpClientHandler handler = CreateHttpClientHandler();
             handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer, handler))
-            using (HttpResponseMessage response = await client.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead))
+            using (HttpResponseMessage response = await client.SendAsync(TestAsync, CreateRequest(HttpMethod.Get, uri, remoteServer.HttpVersion), HttpCompletionOption.ResponseHeadersRead))
             {
                 Assert.Equal(HttpStatusCode.OK, response.StatusCode);
 
@@ -237,7 +252,7 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
                         client.DefaultRequestHeaders.Add("Accept-Encoding", manualAcceptEncodingHeaderValues);
                     }
 
-                    Task<HttpResponseMessage> clientTask = client.GetAsync(url);
+                    Task<HttpResponseMessage> clientTask = client.SendAsync(TestAsync, CreateRequest(HttpMethod.Get, url, UseVersion));
                     Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
                     await TaskTimeoutExtensions.WhenAllOrAnyFailed(new Task[] { clientTask, serverTask });
 

src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTestBase.cs

@@ -110,6 +110,25 @@ public VersionCheckerHttpHandler(HttpMessageHandler innerHandler, Version expect
                 _expectedVersion = expectedVersion;
             }
 
+#if NETCOREAPP
+            protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken)
+            {
+                if (request.Version != _expectedVersion)
+                {
+                    throw new Exception($"Unexpected request version: expected {_expectedVersion}, saw {request.Version}");
+                }
+
+                HttpResponseMessage response = base.Send(request, cancellationToken);
+
+                if (response.Version != _expectedVersion)
+                {
+                    throw new Exception($"Unexpected response version: expected {_expectedVersion}, saw {response.Version}");
+                }
+
+                return response;
+            }
+#endif
+
             protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
             {
                 if (request.Version != _expectedVersion)

src/libraries/System.Net.Http.Json/ref/System.Net.Http.Json.netcoreapp.cs

@@ -6,6 +6,7 @@ namespace System.Net.Http.Json
 {
     public sealed partial class JsonContent : System.Net.Http.HttpContent
     {
+        protected override void SerializeToStream(System.IO.Stream stream, System.Net.TransportContext? context, System.Threading.CancellationToken cancellationToken) { }
         protected override System.Threading.Tasks.Task SerializeToStreamAsync(System.IO.Stream stream, System.Net.TransportContext? context, System.Threading.CancellationToken cancellationToken) { throw null; }
     }
 }

src/libraries/System.Net.Http.Json/src/System/Net/Http/Json/JsonContent.cs

@@ -52,15 +52,15 @@ public static JsonContent Create(object? inputValue, Type inputType, MediaTypeHe
             => new JsonContent(inputValue, inputType, mediaType, options);
 
         protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context)
-            => SerializeToStreamAsyncCore(stream, CancellationToken.None);
+            => SerializeToStreamAsyncCore(stream, async: true, CancellationToken.None);
 
         protected override bool TryComputeLength(out long length)
         {
             length = 0;
             return false;
         }
 
-        private async Task SerializeToStreamAsyncCore(Stream targetStream, CancellationToken cancellationToken)
+        private async Task SerializeToStreamAsyncCore(Stream targetStream, bool async, CancellationToken cancellationToken)
         {
             Encoding? targetEncoding = GetEncoding(Headers.ContentType?.CharSet);
 
@@ -71,15 +71,34 @@ private async Task SerializeToStreamAsyncCore(Stream targetStream, CancellationT
                 Stream transcodingStream = Encoding.CreateTranscodingStream(targetStream, targetEncoding, Encoding.UTF8, leaveOpen: true);
                 try
                 {
-                    await JsonSerializer.SerializeAsync(transcodingStream, Value, ObjectType, _jsonSerializerOptions, cancellationToken).ConfigureAwait(false);
+                    if (async)
+                    {
+                        await JsonSerializer.SerializeAsync(transcodingStream, Value, ObjectType, _jsonSerializerOptions, cancellationToken).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        // Have to use Utf8JsonWriter because JsonSerializer doesn't support sync serialization into stream directly.
+                        // ToDo: Remove Utf8JsonWriter usage after https://github.com/dotnet/runtime/issues/1574
+                        using Utf8JsonWriter writer = new Utf8JsonWriter(transcodingStream);
+                        JsonSerializer.Serialize(writer, Value, ObjectType, _jsonSerializerOptions);
+                    }
                 }
                 finally
                 {
-                    // DisposeAsync will flush any partial write buffers. In practice our partial write
+                    // Dispose/DisposeAsync will flush any partial write buffers. In practice our partial write
                     // buffers should be empty as we expect JsonSerializer to emit only well-formed UTF-8 data.
-                    await transcodingStream.DisposeAsync().ConfigureAwait(false);
+                    if (async)
+                    {
+                        await transcodingStream.DisposeAsync().ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        transcodingStream.Dispose();
+                    }
                 }
 #else
+                Debug.Assert(async);
+
                 using (TranscodingWriteStream transcodingStream = new TranscodingWriteStream(targetStream, targetEncoding))
                 {
                     await JsonSerializer.SerializeAsync(transcodingStream, Value, ObjectType, _jsonSerializerOptions, cancellationToken).ConfigureAwait(false);
@@ -92,7 +111,21 @@ private async Task SerializeToStreamAsyncCore(Stream targetStream, CancellationT
             }
             else
             {
-                await JsonSerializer.SerializeAsync(targetStream, Value, ObjectType, _jsonSerializerOptions, cancellationToken).ConfigureAwait(false);
+                if (async)
+                {
+                    await JsonSerializer.SerializeAsync(targetStream, Value, ObjectType, _jsonSerializerOptions, cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+#if NETCOREAPP
+                    // Have to use Utf8JsonWriter because JsonSerializer doesn't support sync serialization into stream directly.
+                    // ToDo: Remove Utf8JsonWriter usage after https://github.com/dotnet/runtime/issues/1574
+                    using Utf8JsonWriter writer = new Utf8JsonWriter(targetStream);
+                    JsonSerializer.Serialize(writer, Value, ObjectType, _jsonSerializerOptions);
+#else
+                    Debug.Assert(async);
+#endif
+                }
             }
         }
 

src/libraries/System.Net.Http.Json/src/System/Net/Http/Json/JsonContent.netcoreapp.cs

@@ -10,7 +10,10 @@ namespace System.Net.Http.Json
 {
     public sealed partial class JsonContent
     {
+        protected override void SerializeToStream(Stream stream, TransportContext? context, CancellationToken cancellationToken)
+            => SerializeToStreamAsyncCore(stream, async: false, cancellationToken).GetAwaiter().GetResult();
+
         protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context, CancellationToken cancellationToken)
-            => SerializeToStreamAsyncCore(stream, cancellationToken);
+            => SerializeToStreamAsyncCore(stream, async: true, cancellationToken);
     }
 }

src/libraries/System.Net.Http.Json/tests/FunctionalTests/HttpClientJsonExtensionsTests.cs

@@ -14,17 +14,10 @@ namespace System.Net.Http.Json.Functional.Tests
 {
     public class HttpClientJsonExtensionsTests
     {
-        private static readonly JsonSerializerOptions s_defaultSerializerOptions
-            = new JsonSerializerOptions
-            {
-                PropertyNameCaseInsensitive = true,
-                PropertyNamingPolicy = JsonNamingPolicy.CamelCase
-            };
-
         [Fact]
         public async Task TestGetFromJsonAsync()
         {
-            const string json = @"{""Name"":""David"",""Age"":24}";
+            string json = Person.Create().Serialize();
             const int NumRequests = 4;
             HttpHeaderData header = new HttpHeaderData("Content-Type", "application/json");
             List<HttpHeaderData> headers = new List<HttpHeaderData> { header };
@@ -107,7 +100,7 @@ await LoopbackServer.CreateClientAndServerAsync(
                     {
                         HttpRequestData request = await server.HandleRequestAsync();
                         ValidateRequest(request);
-                        Person per = JsonSerializer.Deserialize<Person>(request.Body, s_defaultSerializerOptions);
+                        Person per = JsonSerializer.Deserialize<Person>(request.Body, JsonOptions.DefaultSerializerOptions);
                         per.Validate();
                     }
                 });
@@ -143,7 +136,7 @@ await LoopbackServer.CreateClientAndServerAsync(
                     {
                         HttpRequestData request = await server.HandleRequestAsync();
                         ValidateRequest(request);
-                        Person obj = JsonSerializer.Deserialize<Person>(request.Body, s_defaultSerializerOptions);
+                        Person obj = JsonSerializer.Deserialize<Person>(request.Body, JsonOptions.DefaultSerializerOptions);
                         obj.Validate();
                     }
                 });

src/libraries/System.Net.Http.Json/tests/FunctionalTests/HttpContentJsonExtensionsTests.cs

@@ -167,7 +167,7 @@ await LoopbackServer.CreateClientAndServerAsync(
         [Fact]
         public async Task TestGetFromJsonAsyncTextPlainUtf16Async()
         {
-            const string json = @"{""Name"":""David"",""Age"":24}";
+            string json = Person.Create().Serialize();
             const int NumRequests = 2;
             await LoopbackServer.CreateClientAndServerAsync(
                 async uri =>

src/libraries/System.Net.Http.Json/tests/FunctionalTests/JsonContentTests.cs

@@ -4,15 +4,17 @@
 
 using System.Net.Http.Headers;
 using System.Net.Test.Common;
+using System.Runtime.CompilerServices;
 using System.Text;
 using System.Text.Json;
 using System.Threading.Tasks;
 using Xunit;
 
 namespace System.Net.Http.Json.Functional.Tests
 {
-    public class JsonContentTests
+    public abstract class JsonContentTestsBase
     {
+        protected abstract Task<HttpResponseMessage> SendAsync(HttpClient client, HttpRequestMessage request);
 
         private class Foo { }
         private class Bar { }
@@ -71,7 +73,6 @@ public void TestJsonContentMediaType()
         [Fact]
         public async Task SendQuotedCharsetAsync()
         {
-
             await LoopbackServer.CreateClientAndServerAsync(
                 async uri =>
                 {
@@ -82,7 +83,7 @@ await LoopbackServer.CreateClientAndServerAsync(
 
                         var request = new HttpRequestMessage(HttpMethod.Post, uri);
                         request.Content = content;
-                        await client.SendAsync(request);
+                        await SendAsync(client, request);
                     }
                 },
                 async server => {
@@ -114,7 +115,7 @@ await LoopbackServer.CreateClientAndServerAsync(
                         var request = new HttpRequestMessage(HttpMethod.Post, uri);
                         MediaTypeHeaderValue mediaType = MediaTypeHeaderValue.Parse("foo/bar; charset=utf-8");
                         request.Content = JsonContent.Create(Person.Create(), mediaType: mediaType);
-                        await client.SendAsync(request);
+                        await SendAsync(client, request);
                     }
                 },
                 async server => {
@@ -161,7 +162,7 @@ public void JsonContentThrowsOnIncompatibleTypeAsync()
         }
 
         [Fact]
-        public static async Task ValidateUtf16IsTranscodedAsync()
+        public async Task ValidateUtf16IsTranscodedAsync()
         {
             await LoopbackServer.CreateClientAndServerAsync(
                 async uri =>
@@ -172,7 +173,7 @@ await LoopbackServer.CreateClientAndServerAsync(
                         MediaTypeHeaderValue mediaType = MediaTypeHeaderValue.Parse("application/json; charset=utf-16");
                         // Pass new options to avoid using the Default Web Options that use camelCase.
                         request.Content = JsonContent.Create(Person.Create(), mediaType: mediaType, options: new JsonSerializerOptions());
-                        await client.SendAsync(request);
+                        await SendAsync(client, request);
                     }
                 },
                 async server => {
@@ -195,7 +196,7 @@ await LoopbackServer.CreateClientAndServerAsync(
                         EnsureDefaultOptions dummyObj = new EnsureDefaultOptions();
                         var request = new HttpRequestMessage(HttpMethod.Post, uri);
                         request.Content = JsonContent.Create(dummyObj);
-                        await client.SendAsync(request);
+                        await SendAsync(client, request);
                     }
                 },
                 server => server.HandleRequestAsync());
@@ -215,7 +216,7 @@ await LoopbackServer.CreateClientAndServerAsync(
                         content.Headers.ContentType = null;
 
                         request.Content = content;
-                        await client.SendAsync(request);
+                        await SendAsync(client, request);
                     }
                 },
                 async server => {
@@ -224,4 +225,9 @@ await LoopbackServer.CreateClientAndServerAsync(
                 });
         }
     }
+
+    public class JsonContentTests_Async : JsonContentTestsBase
+    {
+        protected override Task<HttpResponseMessage> SendAsync(HttpClient client, HttpRequestMessage request) => client.SendAsync(request);
+    }
 }

src/libraries/System.Net.Http.Json/tests/FunctionalTests/JsonContentTests.netcoreapp.cs

@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.IO;
+using System.Net.Http.Headers;
+using System.Net.Test.Common;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace System.Net.Http.Json.Functional.Tests
+{
+    public class JsonContentTests_Sync : JsonContentTestsBase
+    {
+        protected override Task<HttpResponseMessage> SendAsync(HttpClient client, HttpRequestMessage request) => Task.Run(() => client.Send(request));
+
+        [Fact]
+        public void JsonContent_CopyTo_Succeeds()
+        {
+            var person = Person.Create();
+            using var content = JsonContent.Create(person);
+            using var stream = new MemoryStream();
+            content.CopyTo(stream, null, default);
+            stream.Seek(0, SeekOrigin.Begin);
+            using var reader = new StreamReader(stream);
+            var json = reader.ReadToEnd();
+            Assert.Equal(person.Serialize(JsonOptions.DefaultSerializerOptions), json);
+        }
+    }
+}

src/libraries/System.Net.Http.Json/tests/FunctionalTests/System.Net.Http.Json.Functional.Tests.csproj

@@ -9,6 +9,9 @@
     <Compile Include="JsonContentTests.cs" />
     <Compile Include="TestClasses.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <Compile Include="JsonContentTests.netcoreapp.cs" />
+  </ItemGroup>
   <ItemGroup>
     <Compile Include="$(CommonTestPath)System\Net\Capability.Security.cs"
              Link="Common\System\Net\Capability.Security.cs" />