Review feedback: use base class instead of static helper

Bart Koelman · Bart Koelman · commit 594b533339cc · 2021-09-17T14:45:10.000+02:00
diff --git a/src/JsonApiDotNetCore/Serialization/JsonConverterSupport.cs b/src/JsonApiDotNetCore/Serialization/JsonConverterSupport.cs
diff --git a/src/JsonApiDotNetCore/Serialization/JsonConverters/ResourceObjectConverter.cs b/src/JsonApiDotNetCore/Serialization/JsonConverters/ResourceObjectConverter.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Reflection;
 using System.Text.Json;
-using System.Text.Json.Serialization;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Resources;
@@ -15,7 +14,7 @@ namespace JsonApiDotNetCore.Serialization.JsonConverters
     /// Converts <see cref="ResourceObject" /> to/from JSON.
     /// </summary>
     [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
-    public sealed class ResourceObjectConverter : JsonConverter<ResourceObject>
+    public sealed class ResourceObjectConverter : JsonObjectConverter<ResourceObject>
     {
         private static readonly JsonEncodedText TypeText = JsonEncodedText.Encode("type");
         private static readonly JsonEncodedText IdText = JsonEncodedText.Encode("id");
@@ -72,7 +71,7 @@ public override ResourceObject Read(ref Utf8JsonReader reader, Type typeToConver
                                 {
                                     // Newtonsoft.Json used to auto-convert number to strings, while System.Text.Json does not. This is so likely
                                     // to hit users during upgrade that we special-case for this and produce a helpful error message.
-                                    var jsonElement = JsonConverterSupport.ReadSubTree<JsonElement>(ref reader, options);
+                                    var jsonElement = ReadSubTree<JsonElement>(ref reader, options);
                                     throw new JsonException($"Failed to convert ID '{jsonElement}' of type '{jsonElement.ValueKind}' to type 'String'.");
                                 }
 
@@ -99,17 +98,17 @@ public override ResourceObject Read(ref Utf8JsonReader reader, Type typeToConver
                             }
                             case "relationships":
                             {
-                                resourceObject.Relationships = JsonConverterSupport.ReadSubTree<IDictionary<string, RelationshipObject>>(ref reader, options);
+                                resourceObject.Relationships = ReadSubTree<IDictionary<string, RelationshipObject>>(ref reader, options);
                                 break;
                             }
                             case "links":
                             {
-                                resourceObject.Links = JsonConverterSupport.ReadSubTree<ResourceLinks>(ref reader, options);
+                                resourceObject.Links = ReadSubTree<ResourceLinks>(ref reader, options);
                                 break;
                             }
                             case "meta":
                             {
-                                resourceObject.Meta = JsonConverterSupport.ReadSubTree<IDictionary<string, object>>(ref reader, options);
+                                resourceObject.Meta = ReadSubTree<IDictionary<string, object>>(ref reader, options);
                                 break;
                             }
                             default:
@@ -124,7 +123,7 @@ public override ResourceObject Read(ref Utf8JsonReader reader, Type typeToConver
                 }
             }
 
-            throw JsonConverterSupport.GetEndOfStreamError();
+            throw GetEndOfStreamError();
         }
 
         private static string TryPeekType(ref Utf8JsonReader reader)
@@ -196,7 +195,7 @@ private static IDictionary<string, object> ReadAttributes(ref Utf8JsonReader rea
                                     // Inside a JsonConverter there is no way to know where in the JSON object tree we are. And the serializer
                                     // is unable to provide the correct position either. So we avoid an exception and postpone producing an error
                                     // response to the post-processing phase, by setting a sentinel value.
-                                    var jsonElement = JsonConverterSupport.ReadSubTree<JsonElement>(ref reader, options);
+                                    var jsonElement = ReadSubTree<JsonElement>(ref reader, options);
 
                                     attributeValue = new JsonInvalidAttributeInfo(attributeName, property.PropertyType, jsonElement.ToString(),
                                         jsonElement.ValueKind);
@@ -215,7 +214,7 @@ private static IDictionary<string, object> ReadAttributes(ref Utf8JsonReader rea
                 }
             }
 
-            throw JsonConverterSupport.GetEndOfStreamError();
+            throw GetEndOfStreamError();
         }
 
         /// <summary>
@@ -240,25 +239,25 @@ public override void Write(Utf8JsonWriter writer, ResourceObject value, JsonSeri
             if (!value.Attributes.IsNullOrEmpty())
             {
                 writer.WritePropertyName(AttributesText);
-                JsonConverterSupport.WriteSubTree(writer, value.Attributes, options);
+                WriteSubTree(writer, value.Attributes, options);
             }
 
             if (!value.Relationships.IsNullOrEmpty())
             {
                 writer.WritePropertyName(RelationshipsText);
-                JsonConverterSupport.WriteSubTree(writer, value.Relationships, options);
+                WriteSubTree(writer, value.Relationships, options);
             }
 
             if (value.Links != null && value.Links.HasValue())
             {
                 writer.WritePropertyName(LinksText);
-                JsonConverterSupport.WriteSubTree(writer, value.Links, options);
+                WriteSubTree(writer, value.Links, options);
             }
 
             if (!value.Meta.IsNullOrEmpty())
             {
                 writer.WritePropertyName(MetaText);
-                JsonConverterSupport.WriteSubTree(writer, value.Meta, options);
+                WriteSubTree(writer, value.Meta, options);
             }
 
             writer.WriteEndObject();
diff --git a/src/JsonApiDotNetCore/Serialization/JsonConverters/SingleOrManyDataConverterFactory.cs b/src/JsonApiDotNetCore/Serialization/JsonConverters/SingleOrManyDataConverterFactory.cs
@@ -28,7 +28,7 @@ public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializer
             return (JsonConverter)Activator.CreateInstance(converterType, BindingFlags.Instance | BindingFlags.Public, null, null, null);
         }
 
-        private sealed class SingleOrManyDataConverter<T> : JsonConverter<SingleOrManyData<T>>
+        private sealed class SingleOrManyDataConverter<T> : JsonObjectConverter<SingleOrManyData<T>>
             where T : class, IResourceIdentity
         {
             public override SingleOrManyData<T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions serializerOptions)
@@ -48,7 +48,7 @@ public override SingleOrManyData<T> Read(ref Utf8JsonReader reader, Type typeToC
                         }
                         case JsonTokenType.StartObject:
                         {
-                            var resourceObject = JsonConverterSupport.ReadSubTree<T>(ref reader, serializerOptions);
+                            var resourceObject = ReadSubTree<T>(ref reader, serializerOptions);
                             objects.Add(resourceObject);
                             break;
                         }
@@ -67,7 +67,7 @@ public override SingleOrManyData<T> Read(ref Utf8JsonReader reader, Type typeToC
 
             public override void Write(Utf8JsonWriter writer, SingleOrManyData<T> value, JsonSerializerOptions options)
             {
-                JsonConverterSupport.WriteSubTree(writer, value.Value, options);
+                WriteSubTree(writer, value.Value, options);
             }
         }
     }
diff --git a/src/JsonApiDotNetCore/Serialization/JsonConverters/WriteOnlyDocumentConverter.cs b/src/JsonApiDotNetCore/Serialization/JsonConverters/WriteOnlyDocumentConverter.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Text.Json;
-using System.Text.Json.Serialization;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Serialization.Objects;
 
@@ -10,7 +9,7 @@ namespace JsonApiDotNetCore.Serialization.JsonConverters
     /// Converts <see cref="Document" /> to JSON.
     /// </summary>
     [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
-    public sealed class WriteOnlyDocumentConverter : JsonConverter<Document>
+    public sealed class WriteOnlyDocumentConverter : JsonObjectConverter<Document>
     {
         private static readonly JsonEncodedText JsonApiText = JsonEncodedText.Encode("jsonapi");
         private static readonly JsonEncodedText LinksText = JsonEncodedText.Encode("links");
@@ -36,49 +35,49 @@ public override void Write(Utf8JsonWriter writer, Document value, JsonSerializer
             if (value.JsonApi != null)
             {
                 writer.WritePropertyName(JsonApiText);
-                JsonConverterSupport.WriteSubTree(writer, value.JsonApi, options);
+                WriteSubTree(writer, value.JsonApi, options);
             }
 
             if (value.Links != null && value.Links.HasValue())
             {
                 writer.WritePropertyName(LinksText);
-                JsonConverterSupport.WriteSubTree(writer, value.Links, options);
+                WriteSubTree(writer, value.Links, options);
             }
 
             if (value.Data.IsAssigned)
             {
                 writer.WritePropertyName(DataText);
-                JsonConverterSupport.WriteSubTree(writer, value.Data, options);
+                WriteSubTree(writer, value.Data, options);
             }
 
             if (!value.Operations.IsNullOrEmpty())
             {
                 writer.WritePropertyName(AtomicOperationsText);
-                JsonConverterSupport.WriteSubTree(writer, value.Operations, options);
+                WriteSubTree(writer, value.Operations, options);
             }
 
             if (!value.Results.IsNullOrEmpty())
             {
                 writer.WritePropertyName(AtomicResultsText);
-                JsonConverterSupport.WriteSubTree(writer, value.Results, options);
+                WriteSubTree(writer, value.Results, options);
             }
 
             if (!value.Errors.IsNullOrEmpty())
             {
                 writer.WritePropertyName(ErrorsText);
-                JsonConverterSupport.WriteSubTree(writer, value.Errors, options);
+                WriteSubTree(writer, value.Errors, options);
             }
 
             if (value.Included != null)
             {
                 writer.WritePropertyName(IncludedText);
-                JsonConverterSupport.WriteSubTree(writer, value.Included, options);
+                WriteSubTree(writer, value.Included, options);
             }
 
             if (!value.Meta.IsNullOrEmpty())
             {
                 writer.WritePropertyName(MetaText);
-                JsonConverterSupport.WriteSubTree(writer, value.Meta, options);
+                WriteSubTree(writer, value.Meta, options);
             }
 
             writer.WriteEndObject();
diff --git a/src/JsonApiDotNetCore/Serialization/JsonConverters/WriteOnlyRelationshipObjectConverter.cs b/src/JsonApiDotNetCore/Serialization/JsonConverters/WriteOnlyRelationshipObjectConverter.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Text.Json;
-using System.Text.Json.Serialization;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Serialization.Objects;
 
@@ -10,7 +9,7 @@ namespace JsonApiDotNetCore.Serialization.JsonConverters
     /// Converts <see cref="RelationshipObject" /> to JSON.
     /// </summary>
     [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
-    public sealed class WriteOnlyRelationshipObjectConverter : JsonConverter<RelationshipObject>
+    public sealed class WriteOnlyRelationshipObjectConverter : JsonObjectConverter<RelationshipObject>
     {
         private static readonly JsonEncodedText DataText = JsonEncodedText.Encode("data");
         private static readonly JsonEncodedText LinksText = JsonEncodedText.Encode("links");
@@ -31,19 +30,19 @@ public override void Write(Utf8JsonWriter writer, RelationshipObject value, Json
             if (value.Links != null && value.Links.HasValue())
             {
                 writer.WritePropertyName(LinksText);
-                JsonConverterSupport.WriteSubTree(writer, value.Links, options);
+                WriteSubTree(writer, value.Links, options);
             }
 
             if (value.Data.IsAssigned)
             {
                 writer.WritePropertyName(DataText);
-                JsonConverterSupport.WriteSubTree(writer, value.Data, options);
+                WriteSubTree(writer, value.Data, options);
             }
 
             if (!value.Meta.IsNullOrEmpty())
             {
                 writer.WritePropertyName(MetaText);
-                JsonConverterSupport.WriteSubTree(writer, value.Meta, options);
+                WriteSubTree(writer, value.Meta, options);
             }
 
             writer.WriteEndObject();
diff --git a/src/JsonApiDotNetCore/Serialization/JsonObjectConverter.cs b/src/JsonApiDotNetCore/Serialization/JsonObjectConverter.cs
@@ -0,0 +1,35 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace JsonApiDotNetCore.Serialization
+{
+    public abstract class JsonObjectConverter<TObject> : JsonConverter<TObject>
+    {
+        protected static TValue ReadSubTree<TValue>(ref Utf8JsonReader reader, JsonSerializerOptions options)
+        {
+            if (typeof(TValue) != typeof(object) && options?.GetConverter(typeof(TValue)) is JsonConverter<TValue> converter)
+            {
+                return converter.Read(ref reader, typeof(TValue), options);
+            }
+
+            return JsonSerializer.Deserialize<TValue>(ref reader, options);
+        }
+
+        protected static void WriteSubTree<TValue>(Utf8JsonWriter writer, TValue value, JsonSerializerOptions options)
+        {
+            if (typeof(TValue) != typeof(object) && options?.GetConverter(typeof(TValue)) is JsonConverter<TValue> converter)
+            {
+                converter.Write(writer, value, options);
+            }
+            else
+            {
+                JsonSerializer.Serialize(writer, value, options);
+            }
+        }
+
+        protected static JsonException GetEndOfStreamError()
+        {
+            return new JsonException("Unexpected end of JSON stream.");
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@`
`2`	`2`	`using System.Collections.Generic;`
`3`	`3`	`using System.Reflection;`
`4`	`4`	`using System.Text.Json;`
`5`		`-using System.Text.Json.Serialization;`
`6`	`5`	`using JetBrains.Annotations;`
`7`	`6`	`using JsonApiDotNetCore.Configuration;`
`8`	`7`	`using JsonApiDotNetCore.Resources;`
`@@ -15,7 +14,7 @@ namespace JsonApiDotNetCore.Serialization.JsonConverters`
`15`	`14`	`/// Converts <see cref="ResourceObject" /> to/from JSON.`
`16`	`15`	`/// </summary>`
`17`	`16`	`[UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]`
`18`		`- public sealed class ResourceObjectConverter : JsonConverter<ResourceObject>`
	`17`	`+ public sealed class ResourceObjectConverter : JsonObjectConverter<ResourceObject>`
`19`	`18`	`{`
`20`	`19`	`private static readonly JsonEncodedText TypeText = JsonEncodedText.Encode("type");`
`21`	`20`	`private static readonly JsonEncodedText IdText = JsonEncodedText.Encode("id");`
`@@ -72,7 +71,7 @@ public override ResourceObject Read(ref Utf8JsonReader reader, Type typeToConver`
`72`	`71`	`{`
`73`	`72`	`// Newtonsoft.Json used to auto-convert number to strings, while System.Text.Json does not. This is so likely`
`74`	`73`	`// to hit users during upgrade that we special-case for this and produce a helpful error message.`
`75`		`- var jsonElement = JsonConverterSupport.ReadSubTree<JsonElement>(ref reader, options);`
	`74`	`+ var jsonElement = ReadSubTree<JsonElement>(ref reader, options);`
`76`	`75`	`throw new JsonException($"Failed to convert ID '{jsonElement}' of type '{jsonElement.ValueKind}' to type 'String'.");`
`77`	`76`	`}`
`78`	`77`
`@@ -99,17 +98,17 @@ public override ResourceObject Read(ref Utf8JsonReader reader, Type typeToConver`
`99`	`98`	`}`
`100`	`99`	`case "relationships":`
`101`	`100`	`{`
`102`		`- resourceObject.Relationships = JsonConverterSupport.ReadSubTree<IDictionary<string, RelationshipObject>>(ref reader, options);`
	`101`	`+ resourceObject.Relationships = ReadSubTree<IDictionary<string, RelationshipObject>>(ref reader, options);`
`103`	`102`	`break;`
`104`	`103`	`}`
`105`	`104`	`case "links":`
`106`	`105`	`{`
`107`		`- resourceObject.Links = JsonConverterSupport.ReadSubTree<ResourceLinks>(ref reader, options);`
	`106`	`+ resourceObject.Links = ReadSubTree<ResourceLinks>(ref reader, options);`
`108`	`107`	`break;`
`109`	`108`	`}`
`110`	`109`	`case "meta":`
`111`	`110`	`{`
`112`		`- resourceObject.Meta = JsonConverterSupport.ReadSubTree<IDictionary<string, object>>(ref reader, options);`
	`111`	`+ resourceObject.Meta = ReadSubTree<IDictionary<string, object>>(ref reader, options);`
`113`	`112`	`break;`
`114`	`113`	`}`
`115`	`114`	`default:`
`@@ -124,7 +123,7 @@ public override ResourceObject Read(ref Utf8JsonReader reader, Type typeToConver`
`124`	`123`	`}`
`125`	`124`	`}`
`126`	`125`
`127`		`- throw JsonConverterSupport.GetEndOfStreamError();`
	`126`	`+ throw GetEndOfStreamError();`
`128`	`127`	`}`
`129`	`128`
`130`	`129`	`private static string TryPeekType(ref Utf8JsonReader reader)`
`@@ -196,7 +195,7 @@ private static IDictionary<string, object> ReadAttributes(ref Utf8JsonReader rea`
`196`	`195`	`// Inside a JsonConverter there is no way to know where in the JSON object tree we are. And the serializer`
`197`	`196`	`// is unable to provide the correct position either. So we avoid an exception and postpone producing an error`
`198`	`197`	`// response to the post-processing phase, by setting a sentinel value.`
`199`		`- var jsonElement = JsonConverterSupport.ReadSubTree<JsonElement>(ref reader, options);`
	`198`	`+ var jsonElement = ReadSubTree<JsonElement>(ref reader, options);`
`200`	`199`
`201`	`200`	`attributeValue = new JsonInvalidAttributeInfo(attributeName, property.PropertyType, jsonElement.ToString(),`
`202`	`201`	`jsonElement.ValueKind);`
`@@ -215,7 +214,7 @@ private static IDictionary<string, object> ReadAttributes(ref Utf8JsonReader rea`
`215`	`214`	`}`
`216`	`215`	`}`
`217`	`216`
`218`		`- throw JsonConverterSupport.GetEndOfStreamError();`
	`217`	`+ throw GetEndOfStreamError();`
`219`	`218`	`}`
`220`	`219`
`221`	`220`	`/// <summary>`
`@@ -240,25 +239,25 @@ public override void Write(Utf8JsonWriter writer, ResourceObject value, JsonSeri`
`240`	`239`	`if (!value.Attributes.IsNullOrEmpty())`
`241`	`240`	`{`
`242`	`241`	`writer.WritePropertyName(AttributesText);`
`243`		`- JsonConverterSupport.WriteSubTree(writer, value.Attributes, options);`
	`242`	`+ WriteSubTree(writer, value.Attributes, options);`
`244`	`243`	`}`
`245`	`244`
`246`	`245`	`if (!value.Relationships.IsNullOrEmpty())`
`247`	`246`	`{`
`248`	`247`	`writer.WritePropertyName(RelationshipsText);`
`249`		`- JsonConverterSupport.WriteSubTree(writer, value.Relationships, options);`
	`248`	`+ WriteSubTree(writer, value.Relationships, options);`
`250`	`249`	`}`
`251`	`250`
`252`	`251`	`if (value.Links != null && value.Links.HasValue())`
`253`	`252`	`{`
`254`	`253`	`writer.WritePropertyName(LinksText);`
`255`		`- JsonConverterSupport.WriteSubTree(writer, value.Links, options);`
	`254`	`+ WriteSubTree(writer, value.Links, options);`
`256`	`255`	`}`
`257`	`256`
`258`	`257`	`if (!value.Meta.IsNullOrEmpty())`
`259`	`258`	`{`
`260`	`259`	`writer.WritePropertyName(MetaText);`
`261`		`- JsonConverterSupport.WriteSubTree(writer, value.Meta, options);`
	`260`	`+ WriteSubTree(writer, value.Meta, options);`
`262`	`261`	`}`
`263`	`262`
`264`	`263`	`writer.WriteEndObject();`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializer`
`28`	`28`	`return (JsonConverter)Activator.CreateInstance(converterType, BindingFlags.Instance \| BindingFlags.Public, null, null, null);`
`29`	`29`	`}`
`30`	`30`
`31`		`- private sealed class SingleOrManyDataConverter<T> : JsonConverter<SingleOrManyData<T>>`
	`31`	`+ private sealed class SingleOrManyDataConverter<T> : JsonObjectConverter<SingleOrManyData<T>>`
`32`	`32`	`where T : class, IResourceIdentity`
`33`	`33`	`{`
`34`	`34`	`public override SingleOrManyData<T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions serializerOptions)`
`@@ -48,7 +48,7 @@ public override SingleOrManyData<T> Read(ref Utf8JsonReader reader, Type typeToC`
`48`	`48`	`}`
`49`	`49`	`case JsonTokenType.StartObject:`
`50`	`50`	`{`
`51`		`- var resourceObject = JsonConverterSupport.ReadSubTree<T>(ref reader, serializerOptions);`
	`51`	`+ var resourceObject = ReadSubTree<T>(ref reader, serializerOptions);`
`52`	`52`	`objects.Add(resourceObject);`
`53`	`53`	`break;`
`54`	`54`	`}`
`@@ -67,7 +67,7 @@ public override SingleOrManyData<T> Read(ref Utf8JsonReader reader, Type typeToC`
`67`	`67`
`68`	`68`	`public override void Write(Utf8JsonWriter writer, SingleOrManyData<T> value, JsonSerializerOptions options)`
`69`	`69`	`{`
`70`		`- JsonConverterSupport.WriteSubTree(writer, value.Value, options);`
	`70`	`+ WriteSubTree(writer, value.Value, options);`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Text.Json;`
`3`		`-using System.Text.Json.Serialization;`
`4`	`3`	`using JetBrains.Annotations;`
`5`	`4`	`using JsonApiDotNetCore.Serialization.Objects;`
`6`	`5`
`@@ -10,7 +9,7 @@ namespace JsonApiDotNetCore.Serialization.JsonConverters`
`10`	`9`	`/// Converts <see cref="Document" /> to JSON.`
`11`	`10`	`/// </summary>`
`12`	`11`	`[UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]`
`13`		`- public sealed class WriteOnlyDocumentConverter : JsonConverter<Document>`
	`12`	`+ public sealed class WriteOnlyDocumentConverter : JsonObjectConverter<Document>`
`14`	`13`	`{`
`15`	`14`	`private static readonly JsonEncodedText JsonApiText = JsonEncodedText.Encode("jsonapi");`
`16`	`15`	`private static readonly JsonEncodedText LinksText = JsonEncodedText.Encode("links");`
`@@ -36,49 +35,49 @@ public override void Write(Utf8JsonWriter writer, Document value, JsonSerializer`
`36`	`35`	`if (value.JsonApi != null)`
`37`	`36`	`{`
`38`	`37`	`writer.WritePropertyName(JsonApiText);`
`39`		`- JsonConverterSupport.WriteSubTree(writer, value.JsonApi, options);`
	`38`	`+ WriteSubTree(writer, value.JsonApi, options);`
`40`	`39`	`}`
`41`	`40`
`42`	`41`	`if (value.Links != null && value.Links.HasValue())`
`43`	`42`	`{`
`44`	`43`	`writer.WritePropertyName(LinksText);`
`45`		`- JsonConverterSupport.WriteSubTree(writer, value.Links, options);`
	`44`	`+ WriteSubTree(writer, value.Links, options);`
`46`	`45`	`}`
`47`	`46`
`48`	`47`	`if (value.Data.IsAssigned)`
`49`	`48`	`{`
`50`	`49`	`writer.WritePropertyName(DataText);`
`51`		`- JsonConverterSupport.WriteSubTree(writer, value.Data, options);`
	`50`	`+ WriteSubTree(writer, value.Data, options);`
`52`	`51`	`}`
`53`	`52`
`54`	`53`	`if (!value.Operations.IsNullOrEmpty())`
`55`	`54`	`{`
`56`	`55`	`writer.WritePropertyName(AtomicOperationsText);`
`57`		`- JsonConverterSupport.WriteSubTree(writer, value.Operations, options);`
	`56`	`+ WriteSubTree(writer, value.Operations, options);`
`58`	`57`	`}`
`59`	`58`
`60`	`59`	`if (!value.Results.IsNullOrEmpty())`
`61`	`60`	`{`
`62`	`61`	`writer.WritePropertyName(AtomicResultsText);`
`63`		`- JsonConverterSupport.WriteSubTree(writer, value.Results, options);`
	`62`	`+ WriteSubTree(writer, value.Results, options);`
`64`	`63`	`}`
`65`	`64`
`66`	`65`	`if (!value.Errors.IsNullOrEmpty())`
`67`	`66`	`{`
`68`	`67`	`writer.WritePropertyName(ErrorsText);`
`69`		`- JsonConverterSupport.WriteSubTree(writer, value.Errors, options);`
	`68`	`+ WriteSubTree(writer, value.Errors, options);`
`70`	`69`	`}`
`71`	`70`
`72`	`71`	`if (value.Included != null)`
`73`	`72`	`{`
`74`	`73`	`writer.WritePropertyName(IncludedText);`
`75`		`- JsonConverterSupport.WriteSubTree(writer, value.Included, options);`
	`74`	`+ WriteSubTree(writer, value.Included, options);`
`76`	`75`	`}`
`77`	`76`
`78`	`77`	`if (!value.Meta.IsNullOrEmpty())`
`79`	`78`	`{`
`80`	`79`	`writer.WritePropertyName(MetaText);`
`81`		`- JsonConverterSupport.WriteSubTree(writer, value.Meta, options);`
	`80`	`+ WriteSubTree(writer, value.Meta, options);`
`82`	`81`	`}`
`83`	`82`
`84`	`83`	`writer.WriteEndObject();`