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

        }

    }

​

    public static partial class JTokenExtensions

    {

        public static JToken ReplaceNilXmlElementObjectsWithNull(this JToken root)

        {

            var rootContainer = root as JContainer;

            if (rootContainer == null)

                return root;

            var list = rootContainer.DescendantsAndSelf()

                .OfType<JObject>()

                .Where(o => o.WasNilXmlElement())

                .ToList();

            foreach (var obj in list)

            {

                var replacement = JValue.CreateNull();

                if (obj.Parent != null)

                    obj.Replace(replacement);

                if (root == obj)

                    root = replacement;

            }

            return root;

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var json = GetJson();

​

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

            Console.WriteLine(json);

​

            var settings = new JsonSerializerSettings

            {

                // Whatever settings you require.

            };

​

            var root = JsonConvert.DeserializeObject<JToken>(json, settings)

                .ReplaceNilXmlElementObjectsWithNull()

                .ToObject<RootObject[]>(JsonSerializer.CreateDefault(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));

​

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

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

​

            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 token = JsonConvert.DeserializeObject<JToken>(json, settings);

            var obj2 = token.ReplaceNilXmlElementObjectsWithNull().ToObject<T>(JsonSerializer.CreateDefault(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();

        }

    }