[Fork] Question41479877 map-json-to-custom-class

CSharp · Console

/Program.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Threading;
using System.Collections.ObjectModel;
using System.Reflection;

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;				

    // https://stackoverflow.com/questions/41479877/map-json-to-custom-class


    class TestClass
    {
        static string GetJsonSingle()
        {
            var json = @"{
	""EventMessageUId"": ""ef51b5a3-32b2-e611-baf9-fc3fdb446bd2"",
	""Message"": ""{\""StoryId\"":20500,\""StoryDesc\"":\""Test Story data\""}"",
	""ProjectId"": ""1""
}";
            return json;
        }

        static string GetJsonMultiple()
        {
            var json = @"{
	""EventMessageUId"": ""ef51b5a3-32b2-e611-baf9-fc3fdb446bd2"",
	""Message"": ""[{\""StoryId\"":20500,\""StoryDesc\"":\""Test Story data\""},{\""StoryId\"":99500,\""StoryDesc\"":\""second Test Story data\""}]"",
	""ProjectId"": ""1""
}";
            return json;
        }

        internal static void Test()
        {
            Test(GetJsonSingle());
            Test(GetJsonMultiple());

            Console.WriteLine("Done");

        }

        private static void Test(string json)
        {
			Console.WriteLine("Testing: ");
			Console.WriteLine(json);
			
            var settings = new JsonSerializerSettings
            {
                Converters = { new StringConverterDecorator(new SingleOrArrayConverter<List<Message>, Message>()) },
            };

            var requirement = JsonConvert.DeserializeObject<Requirments>(json, settings);

            Console.WriteLine("Deserialized Message: ");
            Console.WriteLine(JsonConvert.SerializeObject(requirement.Message));

			Console.WriteLine("Deserialized and re-serialized {0}: ", requirement);
            Console.WriteLine(JsonConvert.SerializeObject(requirement, Formatting.Indented, settings));

            Console.WriteLine("");
        }
    }

    public class Requirments
    {
        public int FileID { get; set; }
        public string EventMessageUId { get; set; }
        public string ProjectId { get; set; }   

        //[JsonConverter(typeof(StringConverterDecorator), typeof(SingleOrArrayConverter))]
        public List<Message> Message { get; set; }

        public string error { get; set; }
    }

    public class Message
    {
        public string StoryID { get; set; }
        public string StoryDesc { get; set; }
    }

    public class SingleOrArrayConverter<TCollection, TItem> : SingleOrArrayConverter where TCollection : ICollection<TItem>
    {
        public override bool CanConvert(Type objectType)
        {
            if (!base.CanConvert(objectType))
                return false;
            return typeof(TCollection).IsAssignableFrom(objectType);
        }
    }

    public class SingleOrArrayConverter : JsonConverter
    {
        public override bool CanConvert(Type objectType)
        {
            if (objectType.IsArray || objectType == typeof(string) || objectType.IsPrimitive)
                return false;
            Type elementType = null;
            foreach (var type in objectType.GetCollectItemTypes())
            {
                if (elementType == null)
                    elementType = type;
                else
                    return false;
            }
            return elementType != null;
        }

        object ReadJsonGeneric<TItem>(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
                return null;
            var collection = (ICollection<TItem>)(existingValue ?? serializer.ContractResolver.ResolveContract(objectType).DefaultCreator());
            if (reader.TokenType == JsonToken.StartArray)
                serializer.Populate(reader, collection);
            else
                collection.Add(serializer.Deserialize<TItem>(reader));
            return collection;
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
                return null;
            if (objectType.IsArray)
                throw new JsonSerializationException("Read-only collections such as arrays are not supported");
            try
            {
                var elementType = objectType.GetCollectItemTypes().SingleOrDefault();
                if (elementType == null)
                    throw new JsonSerializationException(string.Format("{0} is not an ICollection<T> for some T", objectType));
                var method = typeof(SingleOrArrayConverter).GetMethod("ReadJsonGeneric", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public);
                return method.MakeGenericMethod(new[] { elementType }).Invoke(this, new object[] { reader, objectType, existingValue, serializer });
            }
            catch (Exception ex)
            {
                // Wrap the TargetInvocationException in a JsonSerializerException
                throw new JsonSerializationException("Failed to deserialize " + objectType, ex);
            }
        }

        void WriteJsonGeneric<TItem>(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var list = (ICollection<TItem>)value;
            if (list.Count == 1)
            {
                foreach (object item in list)
                {
                    serializer.Serialize(writer, item);
                    break;
                }
            }
            else
            {
                writer.WriteStartArray();
                foreach (var item in list)
                {
                    serializer.Serialize(writer, item);
                }
                writer.WriteEndArray();
            }
        }

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var objectType = value.GetType();
            try
            {
                var elementType = objectType.GetCollectItemTypes().SingleOrDefault();
                if (elementType == null)
                    throw new JsonSerializationException(string.Format("{0} is not an ICollection<T> for some T", objectType));
                var method = typeof(SingleOrArrayConverter).GetMethod("WriteJsonGeneric", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public);
                method.MakeGenericMethod(new[] { elementType }).Invoke(this, new object[] { writer, value, serializer });
            }
            catch (Exception ex)
            {
                // Wrap the TargetInvocationException in a JsonSerializerException
                throw new JsonSerializationException("Failed to serialize " + objectType, ex);
            }
        }
    }

    public static class TypeExtensions
    {
        public static IEnumerable<Type> GetInterfacesAndSelf(this Type type)
        {
            if (type == null)
                throw new ArgumentNullException();
            if (type.IsInterface)
                return new[] { type }.Concat(type.GetInterfaces());
            else
                return type.GetInterfaces();
        }

        public static IEnumerable<Type> GetCollectItemTypes(this Type type)
        {
            foreach (Type intType in type.GetInterfacesAndSelf())
            {
                if (intType.IsGenericType
                    && intType.GetGenericTypeDefinition() == typeof(ICollection<>))
                {
                    yield return intType.GetGenericArguments()[0];
                }
            }
        }
    }

    public class StringConverterDecorator : JsonConverterDecorator
    {
        public StringConverterDecorator(Type jsonConverterType) : base(jsonConverterType) { }

        public StringConverterDecorator(JsonConverter converter) : base(converter) { }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
                return null;
            // Unwrap the double-serialized string.
            var s = JToken.Load(reader).ToString();
            var token = JToken.Parse(s);
            // Then convert the revealed JSON to its final form.
            using (var subReader = token.CreateReader())
            {
                while (subReader.TokenType == JsonToken.None)
                    subReader.Read();
                return base.ReadJson(subReader, objectType, existingValue, serializer);
            }
        }

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            string s;

            // Serialize the value to an intermediate JSON string.
            using (var textWriter = new StringWriter())
            {
                using (var subWriter = new JsonTextWriter(textWriter))
                {
                    base.WriteJson(subWriter, value, serializer);
                }
                s = textWriter.ToString();
            }
            // Then double-serialize the value by writing the JSON as a string literal to the output stream.
            writer.WriteValue(s);
        }
    }

    public abstract class JsonConverterDecorator : JsonConverter
    {
        readonly JsonConverter converter;

        public JsonConverterDecorator(Type jsonConverterType) : this((JsonConverter)Activator.CreateInstance(jsonConverterType)) { }

        public JsonConverterDecorator(JsonConverter converter)
        {
            if (converter == null)
                throw new ArgumentNullException();
            this.converter = converter;
        }

        public override bool CanConvert(Type objectType)
        {
            return converter.CanConvert(objectType);
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            return converter.ReadJson(reader, objectType, existingValue, serializer);
        }

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            converter.WriteJson(writer, value, serializer);
        }

        public override bool CanRead { get { return converter.CanRead; } }

        public override bool CanWrite { get { return converter.CanWrite; } }
    }
					
	public class Program
	{
		public static void Main()
		{
            Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);
			
			TestClass.Test();
		}
	}
;