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

using System.Xml;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

// https://stackoverflow.com/questions/48009358/c-sharp-jsonconvert-serializexmlnode-empty-with-attributes

​

    public static class JTokenExtensions

    {

        const string XsiNamespace = @"http://www.w3.org/2001/XMLSchema-instance";

        readonly static string XmlNullValue = System.Xml.XmlConvert.ToString(true);

​

        public static JToken ReplaceXmlNilObjectsWithNull(this JToken root)

        {

            return root.ReplaceXmlNilObjects(t => JValue.CreateNull());

        }

​

        public static JToken ReplaceXmlNilObjects(this JToken root, Func<JToken, JToken> getReplacement)

        {

            var query = from obj in root.DescendantsAndSelf().OfType<JObject>()

                        where obj.Properties().Any(p => p.IsNilXmlTrueProperty())

                        select obj;

            foreach (var obj in query.ToList())

            {

                var replacement = getReplacement(obj);

                if (obj == root)

                    root = replacement;

                if (obj.Parent != null)

                    obj.Replace(replacement);

            }

            return root;

        }

​

        static IEnumerable<JToken> DescendantsAndSelf(this JToken node)

        {

            // Small wrapper adding this method to all JToken types.

            if (node == null)

                return Enumerable.Empty<JToken>();

            var container = node as JContainer;

            if (container != null)

                return container.DescendantsAndSelf();

            else

                return new[] { node };

        }

​

        static string GetXmlNamespace(this JProperty prop)

        {

            if (!prop.Name.StartsWith("@"))

                return null;

            var index = prop.Name.IndexOf(":");

            if (index < 0 || prop.Name.IndexOf(":", index+1) >= 0)

                return null;

            var ns = prop.Name.Substring(1, index - 1);

            if (string.IsNullOrEmpty(ns))

                return null;

            var nsPropertyName = "@xmlns:" + ns;

            foreach (var obj in prop.AncestorsAndSelf().OfType<JObject>())

            {

                var nsProperty = obj[nsPropertyName];

                if (nsProperty != null && nsProperty.Type == JTokenType.String)

                    return (string)nsProperty;

            }

            return null;

        }

​

        static bool IsNilXmlTrueProperty(this JProperty prop)

        {

            if (prop == null)

                return false;

            if (!(prop.Value.Type == JTokenType.String && (string)prop.Value == "true"))

                return false;

            if (!(prop.Name.StartsWith("@") && prop.Name.EndsWith(":nil")))

                return false;

            var ns = prop.GetXmlNamespace();

            return ns == XsiNamespace;

        }

    }

​

    public class RootObject

    {

        public List<DateTime?> AustrittDatum { get; set; }

    }

    class TestClass

    {

        public static void Test()

        {

            foreach (var xmlString in GetXml())

            {

                Console.WriteLine("\nInput XML: ");

                Console.WriteLine(xmlString);

​

                // Parse XML to XDocument

                var xDoc = XDocument.Parse(xmlString);

​

                // Convert the XDocument to an intermediate JToken hierarchy.

                var converter = new Newtonsoft.Json.Converters.XmlNodeConverter { OmitRootObject = true };

                var rootToken = JObject.FromObject(xDoc, JsonSerializer.CreateDefault(new JsonSerializerSettings { Converters = { converter } } ))

                    // And replace xsi:nil objects will null JSON values

                    .ReplaceXmlNilObjectsWithNull();

​

                // Deserialize to the final RootObject.

                var rootObject = rootToken.ToObject<RootObject>();

​

                Console.WriteLine("Intermediate JSON: ");

                Console.WriteLine(rootToken);

​

                Console.WriteLine("Final deserialized and re-serialized {0}", rootObject);

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

​

                Assert.IsTrue(!rootToken.ToString(Newtonsoft.Json.Formatting.None).Contains(@"""@xsi:nil"": ""true"""));

            }

        }

​

        static IEnumerable<string> GetXml()

        {

            var xml = new[]

            {

@"<Root>

<AustrittDatum>2018-01-31+01:00</AustrittDatum>

<AustrittDatum xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xsi:nil=""true""/>""

</Root>",

@"<Root xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" >

<AustrittDatum>2018-01-31+01:00</AustrittDatum>

<AustrittDatum xsi:nil=""true""/>""

</Root>",

            };

            return xml;

        }

    }

​

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

        }

    }

​