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;

            }

        }

    }

​