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 Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

​

//https://stackoverflow.com/questions/51804489/json-net-map-dynamic-property-to-a-fixed-one?noredirect=1#comment90581071_51804489

​

    public class QueryResponseRoot<T> //where T : IQuickbooksBaseEntity

    {

        [JsonProperty("QueryResponse")]

        public QueryResponse<T> QueryResponse { get; set; }

        [JsonProperty("time", Required = Required.Always)]

        public DateTimeOffset Time { get; set; }

    }

    public class QueryResponse<T>// where T : IQuickbooksBaseEntity

    {

        //[JsonProperty, JsonConverter(typeof(QuickbooksResponseConverter))]

        public IList<T> Results { get; set; }

        [JsonProperty("startPosition")]

        public Int64 StartPositions { get; set; }

        [JsonProperty("maxResults")]

        public Int64 MaxResults { get; set; }

    }

​

    public class Customer

    {

        public string GivenName { get; set; }

    }

​

​

    public class Account

    {

        public string Name { get; set; }

    }

​

//https://stackoverflow.com/questions/26629430/json-net-getting-generic-property-types-name-on-serialization?noredirect=1&lq=1

​

    public class GenericPropertyContractResolver : DefaultContractResolver

    {

        private readonly Type genericTypeDefinition;

        public GenericPropertyContractResolver(Type genericTypeDefinition)

        {

            this.genericTypeDefinition = genericTypeDefinition;

        }

        protected override JsonProperty CreateProperty(

            MemberInfo member, MemberSerialization memberSerialization)

        {

            JsonProperty baseProperty =

                base.CreateProperty(member, memberSerialization);

            Type declaringType = member.DeclaringType;

            if (!declaringType.IsGenericType ||

                declaringType.GetGenericTypeDefinition() != this.genericTypeDefinition)

            {

                return baseProperty;

            }

            Type declaringGenericType = declaringType.GetGenericArguments()[0];

            if (IsGenericMember(member))

            {

                baseProperty.PropertyName =

                    this.ResolvePropertyName(declaringGenericType.Name);

            }

            return baseProperty;

        }

        // Is there a better way to do this? Determines if the member passed in

        // is a generic member in the open generic type.

        public bool IsGenericMember(MemberInfo member)

        {

            MemberInfo genericMember = 

                this.genericTypeDefinition.GetMember(member.Name)[0];

            if (genericMember != null)

            {

                if (genericMember.MemberType == MemberTypes.Field)

                {

                    return ((FieldInfo)genericMember).FieldType.IsGenericParameter;

                }

                else if (genericMember.MemberType == MemberTypes.Property)

                {

                    PropertyInfo property = (PropertyInfo)genericMember;

                    return property

                        .GetMethod

                        .ReturnParameter

                        .ParameterType

                        .IsGenericParameter;

                }

            }

            return false;

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var customerJson = @"{

  ""QueryResponse"": {

    ""Customer"": [

      {

        ""GivenName"": ""Test""

      },

      {

        ""GivenName"": ""Test 2""

      }

    ],

    ""startPosition"": 1,

    ""maxResults"": 2

  },

  ""time"": ""2018-08-11T16:12:10.808-07:00""

}";

            Test<Customer>(customerJson);       

            var accountJson = @"{

  ""QueryResponse"": {

    ""Account"": [

      {

        ""Name"": ""Accounts Payable (A/P)""

      }

    ],

    ""startPosition"": 1,

    ""maxResults"": 90

  },

  ""time"": ""2018-08-11T16:14:55.309-07:00""

}";

            Test<Account>(accountJson);

        }

        public static void Test<T>(string json)

        {

            Console.WriteLine("\nTesting round-trip of {0}", typeof(T));

​

            var settings = new JsonSerializerSettings

            {

                ContractResolver = new GenericPropertyContractResolver(typeof(QueryResponse<>)),

            };

            var root = JsonConvert.DeserializeObject<QueryResponseRoot<T>>(json, settings);

            var json2 = JsonConvert.SerializeObject(root, Formatting.Indented, settings);

            Console.WriteLine(json2);

        }

    }

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: " + Environment.Version);

            Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​

    public class AssertionFailedException : System.Exception

    {

        public AssertionFailedException() : base() { }

​

        public AssertionFailedException(string s) : base(s) { }

    }

​

    public static class Assert

    {

        public static void IsTrue(bool value)

        {

            IsTrue(value, "failed");

        }

​

        public static void IsTrue(bool value, string message)

        {

            if (value == false)

                throw new AssertionFailedException(message ?? "failed");

        }

    }

​