https://stackoverflow.com/questions/76119552/how-can-i-parse-a-json-into-a-dynamic-object-allowing-access-to-fields-via-dot-n

CSharp · Console

/Program.cs

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.Threading.Tasks;
using System.Net.Http;
using Microsoft.CodeAnalysis.CSharp.Scripting;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Scripting;
using Microsoft.CSharp.RuntimeBinder;
using System.Dynamic;

using System.Text.Json;
using System.Text.Json.Serialization;

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

//https://stackoverflow.com/questions/76119552/how-can-i-parse-a-json-into-a-dynamic-object-allowing-access-to-fields-via-dot-n

	public class EvaluationContext { public dynamic Payload { get; set; } }

	public class TestClass
	{
		public async Task Should_Evaluate_Dynamic_Payload_Using_SystemTextJson()
		{
			// Arrange
			const string jsonPayload = """
			{
				"dog": {
					"name": "Slayer"
				}
			}
			""";
				
			var jsonOptions = new JsonSerializerOptions
			{
				Converters = { new ObjectAsPrimitiveConverter(objectFormat : ObjectFormat.Expando, // Use ObjectFormat.Expando to enable dynamic evaluation
															  floatFormat : FloatFormat.Double, unknownNumberFormat : UnknownNumberFormat.Error) },
				WriteIndented = true,
			};
			var evaluationContext = new EvaluationContext
			{
				Payload = JsonSerializer.Deserialize<dynamic>(jsonPayload, jsonOptions),
			};

			const string expression = @"Payload.dog.name == ""Slayer""";

			var options = ScriptOptions.Default;
			options = options.AddReferences(typeof(CSharpArgumentInfo).Assembly);
			var script = CSharpScript.Create<bool>(expression, options, globalsType: typeof(EvaluationContext));
			var scriptRunner = script.CreateDelegate();

			// Act
			var result = await scriptRunner(evaluationContext);

			// Assert
			Assert.AreEqual(true, result);

			Console.WriteLine("Result = {0}", result);
			string name = ((dynamic)evaluationContext.Payload).dog.name;
			Console.WriteLine(name);
		}		
	}

	// Copied from this answer https://stackoverflow.com/a/65974452/3744182
	// To https://stackoverflow.com/questions/65972825/c-sharp-deserializing-nested-json-to-nested-dictionarystring-object
	public class ObjectAsPrimitiveConverter : JsonConverter<object>
	{
		FloatFormat FloatFormat { get; init; }
		UnknownNumberFormat UnknownNumberFormat { get; init; }
		ObjectFormat ObjectFormat { get; init; }

		public ObjectAsPrimitiveConverter() : this(FloatFormat.Double, UnknownNumberFormat.Error, ObjectFormat.Expando) { }
		public ObjectAsPrimitiveConverter(FloatFormat floatFormat, UnknownNumberFormat unknownNumberFormat, ObjectFormat objectFormat)
		{
			this.FloatFormat = floatFormat;
			this.UnknownNumberFormat = unknownNumberFormat;
			this.ObjectFormat = objectFormat;
		}

		public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
		{
			if (value.GetType() == typeof(object))
			{
				writer.WriteStartObject();
				writer.WriteEndObject();
			}
			else
			{
				JsonSerializer.Serialize(writer, value, value.GetType(), options);
			}
		}

		public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
		{
			switch (reader.TokenType)
			{
				case JsonTokenType.Null:
					return null;
				case JsonTokenType.False:
					return false;
				case JsonTokenType.True:
					return true;
				case JsonTokenType.String:
					return reader.GetString();
				case JsonTokenType.Number:
				{
					if (reader.TryGetInt32(out var i))
						return i;
					if (reader.TryGetInt64(out var l))
						return l;
					// BigInteger could be added here.
					if (FloatFormat == FloatFormat.Decimal && reader.TryGetDecimal(out var m))
						return m;
					else if (FloatFormat == FloatFormat.Double && reader.TryGetDouble(out var d))
						return d;
					using var doc = JsonDocument.ParseValue(ref reader);
					if (UnknownNumberFormat == UnknownNumberFormat.JsonElement)
						return doc.RootElement.Clone();
					throw new JsonException(string.Format("Cannot parse number {0}", doc.RootElement.ToString()));
				}
				case JsonTokenType.StartArray:
				{
					var list = new List<object>();
					while (reader.Read())
					{
						switch (reader.TokenType)
						{
							default:
								list.Add(Read(ref reader, typeof(object), options));
								break;
							case JsonTokenType.EndArray:
								return list;
						}
					}
					throw new JsonException();
				}
				case JsonTokenType.StartObject:
					var dict = CreateDictionary();
					while (reader.Read())
					{
						switch (reader.TokenType)
						{
							case JsonTokenType.EndObject:
								return dict;
							case JsonTokenType.PropertyName:
								var key = reader.GetString();
								reader.Read();
								dict.Add(key, Read(ref reader, typeof(object), options));
								break;
							default:
								throw new JsonException();
						}
					}
					throw new JsonException();
				default:
					throw new JsonException(string.Format("Unknown token {0}", reader.TokenType));
			}
		}

		protected virtual IDictionary<string, object> CreateDictionary() => 
			ObjectFormat == ObjectFormat.Expando ? new ExpandoObject() : new Dictionary<string, object>();
	}

	public enum FloatFormat
	{
		Double,
		Decimal,
	}

	public enum UnknownNumberFormat
	{
		Error,
		JsonElement,
	}

	public enum ObjectFormat
	{
		Expando,
		Dictionary,
	}
	
	// End of copied code

	public class Program
	{
		public static async Task Test()
		{
			await new TestClass().Should_Evaluate_Dynamic_Payload_Using_SystemTextJson();
		}
		
		public static async Task Main(string[] args)
		{
			Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version);
			Console.WriteLine("{0} version: {1}", typeof(JsonSerializer).Assembly.GetName().Name,  typeof(JsonSerializer).Assembly.FullName);
			Console.WriteLine("{0} version: {1}", typeof(CSharpScript).Assembly.GetName().Name,  typeof(CSharpScript).Assembly.FullName);
			Console.WriteLine();

			try
			{
				await Test();
			}
			catch (Exception ex)
			{
				Console.WriteLine("Failed with unhandled exception: ");
				Console.WriteLine(ex);
				throw;
			}
		}
	}
;