Adds more write overloads to Utf8Json

Mpdreamz · Mpdreamz · commit de629147c87f · 2019-11-11T12:54:03.000+01:00
Either memory stream or to serialize on the writer.

This consolidates and funnels places that need to write
bytes/streams/objects directly
diff --git a/src/Elasticsearch.Net/Utf8Json/IJsonFormatterResolver.cs b/src/Elasticsearch.Net/Utf8Json/IJsonFormatterResolver.cs
@@ -60,11 +60,10 @@ public static IJsonFormatter<T> GetFormatterWithVerify<T>(this IJsonFormatterRes
             return formatter;
         }
 
+		private static readonly MethodInfo _getFormatterMethod = typeof(IJsonFormatterResolver).GetRuntimeMethod("GetFormatter", Type.EmptyTypes);
         public static object GetFormatterDynamic(this IJsonFormatterResolver resolver, Type type)
         {
-            var methodInfo = typeof(IJsonFormatterResolver).GetRuntimeMethod("GetFormatter", Type.EmptyTypes);
-
-            var formatter = methodInfo.MakeGenericMethod(type).Invoke(resolver, null);
+            var formatter = _getFormatterMethod.MakeGenericMethod(type).Invoke(resolver, null);
             return formatter;
         }
     }
diff --git a/src/Elasticsearch.Net/Utf8Json/Internal/UnsafeMemory.Low.cs b/src/Elasticsearch.Net/Utf8Json/Internal/UnsafeMemory.Low.cs
@@ -35,9 +35,10 @@ internal static class UnsafeMemory
     {
         public static readonly bool Is32Bit = (IntPtr.Size == 4);
 
-        public static void WriteRaw(ref JsonWriter writer, byte[] src)
+        public static void WriteRaw(ref JsonWriter writer, byte[] src) => WriteRaw(ref writer, src, src.Length);
+        public static void WriteRaw(ref JsonWriter writer, byte[] src, int length)
         {
-            switch (src.Length)
+            switch (length)
             {
                 case 0: break;
                 case 1: if (Is32Bit) { UnsafeMemory32.WriteRaw1(ref writer, src); } else { UnsafeMemory64.WriteRaw1(ref writer, src); } break;
@@ -77,19 +78,20 @@ public static void WriteRaw(ref JsonWriter writer, byte[] src)
             }
         }
 
-        public static unsafe void MemoryCopy(ref JsonWriter writer, byte[] src)
+        public static void MemoryCopy(ref JsonWriter writer, byte[] src) => MemoryCopy(ref writer, src, src.Length);
+        public static unsafe void MemoryCopy(ref JsonWriter writer, byte[] src, int length)
         {
-            BinaryUtil.EnsureCapacity(ref writer.buffer, writer.offset, src.Length);
+            BinaryUtil.EnsureCapacity(ref writer.buffer, writer.offset, length);
 #if !NET45
             fixed (void* dstP = &writer.buffer[writer.offset])
             fixed (void* srcP = &src[0])
             {
-                Buffer.MemoryCopy(srcP, dstP, writer.buffer.Length - writer.offset, src.Length);
+                Buffer.MemoryCopy(srcP, dstP, writer.buffer.Length - writer.offset, length);
             }
 #else
-            Buffer.BlockCopy(src, 0, writer.buffer, writer.offset, src.Length);
+            Buffer.BlockCopy(src, 0, writer.buffer, writer.offset, length);
 #endif
-            writer.offset += src.Length;
+            writer.offset += length;
         }
     }
 
diff --git a/src/Elasticsearch.Net/Utf8Json/JsonWriter.cs b/src/Elasticsearch.Net/Utf8Json/JsonWriter.cs
@@ -23,6 +23,7 @@
 #endregion
 
 using System;
+using System.IO;
 using System.Runtime.CompilerServices;
 using System.Text;
 using Elasticsearch.Net.Extensions;
@@ -147,6 +148,27 @@ public void WriteRaw(byte[] rawValue)
             offset += rawValue.Length;
 #endif
         }
+        public void WriteRaw(byte[] rawValue, int length)
+        {
+            UnsafeMemory.WriteRaw(ref this, rawValue, length);
+        }
+        public void WriteRaw(MemoryStream ms)
+		{
+			if (ms.TryGetBuffer(out var b) && !(b.Array is null) && b.Offset == 0)
+				WriteRaw(b.Array, b.Count);
+			else
+			{
+				var bytes = ms.ToArray();
+				this.WriteRaw(bytes);
+			}
+		}
+
+		public void WriteSerialized<T>(T value, IElasticsearchSerializer serializer, IConnectionConfigurationValues settings, SerializationFormatting formatting = SerializationFormatting.None)
+		{
+			using var ms = settings.MemoryStreamFactory.Create();
+			serializer.Serialize(value, ms, formatting);
+			WriteRaw(ms);
+		}
 
 #if NETSTANDARD
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -483,5 +505,6 @@ private static void ToUnicode(char c, ref int offset, byte[] buffer)
 			buffer[offset++] = (byte)CharUtils.HexDigit((c >> 4) & '\x000f');
 			buffer[offset++] = (byte)CharUtils.HexDigit(c & '\x000f');
 		}
+
 	}
 }
diff --git a/src/Elasticsearch.Net/Utf8Json/Resolvers/CompositeResolver.cs b/src/Elasticsearch.Net/Utf8Json/Resolvers/CompositeResolver.cs
@@ -157,7 +157,7 @@ internal abstract class DynamicCompositeResolver : IJsonFormatterResolver
     {
 		private static readonly string ModuleName =  $"{ResolverConfig.Namespace}.DynamicCompositeResolver";
 
-        static readonly DynamicAssembly assembly;
+		static readonly DynamicAssembly assembly;
 
         static DynamicCompositeResolver()
         {
diff --git a/src/Nest/CommonAbstractions/Extensions/TypeExtensions.cs b/src/Nest/CommonAbstractions/Extensions/TypeExtensions.cs
@@ -5,6 +5,7 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Text;
+using Elasticsearch.Net.CrossPlatform;
 
 namespace Nest
 {
@@ -150,5 +151,9 @@ private static bool IsHidingMember(PropertyInfo propertyInfo)
 		}
 
 		internal delegate T ObjectActivator<out T>(params object[] args);
+
+		private static readonly Assembly NestAssembly = typeof(TypeExtensions).Assembly();
+
+		public static bool IsNestType(this Type type) => type.Assembly() == NestAssembly;
 	}
 }
diff --git a/src/Nest/CommonAbstractions/SerializationBehavior/DefaultHighLevelSerializer.cs b/src/Nest/CommonAbstractions/SerializationBehavior/DefaultHighLevelSerializer.cs
@@ -14,25 +14,17 @@ internal class DefaultHighLevelSerializer : IElasticsearchSerializer, IInternalS
 
 		public IJsonFormatterResolver FormatterResolver { get; }
 
-		public T Deserialize<T>(Stream stream)
-		{
-			return JsonSerializer.Deserialize<T>(stream, FormatterResolver);
-		}
-
-		public object Deserialize(Type type, Stream stream)
-		{
-			return JsonSerializer.NonGeneric.Deserialize(type, stream, FormatterResolver);
-		}
-
-		public Task<T> DeserializeAsync<T>(Stream stream, CancellationToken cancellationToken = default)
-		{
-			return JsonSerializer.DeserializeAsync<T>(stream, FormatterResolver);
-		}
-
-		public Task<object> DeserializeAsync(Type type, Stream stream, CancellationToken cancellationToken = default)
-		{
-			return JsonSerializer.NonGeneric.DeserializeAsync(type, stream, FormatterResolver);
-		}
+		public T Deserialize<T>(Stream stream) =>
+			JsonSerializer.Deserialize<T>(stream, FormatterResolver);
+
+		public object Deserialize(Type type, Stream stream) =>
+			JsonSerializer.NonGeneric.Deserialize(type, stream, FormatterResolver);
+
+		public Task<T> DeserializeAsync<T>(Stream stream, CancellationToken cancellationToken = default) =>
+			JsonSerializer.DeserializeAsync<T>(stream, FormatterResolver);
+
+		public Task<object> DeserializeAsync(Type type, Stream stream, CancellationToken cancellationToken = default) =>
+			JsonSerializer.NonGeneric.DeserializeAsync(type, stream, FormatterResolver);
 
 		public virtual void Serialize<T>(T data, Stream writableStream, SerializationFormatting formatting = SerializationFormatting.None) =>
 			JsonSerializer.Serialize(writableStream, data, FormatterResolver);
diff --git a/src/Nest/CommonAbstractions/SerializationBehavior/JsonFormatters/ProxyRequestFormatterBase.cs b/src/Nest/CommonAbstractions/SerializationBehavior/JsonFormatters/ProxyRequestFormatterBase.cs
@@ -37,8 +37,7 @@ public void Serialize(ref JsonWriter writer, TRequestInterface value, IJsonForma
 			using (var ms = settings.MemoryStreamFactory.Create())
 			{
 				untypedDocumentRequest.WriteJson(serializer, ms, SerializationFormatting.None);
-				var v = ms.ToArray();
-				writer.WriteRaw(v);
+				writer.WriteRaw(ms);
 			}
 		}
 	}
diff --git a/src/Nest/CommonAbstractions/SerializationBehavior/JsonFormatters/SourceFormatter.cs b/src/Nest/CommonAbstractions/SerializationBehavior/JsonFormatters/SourceFormatter.cs
@@ -30,23 +30,17 @@ public virtual void Serialize(ref JsonWriter writer, T value, IJsonFormatterReso
 			var settings = formatterResolver.GetConnectionSettings();
 
 			// avoid serialization to bytes when not using custom source serializer
-			if (ReferenceEquals(settings.SourceSerializer, settings.RequestResponseSerializer))
+			if (ReferenceEquals(settings.SourceSerializer, settings.RequestResponseSerializer)
+				|| settings.SourceSerializer is IInternalSerializerWithFormatter s && s.FormatterResolver != null)
 			{
 				formatterResolver.GetFormatter<T>().Serialize(ref writer, value, formatterResolver);
 				return;
 			}
 
 			var sourceSerializer = settings.SourceSerializer;
 			var f = ForceFormatting ?? SerializationFormatting.None;
-			byte[] bytes;
-			using (var ms = settings.MemoryStreamFactory.Create())
-			{
-				sourceSerializer.Serialize(value, ms, f);
-				// TODO: read each byte instead of creating and allocating an array
-				bytes = ms.ToArray();
-			}
 
-			writer.WriteRaw(bytes);
+			writer.WriteSerialized(value, sourceSerializer, settings, f);
 		}
 	}
 }
diff --git a/src/Nest/CommonAbstractions/SerializationBehavior/SourceValueWriteConverter.cs b/src/Nest/CommonAbstractions/SerializationBehavior/SourceValueWriteConverter.cs
@@ -1,4 +1,3 @@
-using Elasticsearch.Net.CrossPlatform;
 using Elasticsearch.Net.Utf8Json;
 
 namespace Nest
@@ -13,8 +12,7 @@ public override void Serialize(ref JsonWriter writer, T value, IJsonFormatterRes
 				return;
 			}
 
-			var nestType = value.GetType().Assembly() == typeof(SourceWriteFormatter<>).Assembly();
-			if (nestType)
+			if (value.GetType().IsNestType())
 				formatterResolver.GetFormatter<T>().Serialize(ref writer, value, formatterResolver);
 			else
 				base.Serialize(ref writer, value, formatterResolver);
diff --git a/src/Nest/Document/Multiple/Bulk/BulkRequestFormatter.cs b/src/Nest/Document/Multiple/Bulk/BulkRequestFormatter.cs
@@ -8,6 +8,8 @@ internal class BulkRequestFormatter : IJsonFormatter<IBulkRequest>
 	{
 		private const byte Newline = (byte)'\n';
 
+		private static SourceWriteFormatter<object> SourceWriter { get; } = new SourceWriteFormatter<object>();
+
 		public IBulkRequest Deserialize(ref JsonReader reader, IJsonFormatterResolver formatterResolver) =>
 			throw new NotSupportedException();
 
@@ -17,16 +19,13 @@ public void Serialize(ref JsonWriter writer, IBulkRequest value, IJsonFormatterR
 				return;
 
 			var settings = formatterResolver.GetConnectionSettings();
-			var memoryStreamFactory = settings.MemoryStreamFactory;
-			var requestResponseSerializer = settings.RequestResponseSerializer;
-			var sourceSerializer = settings.SourceSerializer;
 			var inferrer = settings.Inferrer;
 			var formatter = formatterResolver.GetFormatter<object>();
 
 			for (var index = 0; index < value.Operations.Count; index++)
 			{
 				var op = value.Operations[index];
-				op.Index = op.Index ?? value.Index ?? op.ClrType;
+				op.Index ??= value.Index ?? op.ClrType;
 				if (op.Index.Equals(value.Index)) op.Index = null;
 				op.Id = op.GetIdForOperation(inferrer);
 				op.Routing = op.GetRoutingForOperation(inferrer);
@@ -42,12 +41,7 @@ public void Serialize(ref JsonWriter writer, IBulkRequest value, IJsonFormatterR
 				if (body == null)
 					continue;
 
-				var bodySerializer = op.Operation == "update" || body is ILazyDocument
-					? requestResponseSerializer
-					: sourceSerializer;
-
-				var bodyBytes = bodySerializer.SerializeToBytes(body, memoryStreamFactory, SerializationFormatting.None);
-				writer.WriteRaw(bodyBytes);
+				SourceWriter.Serialize(ref writer, body, formatterResolver);
 				writer.WriteRaw(Newline);
 			}
 		}
diff --git a/src/Nest/Search/MultiSearch/MultiSearchFormatter.cs b/src/Nest/Search/MultiSearch/MultiSearchFormatter.cs
@@ -44,11 +44,9 @@ public void Serialize(ref JsonWriter writer, IMultiSearchRequest value, IJsonFor
 					ignore_unavailable = GetString("ignore_unavailable")
 				};
 
-				var headerBytes = serializer.SerializeToBytes(header, memoryStreamFactory, SerializationFormatting.None);
-				writer.WriteRaw(headerBytes);
+				writer.WriteSerialized(header, serializer, settings, SerializationFormatting.None);
 				writer.WriteRaw(Newline);
-				var bodyBytes = serializer.SerializeToBytes(operation, memoryStreamFactory, SerializationFormatting.None);
-				writer.WriteRaw(bodyBytes);
+				writer.WriteSerialized(operation, serializer, settings, SerializationFormatting.None);
 				writer.WriteRaw(Newline);
 			}
 		}
diff --git a/src/Nest/Search/MultiSearchTemplate/MultiSearchTemplateJsonConverter.cs b/src/Nest/Search/MultiSearchTemplate/MultiSearchTemplateJsonConverter.cs
@@ -44,11 +44,9 @@ string GetString(string key)
 					ignore_unavailable = GetString("ignore_unavailable")
 				};
 
-				var headerBytes = serializer.SerializeToBytes(header, memoryStreamFactory, SerializationFormatting.None);
-				writer.WriteRaw(headerBytes);
+				writer.WriteSerialized(header, serializer, settings, SerializationFormatting.None);
 				writer.WriteRaw(Newline);
-				var bodyBytes = serializer.SerializeToBytes(operation, memoryStreamFactory, SerializationFormatting.None);
-				writer.WriteRaw(bodyBytes);
+				writer.WriteSerialized(operation, serializer, settings, SerializationFormatting.None);
 				writer.WriteRaw(Newline);
 			}
 		}
diff --git a/src/Nest/XPack/MachineLearning/PostJobData/PostJobDataRequest.cs b/src/Nest/XPack/MachineLearning/PostJobData/PostJobDataRequest.cs
@@ -63,14 +63,9 @@ public void Serialize(ref JsonWriter writer, IPostJobDataRequest value, IJsonFor
 
 			var settings = formatterResolver.GetConnectionSettings();
 			var sourceSerializer = settings.SourceSerializer;
-			var memoryStreamFactory = settings.MemoryStreamFactory;
 
 			foreach (var data in value.Data)
-			{
-				var bodyJson = sourceSerializer.SerializeToBytes(data, memoryStreamFactory, SerializationFormatting.None);
-				writer.WriteRaw(bodyJson);
-				writer.WriteRaw(Newline);
-			}
+				writer.WriteSerialized(data, sourceSerializer, settings, SerializationFormatting.None);
 		}
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -60,11 +60,10 @@ public static IJsonFormatter<T> GetFormatterWithVerify<T>(this IJsonFormatterRes`
`60`	`60`	`return formatter;`
`61`	`61`	`}`
`62`	`62`
	`63`	`+ private static readonly MethodInfo _getFormatterMethod = typeof(IJsonFormatterResolver).GetRuntimeMethod("GetFormatter", Type.EmptyTypes);`
`63`	`64`	`public static object GetFormatterDynamic(this IJsonFormatterResolver resolver, Type type)`
`64`	`65`	`{`
`65`		`- var methodInfo = typeof(IJsonFormatterResolver).GetRuntimeMethod("GetFormatter", Type.EmptyTypes);`
`66`		`-`
`67`		`- var formatter = methodInfo.MakeGenericMethod(type).Invoke(resolver, null);`
	`66`	`+ var formatter = _getFormatterMethod.MakeGenericMethod(type).Invoke(resolver, null);`
`68`	`67`	`return formatter;`
`69`	`68`	`}`
`70`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,9 +35,10 @@ internal static class UnsafeMemory`
`35`	`35`	`{`
`36`	`36`	`public static readonly bool Is32Bit = (IntPtr.Size == 4);`
`37`	`37`
`38`		`- public static void WriteRaw(ref JsonWriter writer, byte[] src)`
	`38`	`+ public static void WriteRaw(ref JsonWriter writer, byte[] src) => WriteRaw(ref writer, src, src.Length);`
	`39`	`+ public static void WriteRaw(ref JsonWriter writer, byte[] src, int length)`
`39`	`40`	`{`
`40`		`- switch (src.Length)`
	`41`	`+ switch (length)`
`41`	`42`	`{`
`42`	`43`	`case 0: break;`
`43`	`44`	`case 1: if (Is32Bit) { UnsafeMemory32.WriteRaw1(ref writer, src); } else { UnsafeMemory64.WriteRaw1(ref writer, src); } break;`
`@@ -77,19 +78,20 @@ public static void WriteRaw(ref JsonWriter writer, byte[] src)`
`77`	`78`	`}`
`78`	`79`	`}`
`79`	`80`
`80`		`- public static unsafe void MemoryCopy(ref JsonWriter writer, byte[] src)`
	`81`	`+ public static void MemoryCopy(ref JsonWriter writer, byte[] src) => MemoryCopy(ref writer, src, src.Length);`
	`82`	`+ public static unsafe void MemoryCopy(ref JsonWriter writer, byte[] src, int length)`
`81`	`83`	`{`
`82`		`- BinaryUtil.EnsureCapacity(ref writer.buffer, writer.offset, src.Length);`
	`84`	`+ BinaryUtil.EnsureCapacity(ref writer.buffer, writer.offset, length);`
`83`	`85`	`#if !NET45`
`84`	`86`	`fixed (void* dstP = &writer.buffer[writer.offset])`
`85`	`87`	`fixed (void* srcP = &src[0])`
`86`	`88`	`{`
`87`		`- Buffer.MemoryCopy(srcP, dstP, writer.buffer.Length - writer.offset, src.Length);`
	`89`	`+ Buffer.MemoryCopy(srcP, dstP, writer.buffer.Length - writer.offset, length);`
`88`	`90`	`}`
`89`	`91`	`#else`
`90`		`- Buffer.BlockCopy(src, 0, writer.buffer, writer.offset, src.Length);`
	`92`	`+ Buffer.BlockCopy(src, 0, writer.buffer, writer.offset, length);`
`91`	`93`	`#endif`
`92`		`- writer.offset += src.Length;`
	`94`	`+ writer.offset += length;`
`93`	`95`	`}`
`94`	`96`	`}`
`95`	`97`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ internal abstract class DynamicCompositeResolver : IJsonFormatterResolver`
`157`	`157`	`{`
`158`	`158`	`private static readonly string ModuleName = $"{ResolverConfig.Namespace}.DynamicCompositeResolver";`
`159`	`159`
`160`		`- static readonly DynamicAssembly assembly;`
	`160`	`+ static readonly DynamicAssembly assembly;`
`161`	`161`
`162`	`162`	`static DynamicCompositeResolver()`
`163`	`163`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`using System.Linq.Expressions;`
`6`	`6`	`using System.Reflection;`
`7`	`7`	`using System.Text;`
	`8`	`+using Elasticsearch.Net.CrossPlatform;`
`8`	`9`
`9`	`10`	`namespace Nest`
`10`	`11`	`{`
`@@ -150,5 +151,9 @@ private static bool IsHidingMember(PropertyInfo propertyInfo)`
`150`	`151`	`}`
`151`	`152`
`152`	`153`	`internal delegate T ObjectActivator<out T>(params object[] args);`
	`154`	`+`
	`155`	`+ private static readonly Assembly NestAssembly = typeof(TypeExtensions).Assembly();`
	`156`	`+`
	`157`	`+ public static bool IsNestType(this Type type) => type.Assembly() == NestAssembly;`
`153`	`158`	`}`
`154`	`159`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,8 +37,7 @@ public void Serialize(ref JsonWriter writer, TRequestInterface value, IJsonForma`
`37`	`37`	`using (var ms = settings.MemoryStreamFactory.Create())`
`38`	`38`	`{`
`39`	`39`	`untypedDocumentRequest.WriteJson(serializer, ms, SerializationFormatting.None);`
`40`		`- var v = ms.ToArray();`
`41`		`- writer.WriteRaw(v);`
	`40`	`+ writer.WriteRaw(ms);`
`42`	`41`	`}`
`43`	`42`	`}`
`44`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,23 +30,17 @@ public virtual void Serialize(ref JsonWriter writer, T value, IJsonFormatterReso`
`30`	`30`	`var settings = formatterResolver.GetConnectionSettings();`
`31`	`31`
`32`	`32`	`// avoid serialization to bytes when not using custom source serializer`
`33`		`- if (ReferenceEquals(settings.SourceSerializer, settings.RequestResponseSerializer))`
	`33`	`+ if (ReferenceEquals(settings.SourceSerializer, settings.RequestResponseSerializer)`
	`34`	`+ \|\| settings.SourceSerializer is IInternalSerializerWithFormatter s && s.FormatterResolver != null)`
`34`	`35`	`{`
`35`	`36`	`formatterResolver.GetFormatter<T>().Serialize(ref writer, value, formatterResolver);`
`36`	`37`	`return;`
`37`	`38`	`}`
`38`	`39`
`39`	`40`	`var sourceSerializer = settings.SourceSerializer;`
`40`	`41`	`var f = ForceFormatting ?? SerializationFormatting.None;`
`41`		`- byte[] bytes;`
`42`		`- using (var ms = settings.MemoryStreamFactory.Create())`
`43`		`- {`
`44`		`- sourceSerializer.Serialize(value, ms, f);`
`45`		`- // TODO: read each byte instead of creating and allocating an array`
`46`		`- bytes = ms.ToArray();`
`47`		`- }`
`48`	`42`
`49`		`- writer.WriteRaw(bytes);`
	`43`	`+ writer.WriteSerialized(value, sourceSerializer, settings, f);`
`50`	`44`	`}`
`51`	`45`	`}`
`52`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,11 +44,9 @@ public void Serialize(ref JsonWriter writer, IMultiSearchRequest value, IJsonFor`
`44`	`44`	`ignore_unavailable = GetString("ignore_unavailable")`
`45`	`45`	`};`
`46`	`46`
`47`		`- var headerBytes = serializer.SerializeToBytes(header, memoryStreamFactory, SerializationFormatting.None);`
`48`		`- writer.WriteRaw(headerBytes);`
	`47`	`+ writer.WriteSerialized(header, serializer, settings, SerializationFormatting.None);`
`49`	`48`	`writer.WriteRaw(Newline);`
`50`		`- var bodyBytes = serializer.SerializeToBytes(operation, memoryStreamFactory, SerializationFormatting.None);`
`51`		`- writer.WriteRaw(bodyBytes);`
	`49`	`+ writer.WriteSerialized(operation, serializer, settings, SerializationFormatting.None);`
`52`	`50`	`writer.WriteRaw(Newline);`
`53`	`51`	`}`
`54`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,11 +44,9 @@ string GetString(string key)`
`44`	`44`	`ignore_unavailable = GetString("ignore_unavailable")`
`45`	`45`	`};`
`46`	`46`
`47`		`- var headerBytes = serializer.SerializeToBytes(header, memoryStreamFactory, SerializationFormatting.None);`
`48`		`- writer.WriteRaw(headerBytes);`
	`47`	`+ writer.WriteSerialized(header, serializer, settings, SerializationFormatting.None);`
`49`	`48`	`writer.WriteRaw(Newline);`
`50`		`- var bodyBytes = serializer.SerializeToBytes(operation, memoryStreamFactory, SerializationFormatting.None);`
`51`		`- writer.WriteRaw(bodyBytes);`
	`49`	`+ writer.WriteSerialized(operation, serializer, settings, SerializationFormatting.None);`
`52`	`50`	`writer.WriteRaw(Newline);`
`53`	`51`	`}`
`54`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,14 +63,9 @@ public void Serialize(ref JsonWriter writer, IPostJobDataRequest value, IJsonFor`
`63`	`63`
`64`	`64`	`var settings = formatterResolver.GetConnectionSettings();`
`65`	`65`	`var sourceSerializer = settings.SourceSerializer;`
`66`		`- var memoryStreamFactory = settings.MemoryStreamFactory;`
`67`	`66`
`68`	`67`	`foreach (var data in value.Data)`
`69`		`- {`
`70`		`- var bodyJson = sourceSerializer.SerializeToBytes(data, memoryStreamFactory, SerializationFormatting.None);`
`71`		`- writer.WriteRaw(bodyJson);`
`72`		`- writer.WriteRaw(Newline);`
`73`		`- }`
	`68`	`+ writer.WriteSerialized(data, sourceSerializer, settings, SerializationFormatting.None);`
`74`	`69`	`}`
`75`	`70`	`}`
`76`	`71`	`}`