[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] https://stackoverflow.com/questions/70584260/how-to-split-a-large-json-file-based-on-an-array-property-which-is-deeply-nested by dbc_MinLength

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 Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;	

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

//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 class TestClass
    {
        public static void Test()
        {
			var json = @"{
  ""Job"": {
    ""Keys"": {
      ""JobID"": ""test123"",
      ""DeviceID"": ""TEST01""
    },
    ""Props"": {
      ""FileType"": ""Measurements"",
      ""InstrumentDescriptions"": [
        {
          ""InstrumentID"": ""1723007"",
          ""InstrumentType"": ""Actual1"",
          ""Name"": ""U"",
          ""DataType"": ""Double"",
          ""Units"": ""degC""
        },
        {
          ""InstrumentID"": ""2424009"",
          ""InstrumentType"": ""Actual2"",
          ""Name"": ""VG03"",
          ""DataType"": ""Double"",
          ""Units"": ""Pa""
        }
      ]
    },
    ""Steps"": [
      {
        ""Keys"": {
          ""StepID"": ""START"",
          ""StepResult"": ""NormalEnd""
        },
        ""InstrumentData"": [
          {
            ""Keys"": {
              ""InstrumentID"": ""1723007""
            },
            ""Measurements"": [
              {
                ""DateTime"": ""2021-11-16 21:18:37.000"",
                ""Value"": 540
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.100"",
                ""Value"": 539
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.200"",
                ""Value"": 540
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.300"",
                ""Value"": 540
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.400"",
                ""Value"": 540
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.500"",
                ""Value"": 540
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.600"",
                ""Value"": 540
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.700"",
                ""Value"": 538
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.800"",
                ""Value"": 540
              }
            ]
          },
          {
            ""Keys"": {
              ""InstrumentID"": ""2424009""
            },
            ""Measurements"": [
              {
                ""DateTime"": ""2021-11-16 21:18:37.000"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.100"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.200"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.300"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.400"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.500"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.600"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.700"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.800"",
                ""Value"": 1333.22
              }
            ]
          }
        ]
      }
    ]
  }
}";
			TestSplitJson(json, new [] { "Job", "Steps", "InstrumentData" });
			TestSplitJson(json, new [] { "Job", "Steps" });
			TestSplitJson(json, new [] { "Job", "Steps", "InstrumentData", "Measurements" });
        }
		
        private static void TestSplitJson(string json, string [] splitPath)
        {
			var filename = "Question70584260.json";
			
			File.WriteAllText(filename, json);
			
			Console.WriteLine("Splitting on {0}:", string.Join(",", splitPath));

			var fileNames = JsonExtensions.SplitJsonFile(filename, splitPath, 
														 (directory, name, i, ext) => Path.Combine(directory, Path.ChangeExtension(name + $"_fragment_{i}", ext)));
						
			Console.WriteLine("Created {0} fragments:", fileNames.Length);
			
			foreach (var name in fileNames)
			{
				Console.WriteLine("Contents of {0}:", name);
				Console.WriteLine(File.ReadAllText(name));
			}

			File.Delete(filename);
			foreach (var name in fileNames)
				File.Delete(name);

			Console.WriteLine();
        }

        private static void AssertCorrect(string json, string [] splitPath, 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();
            }
		}
    }

	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
 
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 Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;    
​
using NUnit.Framework; // Throws NUnit.Framework.AssertionException
​
//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 class TestClass
    {
        public static void Test()
        {
            var json = @"{
  ""Job"": {
    ""Keys"": {
      ""JobID"": ""test123"",
      ""DeviceID"": ""TEST01""
    },
    ""Props"": {
      ""FileType"": ""Measurements"",
      ""InstrumentDescriptions"": [
        {
          ""InstrumentID"": ""1723007"",
          ""InstrumentType"": ""Actual1"",
          ""Name"": ""U"",
          ""DataType"": ""Double"",
          ""Units"": ""degC""
        },
        {
          ""InstrumentID"": ""2424009"",
          ""InstrumentType"": ""Actual2"",
          ""Name"": ""VG03"",
          ""DataType"": ""Double"",
          ""Units"": ""Pa""
        }
      ]
    },
    ""Steps"": [
      {
        ""Keys"": {
          ""StepID"": ""START"",
          ""StepResult"": ""NormalEnd""
        },
        ""InstrumentData"": [
          {
            ""Keys"": {
              ""InstrumentID"": ""1723007""
            },
            ""Measurements"": [
              {
                ""DateTime"": ""2021-11-16 21:18:37.000"",
                ""Value"": 540
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.100"",
                ""Value"": 539
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.200"",
                ""Value"": 540
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.300"",
                ""Value"": 540
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.400"",
                ""Value"": 540
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.500"",
                ""Value"": 540
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.600"",
                ""Value"": 540
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.700"",
                ""Value"": 538
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.800"",
                ""Value"": 540
              }
            ]
          },
          {
            ""Keys"": {
              ""InstrumentID"": ""2424009""
            },
            ""Measurements"": [
              {
                ""DateTime"": ""2021-11-16 21:18:37.000"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.100"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.200"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.300"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.400"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.500"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.600"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.700"",
                ""Value"": 1333.22
              },
              {
                ""DateTime"": ""2021-11-16 21:18:37.800"",
                ""Value"": 1333.22
              }
            ]
          }
        ]
      }
    ]
  }
}";
            TestSplitJson(json, new [] { "Job", "Steps", "InstrumentData" });
            TestSplitJson(json, new [] { "Job", "Steps" });
            TestSplitJson(json, new [] { "Job", "Steps", "InstrumentData", "Measurements" });
        }
        
        private static void TestSplitJson(string json, string [] splitPath)
        {
            var filename = "Question70584260.json";
            
            File.WriteAllText(filename, json);
            
            Console.WriteLine("Splitting on {0}:", string.Join(",", splitPath));
​
            var fileNames = JsonExtensions.SplitJsonFile(filename, splitPath, 
                                                         (directory, name, i, ext) => Path.Combine(directory, Path.ChangeExtension(name + $"_fragment_{i}", ext)));
                        
            Console.WriteLine("Created {0} fragments:", fileNames.Length);
            
            foreach (var name in fileNames)
            {
                Console.WriteLine("Contents of {0}:", name);
                Console.WriteLine(File.ReadAllText(name));
            }
​
            File.Delete(filename);
            foreach (var name in fileNames)
                File.Delete(name);
​
            Console.WriteLine();
        }
​
        private static void AssertCorrect(string json, string [] splitPath, 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();
            }
        }
    }
​
    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