[Fork] [Fork] [Fork] https://stackoverflow.com/questions/70584260/how-to-split-a-large-json-file-based-on-an-array-property-which-is-deeply-nested | C# Online Compiler

[Fork] [Fork] [Fork] https://stackoverflow.com/questions/70584260/how-to-split-a-large-json-file-based-on-an-array-property-which-is-deeply-nested by dbc_MinLength

//#define DEBUG
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters;
using System.IO;
using System.Data;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Reflection;
using System.Collections.ObjectModel;
using System.Diagnostics;

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;	

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

//using Debug = System.Console;

//https://stackoverflow.com/questions/70584260/how-to-split-a-large-json-file-based-on-an-array-property-which-is-deeply-nested

	public static partial class JsonExtensions
	{
		public static string [] SplitJsonFile(string fileName, string [] splitPath, Func<string, string, int, string, string> nameCreator)
		{
			List<string> fileNames = new List<string>();
			
			var name = Path.GetFileNameWithoutExtension(fileName);
			var ext = Path.GetExtension(fileName);
			var directory = Path.GetDirectoryName(fileName);
			Func<int, TextWriter> createStream = (i) => 
			{
				// Use whatever method you like to generate a name for each fragment.
				var newName = nameCreator(directory, name, i, ext);
				var writer = new StreamWriter(newName, false, Encoding.UTF8);
				fileNames.Add(newName);
				return writer;
			};

			using (var reader = new StreamReader(fileName, Encoding.UTF8))
			{
				JsonExtensions.SplitJson(reader,splitPath, 1, createStream, Formatting.Indented);
			}

			return fileNames.ToArray();
		}
		
        public static void SplitJson(TextReader textReader, IList<string> splitPath, long maxItems, Func<int, TextWriter> createStream, Formatting formatting)
        {
			if (splitPath == null || createStream == null || textReader == null)
				throw new ArgumentNullException();
			if (splitPath.Count < 1 || maxItems < 1)
				throw new ArgumentException();
			using (var reader = new JsonTextReader(textReader))
			{
            	List<JsonWriter> writers = new ();
				List<ParentToken> parentTokens = new ();
				try
				{
					SplitJson(reader, splitPath, 0, maxItems, createStream, formatting, parentTokens, writers);
				}
				finally
				{
					// Make sure files are closed in the event of an exception.
					foreach (IDisposable writer in writers)
						writer?.Dispose();
				}
			}
		}
		
		struct ParentToken
		{
			public ParentToken(JsonToken tokenType, IList<JToken> prefixTokens = default) => (this.TokenType, this._prefixTokens) = (tokenType, prefixTokens);
			readonly IList<JToken> _prefixTokens;
			public JsonToken TokenType { get; }
			public IList<JToken> PrefixTokens => _prefixTokens ?? Array.Empty<JToken>();
		}
		
		static JsonWriter AddWriter(List<JsonWriter> writers, List<ParentToken> parentTokens, Func<int, TextWriter> createStream, Formatting formatting)
		{
			var writer = new JsonTextWriter(createStream(writers.Count)) { Formatting = formatting, AutoCompleteOnClose = false };
			writers.Add(writer);
			foreach (var parent in parentTokens)
			{
				switch (parent.TokenType)
				{
					case JsonToken.StartObject:
						writer.WriteStartObject();
						break;
					case JsonToken.StartArray:
						writer.WriteStartArray();
						break;
					default:
						throw new JsonException();
				}
				for (int i = 0; i < parent.PrefixTokens.Count; i++)
				{
					if (i == parent.PrefixTokens.Count - 1 && parent.PrefixTokens[i] is JProperty property && property.Value.Type == JTokenType.Undefined)
						writer.WritePropertyName(property.Name);
					else
						parent.PrefixTokens[i].WriteTo(writer);
				}
			}
			return writer;
		}
		
		static (JsonWriter, int) GetCurrentWriter(List<JsonWriter> writers, List<ParentToken> parentTokens, Func<int, TextWriter> createStream, Formatting formatting)
			=> writers.Count == 0 ? (AddWriter(writers, parentTokens, createStream, formatting), 0) : (writers[writers.Count-1], writers.Count-1);
		
        static void SplitJson(JsonTextReader reader, IList<string> splitPath, int index, long maxItems, Func<int, TextWriter> createStream, Formatting formatting, List<ParentToken> parentTokens , List<JsonWriter> writers)
        {
			var startTokenType = reader.MoveToContentAndAssert().TokenType;
			var startReaderDepth = reader.Depth;

			var bottom = index >= splitPath.Count;
			
			switch (startTokenType)
			{
				case JsonToken.StartObject:
					{
						(var firstWriter, var firstWriterIndex) = GetCurrentWriter(writers, parentTokens, createStream, formatting);
						bool prefix = true;
						bool doRead = true;
						firstWriter.WriteStartObject();
						var parentToken = new ParentToken(JsonToken.StartObject, new List<JToken>());
						while ((doRead ? reader.ReadToContentAndAssert() : reader.MoveToContentAndAssert()).TokenType != JsonToken.EndObject)
						{
							doRead = true;
							var propertyName = (string)reader.AssertTokenType(JsonToken.PropertyName).Value;
							if (propertyName == splitPath[index])
							{
								if (!prefix)
									throw new JsonException(string.Format("Duplicated property name {0}", propertyName));
								prefix = false;
								
								// Advance reader to value.
								reader.ReadToContentAndAssert();
								
								// Add a token with the current property name but an undefined value.  This indicates an unclosed property.
								firstWriter.WritePropertyName(propertyName);
								parentToken.PrefixTokens.Add(new JProperty(propertyName, JValue.CreateUndefined()));
								
								parentTokens.Add(parentToken);
								
								// SplitJson() leaves the reader positioned ON the end of the token that was read, rather than after.
								SplitJson(reader, splitPath, index + 1, maxItems, createStream, formatting, parentTokens, writers);
								parentTokens.RemoveAt(parentTokens.Count-1);
							}
							else if (prefix)
							{
							 	// JProperty.Load() leaves the reader positioned AFTER the token that was read, rather than at the end.
								var property = JProperty.Load(reader);
								property.WriteTo(firstWriter);
								parentToken.PrefixTokens.Add(property);
								doRead = false;
							}
							else
							{
								var property = JProperty.Load(reader);
								for (int i = firstWriterIndex; i < writers.Count; i++)
								{
									property.WriteTo(writers[i]);
								}
								doRead = false;
							}
						}
						for (int i = firstWriterIndex; i < writers.Count; i++)
						{
							if (prefix)
								// We never found the property
								foreach (var property in parentToken.PrefixTokens)
									property.WriteTo(writers[i]);
							writers[i].WriteEndObject();
						}
					}
					break;
				case JsonToken.StartArray: // Split the array.
					{
						var maxItemsAtDepth = bottom ? maxItems : 1L;
						(var writer, var firstWriterIndex) = GetCurrentWriter(writers, parentTokens, createStream, formatting);
						writer.WriteStartArray();
						long count = 0L;
						while (reader.ReadToContentAndAssert().TokenType != JsonToken.EndArray)
						{
							if (reader.TokenType == JsonToken.Comment || reader.TokenType == JsonToken.None)
								continue;
							if (count >= maxItemsAtDepth)
							{
								writer = AddWriter(writers, parentTokens, createStream, formatting);
								writer.WriteStartArray();
								count = 0L;
							}
							if (bottom)
								// WriteToken() leaves the reader positioned ON the end of the token that was read, rather than after.
								writer.WriteToken(reader);
							else
							{
								parentTokens.Add(new ParentToken(JsonToken.StartArray));
								// SplitJson() leaves the reader positioned ON the end of the token that was read, rather than after.
								SplitJson(reader, splitPath, index, maxItems, createStream, formatting, parentTokens, writers);
								parentTokens.RemoveAt(parentTokens.Count-1);
							}
							count++;
						}
						for (int i = firstWriterIndex; i < writers.Count; i++)
						{
							writers[i].WriteEndArray();
						}
					}
					break;
				default: // null, for instance
					{
						(var writer, var _) = GetCurrentWriter(writers, parentTokens, createStream, formatting);
						writer.WriteToken(reader);
					}
					break;
			}
		}		
	}

	public static partial class JsonExtensions
	{
		public static JsonReader AssertTokenType(this JsonReader reader, JsonToken tokenType) => 
			reader.TokenType == tokenType ? reader : throw new JsonSerializationException(string.Format("Unexpected token {0}, expected {1}", reader.TokenType, tokenType));
		
		public static JsonReader ReadToContentAndAssert(this JsonReader reader) =>
			reader.ReadAndAssert().MoveToContentAndAssert();

		public static JsonReader MoveToContentAndAssert(this JsonReader reader)
		{
			if (reader == null)
				throw new ArgumentNullException();
			if (reader.TokenType == JsonToken.None)       // Skip past beginning of stream.
				reader.ReadAndAssert();
			while (reader.TokenType == JsonToken.Comment) // Skip past comments.
				reader.ReadAndAssert();
			return reader;
		}

		public static JsonReader ReadAndAssert(this JsonReader reader)
		{
			if (reader == null)
				throw new ArgumentNullException();
			if (!reader.Read())
				throw new JsonReaderException("Unexpected end of JSON stream.");
			return reader;
		}
	}


	public static partial class JsonExtensions
	{
		[Conditional("DEBUG")]
		static void DebugWriters(List<JsonWriter> writers, string step)
		{
			Debug.WriteLine($"{step}, there are {writers.Count} writers:");
			for (int i = 0; i < writers.Count; i++)
			{
				var p = writers[i].GetType().GetProperty("Top", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
				Debug.WriteLine($"   writers[{i}].WriteState = {writers[i].WriteState}, writers[{i}].Path = {writers[i].Path}, writers[{i}].Top = {p.GetValue(writers[i])}");
			}
		}
	}

    public class TestClass
    {
		public static void Test()
		{
			TestNestedArray();
			TestQuestion31410187();
		}

		public static void TestNestedArray()
		{
			var obj = new 
			{
				Prefix = "prefix",
				Array = new []
				{
					new
					{
						NestedPrefix = "nested prefix1",
						NestedArray = new [] { "a11", "a12" },
						NestedPostfix = "nested postfix1",
					},
					new
					{
						NestedPrefix = "nested prefix2",
						NestedArray = new [] { "a21" },
						NestedPostfix = "nested postfix2",
					},
				},
				Postfix = "postfix",
			};
			
			var json = JsonConvert.SerializeObject(obj);
			Console.WriteLine(json);
			
			var expectedJson1 = new [] { @"{""Prefix"":""prefix"",""Array"":[{""NestedPrefix"":""nested prefix1"",""NestedArray"":[""a11""],""NestedPostfix"":""nested postfix1""}],""Postfix"":""postfix""}",
										@"{""Prefix"":""prefix"",""Array"":[{""NestedPrefix"":""nested prefix1"",""NestedArray"":[""a12""],""NestedPostfix"":""nested postfix1""}],""Postfix"":""postfix""}",
										@"{""Prefix"":""prefix"",""Array"":[{""NestedPrefix"":""nested prefix2"",""NestedArray"":[""a21""],""NestedPostfix"":""nested postfix2""}],""Postfix"":""postfix""}" };

			TestSplitJson(json, new [] { "Array", "NestedArray" }, expectedJson1);

			var expectedJson2 = new [] {@"{""Prefix"":""prefix"",""Array"":[{""NestedPrefix"":""nested prefix1"",""NestedArray"":[""a11"",""a12""],""NestedPostfix"":""nested postfix1""}],""Postfix"":""postfix""}",
										@"{""Prefix"":""prefix"",""Array"":[{""NestedPrefix"":""nested prefix2"",""NestedArray"":[""a21""],""NestedPostfix"":""nested postfix2""}],""Postfix"":""postfix""}"};
			
			TestSplitJson(json, new [] { "Array" }, expectedJson2);
		}
		
        public static void TestQuestion31410187()
        {
			TestSplitJson(@"{""aa"" : ""b""}", "foo"); // Don't fail if the property wasn't found
			
            string json3 = @"       {
        ""headerName1"": ""headerVal1"",
        ""headerName2"": ""headerVal2"",
        ""headerName3"": [
        ""foo"",    
        {
            ""element1Name1"": ""element1Value1""
        },
        false,
        {
            ""element2Name1"": ""element2Value1""
        },
        {
            ""element3Name1"": ""element3Value1""
        },
        {
            ""element4Name1"": ""element4Value1""
        },
        {
            ""element5Name1"": ""element5Value1""
        },
        {
            ""element6Name1"": ""element6Value1""
        }],
        ""headerNamePost"": ""headerValPost"",
    }";
            string json = @"{
        ""headerName1"": ""headerVal1"",
        ""headerName2"": ""headerVal2"",
        ""headerName3"": [{
            ""element1Name1"": ""element1Value1""
        },
        {
            ""element2Name1"": ""element2Value1""
        },
        {
            ""element3Name1"": ""element3Value1""
        },
        {
            ""element4Name1"": ""element4Value1""
        },
        {
            ""element5Name1"": ""element5Value1""
        },
        {
            ""element6Name1"": ""element6Value1""
        }]
    }";
            TestSplitJson(json, "headerName3");
            TestSplitJson(json3, "headerName3");
        }

        private static void TestSplitJson(string json, string [] splitPath, string [] expectedJson = null)
        {
			Console.WriteLine("Splitting on {0}:", string.Join(",", splitPath));
            var builders = new List<StringBuilder>();
			try
			{
				using (var reader = new StringReader(json))
				{
					JsonExtensions.SplitJson(reader, splitPath, 1, i => { builders.Add(new StringBuilder()); return new StringWriter(builders.Last()); }, Formatting.None);
				}
				Console.WriteLine("Created {0} fragments:", builders.Count);
				foreach (var s in builders.Select(b => b.ToString()))
				{
					Console.WriteLine(s);
				}
		
				if (expectedJson != null)
				{
					Assert.AreEqual(expectedJson.Length, builders.Count);
					for (int i = 0; i < builders.Count; i++)
					{
						Assert.IsTrue(JToken.DeepEquals(JToken.Parse(builders[i].ToString()), JToken.Parse(expectedJson[i])));
					}
				}
			}
			catch (Exception)
			{
				Console.WriteLine("Uncaught exception, incomplete split fragments:");
				foreach (var sb in builders)
					Console.WriteLine(sb);
				throw;
			}
		}
		
        private static void TestSplitJson(string json, string tokenName)
        {
            var builders = new List<StringBuilder>();
			try
			{
				using (var reader = new StringReader(json))
				{
					JsonExtensions.SplitJson(reader, new [] { tokenName }, 2, i => { builders.Add(new StringBuilder()); return new StringWriter(builders.Last()); }, Formatting.Indented);
				}
				foreach (var s in builders.Select(b => b.ToString()))
				{
					Console.WriteLine(s);
				}
			}
			catch (Exception)
			{
				foreach (var sb in builders)
					Console.WriteLine(sb);
				throw;
			}

            AssertCorrect(json, tokenName, builders);
        }

        private static void AssertCorrect(string json, string tokenName, List<StringBuilder> builders)
        {
            var mainToken = JObject.Parse(json);
			// Assert the original and split JSON objects have the same root property names.
            foreach (var s in builders.Select(b => b.ToString()))
            {
                var token = JObject.Parse(s);
                if (!(token.Properties().Select(p => p.Name).SequenceEqual(mainToken.Properties().Select(p => p.Name))))
					throw new InvalidOperationException();
            }
			// Assert that the concatenated sequence of array elements in the split json object(s) equals the sequence of array elements in the original.
            if (mainToken[tokenName] != null)
                if (!(mainToken[tokenName].SequenceEqual(builders.SelectMany(b => JObject.Parse(b.ToString())[tokenName]), new JTokenEqualityComparer())))
					throw new InvalidOperationException();
		}
    }

	public class Program
	{
		public static void Main()
		{
			Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());
			Console.WriteLine("{0} version: {1}", typeof(JsonSerializer).Assembly.GetName().Name,  typeof(JsonSerializer).Assembly.FullName);
			Console.WriteLine();

			try
			{
				TestClass.Test();
			}
			catch (Exception ex)
			{
				Console.WriteLine("Failed with unhandled exception: ");
				Console.WriteLine(ex);
				throw;
			}
		}
		
		public static string GetNetCoreVersion()
		{
			//https://techblog.dorogin.com/how-to-detect-net-core-version-in-runtime-ecd65ad695be
			//
			var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;
			var assemblyPath = assembly.Location.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);
			int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");
			if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)
				return assemblyPath[netCoreAppIndex + 1];
			return null;
		}
	}

​x
 
//#define DEBUG
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters;
using System.IO;
using System.Data;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Reflection;
using System.Collections.ObjectModel;
using System.Diagnostics;
​
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;    
​
using NUnit.Framework; // Throws NUnit.Framework.AssertionException
​
//using Debug = System.Console;
​
//https://stackoverflow.com/questions/70584260/how-to-split-a-large-json-file-based-on-an-array-property-which-is-deeply-nested
​
    public static partial class JsonExtensions
    {
        public static string [] SplitJsonFile(string fileName, string [] splitPath, Func<string, string, int, string, string> nameCreator)
        {
            List<string> fileNames = new List<string>();
            
            var name = Path.GetFileNameWithoutExtension(fileName);
            var ext = Path.GetExtension(fileName);
            var directory = Path.GetDirectoryName(fileName);
            Func<int, TextWriter> createStream = (i) => 
            {
                // Use whatever method you like to generate a name for each fragment.
                var newName = nameCreator(directory, name, i, ext);
                var writer = new StreamWriter(newName, false, Encoding.UTF8);
                fileNames.Add(newName);
                return writer;
            };
​
            using (var reader = new StreamReader(fileName, Encoding.UTF8))
            {
                JsonExtensions.SplitJson(reader,splitPath, 1, createStream, Formatting.Indented);
            }
​
            return fileNames.ToArray();
        }
        
        public static void SplitJson(TextReader textReader, IList<string> splitPath, long maxItems, Func<int, TextWriter> createStream, Formatting formatting)
        {
            if (splitPath == null || createStream == null || textReader == null)
                throw new ArgumentNullException();
            if (splitPath.Count < 1 || maxItems < 1)
                throw new ArgumentException();
            using (var reader = new JsonTextReader(textReader))
            {
                List<JsonWriter> writers = new ();
                List<ParentToken> parentTokens = new ();
                try
                {
                    SplitJson(reader, splitPath, 0, maxItems, createStream, formatting, parentTokens, writers);
                }
                finally
                {
                    // Make sure files are closed in the event of an exception.
                    foreach (IDisposable writer in writers)
                        writer?.Dispose();
                }
            }
        }
        
        struct ParentToken
        {
            public ParentToken(JsonToken tokenType, IList<JToken> prefixTokens = default) => (this.TokenType, this._prefixTokens) = (tokenType, prefixTokens);
            readonly IList<JToken> _prefixTokens;
            public JsonToken TokenType { get; }
            public IList<JToken> PrefixTokens => _prefixTokens ?? Array.Empty<JToken>();
        }
        
        static JsonWriter AddWriter(List<JsonWriter> writers, List<ParentToken> parentTokens, Func<int, TextWriter> createStream, Formatting formatting)
        {
            var writer = new JsonTextWriter(createStream(writers.Count)) { Formatting = formatting, AutoCompleteOnClose = false };
            writers.Add(writer);
            foreach (var parent in parentTokens)
            {
                switch (parent.TokenType)
                {
                    case JsonToken.StartObject:
                        writer.WriteStartObject();
                        break;
                    case JsonToken.StartArray:
                        writer.WriteStartArray();
                        break;
                    default:
                        throw new JsonException();
                }
                for (int i = 0; i < parent.PrefixTokens.Count; i++)
                {
                    if (i == parent.PrefixTokens.Count - 1 && parent.PrefixTokens[i] is JProperty property && property.Value.Type == JTokenType.Undefined)
                        writer.WritePropertyName(property.Name);
                    else
                        parent.PrefixTokens[i].WriteTo(writer);
                }
            }
            return writer;
        }
        
        static (JsonWriter, int) GetCurrentWriter(List<JsonWriter> writers, List<ParentToken> parentTokens, Func<int, TextWriter> createStream, Formatting formatting)
            => writers.Count == 0 ? (AddWriter(writers, parentTokens, createStream, formatting), 0) : (writers[writers.Count-1], writers.Count-1);
        
        static void SplitJson(JsonTextReader reader, IList<string> splitPath, int index, long maxItems, Func<int, TextWriter> createStream, Formatting formatting, List<ParentToken> parentTokens , List<JsonWriter> writers)
        {
            var startTokenType = reader.MoveToContentAndAssert().TokenType;
            var startReaderDepth = reader.Depth;
​
            var bottom = index >= splitPath.Count;
            
            switch (startTokenType)
            {
                case JsonToken.StartObject:
                    {
                        (var firstWriter, var firstWriterIndex) = GetCurrentWriter(writers, parentTokens, createStream, formatting);
                        bool prefix = true;
                        bool doRead = true;
                        firstWriter.WriteStartObject();
                        var parentToken = new ParentToken(JsonToken.StartObject, new List<JToken>());
                        while ((doRead ? reader.ReadToContentAndAssert() : reader.MoveToContentAndAssert()).TokenType != JsonToken.EndObject)
                        {
                            doRead = true;
                            var propertyName = (string)reader.AssertTokenType(JsonToken.PropertyName).Value;
                            if (propertyName == splitPath[index])
                            {
                                if (!prefix)
                                    throw new JsonException(string.Format("Duplicated property name {0}", propertyName));
                                prefix = false;
                                
                                // Advance reader to value.
                                reader.ReadToContentAndAssert();
                                
                                // Add a token with the current property name but an undefined value.  This indicates an unclosed property.
                                firstWriter.WritePropertyName(propertyName);
                                parentToken.PrefixTokens.Add(new JProperty(propertyName, JValue.CreateUndefined()));
                                
                                parentTokens.Add(parentToken);
                                
                                // SplitJson() leaves the reader positioned ON the end of the token that was read, rather than after.
                                SplitJson(reader, splitPath, index + 1, maxItems, createStream, formatting, parentTokens, writers);
                                parentTokens.RemoveAt(parentTokens.Count-1);
                            }
                            else if (prefix)
                            {
                                // JProperty.Load() leaves the reader positioned AFTER the token that was read, rather than at the end.
                                var property = JProperty.Load(reader);
                                property.WriteTo(firstWriter);
                                parentToken.PrefixTokens.Add(property);
                                doRead = false;
                            }
                            else
                            {
                                var property = JProperty.Load(reader);
                                for (int i = firstWriterIndex; i < writers.Count; i++)
                                {
                                    property.WriteTo(writers[i]);
                                }
                                doRead = false;
                            }
                        }
                        for (int i = firstWriterIndex; i < writers.Count; i++)
                        {
                            if (prefix)
                                // We never found the property
                                foreach (var property in parentToken.PrefixTokens)
                                    property.WriteTo(writers[i]);
                            writers[i].WriteEndObject();
                        }
                    }
                    break;
                case JsonToken.StartArray: // Split the array.
                    {
                        var maxItemsAtDepth = bottom ? maxItems : 1L;
                        (var writer, var firstWriterIndex) = GetCurrentWriter(writers, parentTokens, createStream, formatting);
                        writer.WriteStartArray();
                        long count = 0L;
                        while (reader.ReadToContentAndAssert().TokenType != JsonToken.EndArray)
                        {
                            if (reader.TokenType == JsonToken.Comment || reader.TokenType == JsonToken.None)
                                continue;
                            if (count >= maxItemsAtDepth)
                            {
                                writer = AddWriter(writers, parentTokens, createStream, formatting);
                                writer.WriteStartArray();
                                count = 0L;
                            }
                            if (bottom)
                                // WriteToken() leaves the reader positioned ON the end of the token that was read, rather than after.
                                writer.WriteToken(reader);
                            else
                            {
                                parentTokens.Add(new ParentToken(JsonToken.StartArray));
                                // SplitJson() leaves the reader positioned ON the end of the token that was read, rather than after.
                                SplitJson(reader, splitPath, index, maxItems, createStream, formatting, parentTokens, writers);
                                parentTokens.RemoveAt(parentTokens.Count-1);
                            }
                            count++;
                        }
                        for (int i = firstWriterIndex; i < writers.Count; i++)
                        {
                            writers[i].WriteEndArray();
                        }
                    }
                    break;
                default: // null, for instance
                    {
                        (var writer, var _) = GetCurrentWriter(writers, parentTokens, createStream, formatting);
                        writer.WriteToken(reader);
                    }
                    break;
            }
        }       
    }
​
    public static partial class JsonExtensions
    {
        public static JsonReader AssertTokenType(this JsonReader reader, JsonToken tokenType) => 
            reader.TokenType == tokenType ? reader : throw new JsonSerializationException(string.Format("Unexpected token {0}, expected {1}", reader.TokenType, tokenType));
        
        public static JsonReader ReadToContentAndAssert(this JsonReader reader) =>
            reader.ReadAndAssert().MoveToContentAndAssert();
​
        public static JsonReader MoveToContentAndAssert(this JsonReader reader)
        {
            if (reader == null)
                throw new ArgumentNullException();
            if (reader.TokenType == JsonToken.None)       // Skip past beginning of stream.
                reader.ReadAndAssert();
            while (reader.TokenType == JsonToken.Comment) // Skip past comments.
                reader.ReadAndAssert();
            return reader;
        }
​
        public static JsonReader ReadAndAssert(this JsonReader reader)
        {
            if (reader == null)
                throw new ArgumentNullException();
            if (!reader.Read())
                throw new JsonReaderException("Unexpected end of JSON stream.");
            return reader;
        }
    }
​
​
    public static partial class JsonExtensions
    {
        [Conditional("DEBUG")]
        static void DebugWriters(List<JsonWriter> writers, string step)
        {
            Debug.WriteLine($"{step}, there are {writers.Count} writers:");
            for (int i = 0; i < writers.Count; i++)
            {
                var p = writers[i].GetType().GetProperty("Top", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                Debug.WriteLine($"   writers[{i}].WriteState = {writers[i].WriteState}, writers[{i}].Path = {writers[i].Path}, writers[{i}].Top = {p.GetValue(writers[i])}");
            }
        }
    }
​
    public class TestClass
    {
        public static void Test()
        {
            TestNestedArray();
            TestQuestion31410187();
        }
​
        public static void TestNestedArray()
        {
            var obj = new 
            {
                Prefix = "prefix",
                Array = new []
                {
                    new
                    {
                        NestedPrefix = "nested prefix1",
                        NestedArray = new [] { "a11", "a12" },
                        NestedPostfix = "nested postfix1",
                    },
                    new
                    {
                        NestedPrefix = "nested prefix2",
                        NestedArray = new [] { "a21" },
                        NestedPostfix = "nested postfix2",
                    },
                },
                Postfix = "postfix",
            };
            
            var json = JsonConvert.SerializeObject(obj);
            Console.WriteLine(json);
            
            var expectedJson1 = new [] { @"{""Prefix"":""prefix"",""Array"":[{""NestedPrefix"":""nested prefix1"",""NestedArray"":[""a11""],""NestedPostfix"":""nested postfix1""}],""Postfix"":""postfix""}",
                                        @"{""Prefix"":""prefix"",""Array"":[{""NestedPrefix"":""nested prefix1"",""NestedArray"":[""a12""],""NestedPostfix"":""nested postfix1""}],""Postfix"":""postfix""}",
                                        @"{""Prefix"":""prefix"",""Array"":[{""NestedPrefix"":""nested prefix2"",""NestedArray"":[""a21""],""NestedPostfix"":""nested postfix2""}],""Postfix"":""postfix""}" };
​
            TestSplitJson(json, new [] { "Array", "NestedArray" }, expectedJson1);
​
            var expectedJson2 = new [] {@"{""Prefix"":""prefix"",""Array"":[{""NestedPrefix"":""nested prefix1"",""NestedArray"":[""a11"",""a12""],""NestedPostfix"":""nested postfix1""}],""Postfix"":""postfix""}",
                                        @"{""Prefix"":""prefix"",""Array"":[{""NestedPrefix"":""nested prefix2"",""NestedArray"":[""a21""],""NestedPostfix"":""nested postfix2""}],""Postfix"":""postfix""}"};
            
            TestSplitJson(json, new [] { "Array" }, expectedJson2);
        }
        
        public static void TestQuestion31410187()
        {
            TestSplitJson(@"{""aa"" : ""b""}", "foo"); // Don't fail if the property wasn't found
            
            string json3 = @"       {
        ""headerName1"": ""headerVal1"",
        ""headerName2"": ""headerVal2"",
        ""headerName3"": [
        ""foo"",    
        {
            ""element1Name1"": ""element1Value1""
        },
        false,
        {
            ""element2Name1"": ""element2Value1""
        },
        {
            ""element3Name1"": ""element3Value1""
        },
        {
            ""element4Name1"": ""element4Value1""
        },
        {
            ""element5Name1"": ""element5Value1""
        },
        {
            ""element6Name1"": ""element6Value1""
        }],
        ""headerNamePost"": ""headerValPost"",
    }";
            string json = @"{
        ""headerName1"": ""headerVal1"",
        ""headerName2"": ""headerVal2"",
        ""headerName3"": [{
            ""element1Name1"": ""element1Value1""
        },
        {
            ""element2Name1"": ""element2Value1""
        },
        {
            ""element3Name1"": ""element3Value1""
        },
        {
            ""element4Name1"": ""element4Value1""
        },
        {
            ""element5Name1"": ""element5Value1""
        },
        {
            ""element6Name1"": ""element6Value1""
        }]
    }";
            TestSplitJson(json, "headerName3");
            TestSplitJson(json3, "headerName3");
        }
​
        private static void TestSplitJson(string json, string [] splitPath, string [] expectedJson = null)
        {
            Console.WriteLine("Splitting on {0}:", string.Join(",", splitPath));
            var builders = new List<StringBuilder>();
            try
            {
                using (var reader = new StringReader(json))
                {
                    JsonExtensions.SplitJson(reader, splitPath, 1, i => { builders.Add(new StringBuilder()); return new StringWriter(builders.Last()); }, Formatting.None);
                }
                Console.WriteLine("Created {0} fragments:", builders.Count);
                foreach (var s in builders.Select(b => b.ToString()))
                {
                    Console.WriteLine(s);
                }
        
                if (expectedJson != null)
                {
                    Assert.AreEqual(expectedJson.Length, builders.Count);
                    for (int i = 0; i < builders.Count; i++)
                    {
                        Assert.IsTrue(JToken.DeepEquals(JToken.Parse(builders[i].ToString()), JToken.Parse(expectedJson[i])));
                    }
                }
            }
            catch (Exception)
            {
                Console.WriteLine("Uncaught exception, incomplete split fragments:");
                foreach (var sb in builders)
                    Console.WriteLine(sb);
                throw;
            }
        }
        
        private static void TestSplitJson(string json, string tokenName)
        {
            var builders = new List<StringBuilder>();
            try
            {
                using (var reader = new StringReader(json))
                {
                    JsonExtensions.SplitJson(reader, new [] { tokenName }, 2, i => { builders.Add(new StringBuilder()); return new StringWriter(builders.Last()); }, Formatting.Indented);
                }
                foreach (var s in builders.Select(b => b.ToString()))
                {
                    Console.WriteLine(s);
                }
            }
            catch (Exception)
            {
                foreach (var sb in builders)
                    Console.WriteLine(sb);
                throw;
            }
​
            AssertCorrect(json, tokenName, builders);
        }
​
        private static void AssertCorrect(string json, string tokenName, List<StringBuilder> builders)
        {
            var mainToken = JObject.Parse(json);
            // Assert the original and split JSON objects have the same root property names.
            foreach (var s in builders.Select(b => b.ToString()))
            {
                var token = JObject.Parse(s);
                if (!(token.Properties().Select(p => p.Name).SequenceEqual(mainToken.Properties().Select(p => p.Name))))
                    throw new InvalidOperationException();
            }
            // Assert that the concatenated sequence of array elements in the split json object(s) equals the sequence of array elements in the original.
            if (mainToken[tokenName] != null)
                if (!(mainToken[tokenName].SequenceEqual(builders.SelectMany(b => JObject.Parse(b.ToString())[tokenName]), new JTokenEqualityComparer())))
                    throw new InvalidOperationException();
        }
    }
​
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());
            Console.WriteLine("{0} version: {1}", typeof(JsonSerializer).Assembly.GetName().Name,  typeof(JsonSerializer).Assembly.FullName);
            Console.WriteLine();
​
            try
            {
                TestClass.Test();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with unhandled exception: ");
                Console.WriteLine(ex);
                throw;
            }
        }
        
        public static string GetNetCoreVersion()
        {
            //https://techblog.dorogin.com/how-to-detect-net-core-version-in-runtime-ecd65ad695be
            //
            var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;
            var assemblyPath = assembly.Location.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);
            int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");
            if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)
                return assemblyPath[netCoreAppIndex + 1];
            return null;
        }
    }
​

View IL Code