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.Xml;

using System.Xml.Serialization;

using System.Xml.Linq;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

// https://stackoverflow.com/questions/45117277/newtonsoft-jsonconvert-deserialize-json-handle-nil-true

​

​

    public class Vehicle

    {

        public string Id { get; set; }

​

        [XmlElement(IsNullable = true)]

        public DateTime? RenewalDate { get; set; }

    }

​

    public class RootObject

    {

        public Vehicle Vehicle { get; set; }

    }

​

    public class NullableStructConverter<T> : JsonConverter where T : struct

    {

        public override bool CanConvert(Type objectType)

        {

            return objectType == typeof(Nullable<T>);

        }

​

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)

        {

            var underlyingType = Nullable.GetUnderlyingType(objectType);

            if (underlyingType == null)

                throw new InvalidOperationException(string.Format("Type {0} is not nullable", objectType));

            var token = JToken.Load(reader);

            if (token.Type == JTokenType.Null)

                return null;

            if (token.WasNilXmlElement())

                return null;

            return token.ToObject(underlyingType, serializer);

        }

​

        public override bool CanWrite { get { return false; } }

​

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)

        {

            throw new NotImplementedException();

        }

    }

​

    public static partial class JTokenExtensions

    {

        public static bool WasNilXmlElement(this JToken token)

        {

            if (token == null)

                return true;

            if (token.Type == JTokenType.Null)

                return true;

            var obj = token as JObject;

            if (obj != null)

            {

                // Check if all properties were translated from XML attributes

                // and one was translated from xsi:nil = true

                // There might be namespaces present as well, e.g.

                // "@xmlns:p3": "http://www.w3.org/2001/XMLSchema-instance"

                if (obj.Properties().All(p => p.Name.StartsWith("@"))

                    && obj.Properties().Any(p => p.Name == "@nil" || p.Name.EndsWith(":nil") && p.Value.ToString() == "true"))

                    return true;

            }

            return false;

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var json = GetJson();

​

            Console.WriteLine("Testing deserialization of JSON: ");

            Console.WriteLine(json);

​

            var settings = new JsonSerializerSettings 

            { 

                Converters = { new NullableStructConverter<DateTime>() } 

                // Whatever other settings you require.

            };

            var root = JsonConvert.DeserializeObject<RootObject[]>(json, settings);

​

            Assert.IsTrue(root.Length == 2

                && root[0].Vehicle.RenewalDate == null

                && root[1].Vehicle.RenewalDate == new DateTime(2017, 7, 16, 0, 0, 0, DateTimeKind.Utc));

​

            Console.WriteLine("Deserialization and re-serialization successful, result: ");

            Console.WriteLine(JsonConvert.SerializeObject(root, Newtonsoft.Json.Formatting.Indented, settings));

​

            Test(new RootObject { Vehicle = new Vehicle { Id = "101", RenewalDate = null } }, settings);

            Test(new RootObject { Vehicle = new Vehicle { Id = "101", RenewalDate = DateTime.UtcNow } }, settings);

​

            Console.WriteLine("\nAll tests passed successfully.");

        }

​

        static void Test<T>(T obj, JsonSerializerSettings settings)

        {

            var xml = obj.GetXml();

​

            Test<T>(xml, settings);

        }

​

        private static void Test<T>(string xml, JsonSerializerSettings settings)

        {

            Console.WriteLine(string.Format("Testing round-trip of type {0} with input XML as follows: ", typeof(T)));

            Console.WriteLine(xml);

​

            var json = JsonConvert.SerializeXNode(XElement.Parse(xml), Newtonsoft.Json.Formatting.Indented, true);

​

            Console.WriteLine("Intermediate JSON: ");

            Console.WriteLine(json);

​

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

​

            var xml2 = obj2.GetXml();

​

            var ok = XNode.DeepEquals(XElement.Parse(xml), XElement.Parse(xml2));

​

            Assert.IsTrue(ok);

            Console.WriteLine("Input XML and reserialized XML are equivalent.");

            Console.WriteLine("");

        }

​

        static string GetJson()

        {

            var xml = @"[{

""Vehicle"": {

  ""Id"": ""1"",

   ""RenewalDate"": {

    ""@nil"": ""true""

  }     

}},

{

""Vehicle"": {

  ""Id"": ""1"",

   ""RenewalDate"": ""2017-07-16T00:00:00Z""

}}]";

            return xml;

        }

    }

​

    public class AssertionFailedException : System.Exception

    {

        public AssertionFailedException() : base() { }

​

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

    }

​

    public static class Assert

    {

        public static void IsTrue(bool value)

        {

            if (value == false)

                throw new AssertionFailedException("failed");

        }

    }

​

​

    public static partial class XmlSerializerExtensions

    {

        public static string GetXml<T>(this T obj, bool omitStandardNamespaces = true)

        {

            XmlSerializerNamespaces ns = null;

            if (omitStandardNamespaces)

            {

                ns = new XmlSerializerNamespaces();

                ns.Add("", ""); // Disable the xmlns:xsi and xmlns:xsd lines.

            }

            using (var textWriter = new StringWriter())

            {

                var settings = new XmlWriterSettings() { Indent = true }; // For cosmetic purposes.

                using (var xmlWriter = XmlWriter.Create(textWriter, settings))

                    new XmlSerializer(obj.GetType()).Serialize(xmlWriter, obj, ns);

                return textWriter.ToString();

            }

        }

    }

​

    public class Program

    {

        public static void Main()

        {

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

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

            Console.WriteLine();

​

            TestClass.Test();

        }

    }