[Fork] https://stackoverflow.com/questions/72352865/serialize-list-of-objects-with-string-properties-to-json-array-of-objects

CSharp · Console

/Program.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Data;
using System.Globalization;
using System.Reflection;

using System.Drawing;

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/72352865/serialize-list-of-objects-with-string-properties-to-json-array-of-objects

	public class RootObject
	{
		public Property Properties { get; set; }
	}

	public class Property
	{
		public string MyFirstProp { get; set; }
		public string MySecondProp {get; set; }
	}

	public class ObjectAsObjectArrayConverter<TObject> : JsonConverter<TObject>
	{
		public override void WriteJson(JsonWriter writer, TObject value, JsonSerializer serializer)
		{
			var contract = (serializer.ContractResolver.ResolveContract(value.GetType()) as JsonObjectContract) ?? throw new ArgumentException("Wrong contract type");
			writer.WriteStartArray();
            foreach (var property in contract.Properties.Where(p => ShouldSerialize(p, value)))
            {
                var propertyValue = property.ValueProvider.GetValue(value);
                if (propertyValue == null && (serializer.NullValueHandling == NullValueHandling.Ignore || property.NullValueHandling == NullValueHandling.Ignore))
                    continue;
				writer.WriteStartObject();
				writer.WritePropertyName(property.PropertyName);
				if (propertyValue == null)
					writer.WriteNull();
				else if (property.Converter != null && property.Converter.CanWrite)
					property.Converter.WriteJson(writer, propertyValue, serializer);
				else
					serializer.Serialize(writer, propertyValue);
				writer.WriteEndObject();
			}
			writer.WriteEndArray();
		}

        protected virtual bool ShouldSerialize(JsonProperty property, object value) =>
            property.Readable && !property.Ignored && (property.ShouldSerialize == null || property.ShouldSerialize(value));

		public override TObject ReadJson(JsonReader reader, Type objectType, TObject existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			if (existingValue == null)
				existingValue = (TObject)serializer.ContractResolver.ResolveContract(objectType).DefaultCreator();

			switch (reader.MoveToContentAndAssert().TokenType)
			{
				case JsonToken.Null:
					return (TObject)(object)null;
			
				case JsonToken.StartArray:
					while (reader.ReadToContentAndAssert().TokenType != JsonToken.EndArray)
					{
						switch (reader.TokenType)
						{
							case JsonToken.StartObject:
								serializer.Populate(reader, existingValue);
								break;
							default:
								throw new JsonSerializationException("Unexpected token type " + reader.TokenType.ToString());
						}
					}
					break;

				case JsonToken.StartObject:
					serializer.Populate(reader, existingValue);
					break;

				default:
					throw new JsonSerializationException("Unexpected token type " + reader.TokenType.ToString());
			}
			return existingValue;
		}
	}
	
	public static partial class JsonExtensions
	{
		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;
		}
	}

    class TestClass
    {
        public static void Test()
        {
			var myClass = new RootObject
			{
				Properties = new ()
				{
					MyFirstProp = "Hello",
					MySecondProp = "World",
				},
			};

			var settings = new JsonSerializerSettings
			{
				Converters = { new ObjectAsObjectArrayConverter<Property>() },
			};
			var json = JsonConvert.SerializeObject(myClass, Formatting.Indented, settings);
			
			Console.WriteLine(json);
			
			var myClass2 = JsonConvert.DeserializeObject<RootObject>(json, settings);
			
			Assert.AreEqual(myClass?.Properties?.MyFirstProp, myClass2?.Properties?.MyFirstProp);
			Assert.AreEqual(myClass?.Properties?.MySecondProp, myClass2?.Properties?.MySecondProp);
		}	
	}

	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;
		}
	}