Initial migration from Newtonsoft.Json to System.Text.Json

src/NuGet.Clients/NuGet.PackageManagement.UI/UserInterfaceService/NuGetSettingsSerializer.cs

@@ -2,43 +2,35 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System.IO;
-using System.Text;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
 
 namespace NuGet.PackageManagement.UI
 {
     internal sealed class NuGetSettingsSerializer
     {
-        private const int _bufferSize = 4096;
-
-        private readonly JsonSerializer _serializer;
+        private const int BufferSize = 4096;
+        private readonly JsonSerializerOptions _options;
 
         internal NuGetSettingsSerializer()
         {
-            _serializer = new JsonSerializer();
-
-            _serializer.Converters.Add(new StringEnumConverter());
+            _options = new JsonSerializerOptions
+            {
+                Converters = { new JsonStringEnumConverter() },
+                PropertyNameCaseInsensitive = true,
+                DefaultBufferSize = BufferSize,
+            };
         }
 
-        internal NuGetSettings Deserialize(Stream stream)
+        internal async Task<NuGetSettings> DeserializeAsync(Stream stream)
         {
-            using (var streamReader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: _bufferSize, leaveOpen: true))
-            using (var jsonReader = new JsonTextReader(streamReader))
-            {
-                jsonReader.CloseInput = false;
-
-                return _serializer.Deserialize<NuGetSettings>(jsonReader);
-            }
+            return await JsonSerializer.DeserializeAsync<NuGetSettings>(stream, _options);
         }
 
-        internal void Serialize(Stream stream, NuGetSettings settings)
+        internal async Task SerializeAsync(Stream stream, NuGetSettings settings)
         {
-            using (var streamWriter = new StreamWriter(stream, Encoding.UTF8, bufferSize: _bufferSize, leaveOpen: true))
-            using (var jsonWriter = new JsonTextWriter(streamWriter))
-            {
-                _serializer.Serialize(jsonWriter, settings);
-            }
+            await JsonSerializer.SerializeAsync(stream, settings, _options);
         }
     }
 }

src/NuGet.Clients/NuGet.PackageManagement.UI/UserInterfaceService/SolutionUserOptions.cs

@@ -120,7 +120,7 @@ public int ReadUserOptions(IStream pOptionsStream, string _)
             {
                 using (var stream = new DataStreamFromComStream(pOptionsStream))
                 {
-                    NuGetSettings settings = _serializer.Deserialize(stream);
+                    var settings = ThreadHelper.JoinableTaskFactory.Run<NuGetSettings>(async () => await _serializer.DeserializeAsync(stream));
 
                     if (settings != null)
                     {
@@ -152,7 +152,7 @@ public int WriteUserOptions(IStream pOptionsStream, string _)
             {
                 using (var stream = new DataStreamFromComStream(pOptionsStream))
                 {
-                    _serializer.Serialize(stream, _settings);
+                    ThreadHelper.JoinableTaskFactory.Run(async () => await _serializer.SerializeAsync(stream, _settings));
                 }
             }
             catch

test/NuGet.Clients.Tests/NuGet.PackageManagement.UI.Test/NuGetSettingsSerializerTests.cs

@@ -5,6 +5,8 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
 using Newtonsoft.Json;
 using Xunit;
 
@@ -45,21 +47,29 @@ public void UserSettings_WhenSerializing_PropertyCountIsExpected()
         }
 
         [Fact]
-        public void Serialization_WhenDeserializing_Succeeds()
+        public async Task Serialization_WhenDeserializing_Succeeds()
         {
             NuGetSettings expectedSettings = CreateNuGetSettings();
 
             var serializer = new NuGetSettingsSerializer();
 
             using (var stream = new MemoryStream())
             {
-                serializer.Serialize(stream, expectedSettings);
+                await serializer.SerializeAsync(stream, expectedSettings);
 
                 Assert.NotEqual(0, stream.Length);
+                string s;
 
                 stream.Seek(offset: 0, loc: SeekOrigin.Begin);
 
-                NuGetSettings actualSettings = serializer.Deserialize(stream);
+                using (var reader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 4096, leaveOpen: true))
+                {
+                    s = await reader.ReadToEndAsync();
+                }
+
+                stream.Seek(offset: 0, loc: SeekOrigin.Begin);
+
+                NuGetSettings actualSettings = await serializer.DeserializeAsync(stream);
 
                 Assert.NotSame(expectedSettings, actualSettings);
                 AssertAreEquivalent(expectedSettings, actualSettings);