using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Xml.Serialization;

using System.Xml;

using System.IO;

using System.Diagnostics;

using System.Collections.ObjectModel;

using System.Threading;

using System.ComponentModel;

using System.Xml.Linq;

using System.Reflection;

using System.Data;

using System.Xml.Schema;

using System.Text.RegularExpressions;

using System.Net;

using System.Xml.XPath;

using System.Globalization;

using System.ComponentModel.DataAnnotations;

using System.Collections;

using System.Runtime.InteropServices;

​

    [System.Xml.Serialization.XmlIncludeAttribute(typeof(Truck))]

    [System.Xml.Serialization.XmlIncludeAttribute(typeof(Car))]

    public partial class Vehicle

    {

        public string Manufacturer { get; set; }

    }

    public partial class Truck : Vehicle

    {

        public int Load { get; set; }

    }

    public partial class Car : Vehicle

    {

        public string Configuration { get; set; }

    }

    public partial class Garage

    {

        public Garage()

        {

            Vehicles = new List<Vehicle>();

        }

​

        public List<Vehicle> Vehicles { get; set; }

    }

​

    class TestClass

    {

        static string GetOriginalXml()

        {

            var xml = @"<?xml version=""1.0"" encoding=""utf-8"" ?>

<Garage>

  <Vehicles>

    <Vehicle>

      <Manufacturer>Honda</Manufacturer>

      <Configuration>Sedan</Configuration>

    </Vehicle>

    <Vehicle>

      <Manufacturer>Volvo</Manufacturer>

      <Load>40</Load>

    </Vehicle>

  </Vehicles>

</Garage>";

            return xml;

        }

​

        static string GetFixedXml()

        {

            var xml = @"<?xml version=""1.0"" encoding=""utf-8""?>

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

  <Vehicles xsi:type=""Car"">

      <Manufacturer>Honda</Manufacturer>

      <Configuration>Sedan</Configuration>

  </Vehicles>

  <Vehicles xsi:type=""Truck"">

      <Manufacturer>Volvo</Manufacturer>

      <Load>40</Load>

  </Vehicles>

</Garage>";

            return xml;

        }

​

        static string GetFixedXmlWithWrapperElement()

        {

            var xml = @"<?xml version=""1.0"" encoding=""utf-8""?>

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

  <Vehicles>

  <Vehicle xsi:type=""Car"">

      <Manufacturer>Honda</Manufacturer>

      <Configuration>Sedan</Configuration>

  </Vehicle>

  <Vehicle xsi:type=""Truck"">

      <Manufacturer>Volvo</Manufacturer>

      <Load>40</Load>

  </Vehicle>

  </Vehicles>

</Garage>";

            return xml;

        }

​

        internal static void Test()

        {

            Console.WriteLine("Validating original XML with original XSD: ");

            ValidateGarageXml(GetOriginalXml(), GetGarageXSD());

​

            Console.WriteLine("");

            Console.WriteLine("Validating Fixed XML with original XSD: ");

            ValidateGarageXml(GetFixedXml(), GetGarageXSD());

​

            Console.WriteLine("");

            Console.WriteLine("Validating Fixed XML with added wrapper <Vehicles> element with XSD with added wrapper <Vehicles> element:");

            ValidateGarageXml(GetFixedXmlWithWrapperElement(), GetGarageXSDWithWrapperElement());

            //Console.WriteLine(GetGarageXSDWithWrapperElement());

            var garage = GetFixedXmlWithWrapperElement().LoadFromXML<Garage>();

            var reserializedXML = garage.GetXml();

            Console.WriteLine("");

            Console.WriteLine("");

            Console.WriteLine("Result of deserializing and re-serializing Fixed XML with added wrapper <Vehicles> element: ");

            Console.WriteLine(reserializedXML);         

        }

​

        private static void ValidateGarageXml(string xml, string garageXsd)

        {

            XmlSchemaSet schema = new XmlSchemaSet();

            using (var xsdReader = new StringReader(garageXsd))

                schema.Add(XmlSchema.Read(xsdReader, null));

            XDocument validateDoc = XDocument.Parse(xml);

​

            var errors = new List<string>();

​

            var flags = XmlSchemaValidationFlags.ReportValidationWarnings;

​

            Console.WriteLine(validateDoc);

            validateDoc.Validate(schema, flags, (o, ea) =>

            {

                errors.Add(ea.Message);

            });

            if (errors.Count == 0)

            {

                Console.WriteLine("Passed Validation.");

            }

            else

            {

                Console.WriteLine("Failed Validation, errors:");

                Console.WriteLine(String.Join("\n", errors));

            }

        }

​

        static string GetGarageXSD()

        {

            var xsd = @"<?xml version=""1.0"" encoding=""utf-8""?> 

<xs:schema attributeFormDefault=""unqualified"" elementFormDefault=""qualified"" xmlns:xs=""http://www.w3.org/2001/XMLSchema"">   

<xs:complexType name=""Vehicle"" abstract=""true"">

  <xs:sequence>

    <xs:element name=""Manufacturer"" type=""xs:string"" nillable=""false"" />

  </xs:sequence>   

</xs:complexType>   

<xs:complexType name=""Car"">

  <xs:complexContent>

    <xs:extension base=""Vehicle"">

      <xs:sequence>

        <xs:element name=""Configuration"" type=""xs:string"" nillable=""false"" />

      </xs:sequence>

    </xs:extension>

  </xs:complexContent>

</xs:complexType>

<xs:complexType name=""Truck"">

  <xs:complexContent>

    <xs:extension base=""Vehicle"">

      <xs:sequence>

        <xs:element name=""Load"" type=""xs:int"" nillable=""false"" />

      </xs:sequence>

    </xs:extension>

  </xs:complexContent>

</xs:complexType>

<xs:element name=""Garage"">

  <xs:complexType>

    <xs:sequence>

      <xs:element name=""Vehicles"" type=""Vehicle"" minOccurs=""0"" maxOccurs=""unbounded"" nillable=""false"" />

    </xs:sequence>

  </xs:complexType>

</xs:element>

</xs:schema>";

            return xsd;

        }

​

        static string GetGarageXSDWithWrapperElement()

        {

            var xsd = @"<?xml version=""1.0"" encoding=""utf-8""?> 

<xs:schema attributeFormDefault=""unqualified"" elementFormDefault=""qualified"" xmlns:xs=""http://www.w3.org/2001/XMLSchema"">   

<xs:complexType name=""Vehicle"" abstract=""true"">

  <xs:sequence>

    <xs:element name=""Manufacturer"" type=""xs:string"" nillable=""false"" />

  </xs:sequence>   

</xs:complexType>   

<xs:complexType name=""Car"">

  <xs:complexContent>

    <xs:extension base=""Vehicle"">

      <xs:sequence>

        <xs:element name=""Configuration"" type=""xs:string"" nillable=""false"" />

      </xs:sequence>

    </xs:extension>

  </xs:complexContent>

</xs:complexType>

<xs:complexType name=""Truck"">

  <xs:complexContent>

    <xs:extension base=""Vehicle"">

      <xs:sequence>

        <xs:element name=""Load"" type=""xs:int"" nillable=""false"" />

      </xs:sequence>

    </xs:extension>

  </xs:complexContent>

</xs:complexType>

<xs:complexType name=""ArrayOfVehicle"">

<xs:sequence>

  <xs:element minOccurs=""0"" maxOccurs=""unbounded"" name=""Vehicle"" nillable=""true"" type=""Vehicle"" />

</xs:sequence>

</xs:complexType>

<xs:element name=""Garage"">

  <xs:complexType>

    <xs:sequence>

      <xs:element minOccurs=""0"" maxOccurs=""1"" name=""Vehicles"" type=""ArrayOfVehicle"" />

    </xs:sequence>

  </xs:complexType>

</xs:element>

</xs:schema>";

            return xsd;

        }

    }

​

​

    public static class XNodeExtensions

    {

        public static void Validate(this XContainer node, XmlReaderSettings settings)

        {

            if (node == null)

                throw new ArgumentNullException();

            using (var innerReader = node.CreateReader())

            using (var reader = XmlReader.Create(innerReader, settings))

            {

                while (reader.Read())

                    ;

            }

        }

​

        public static void Validate(this XContainer node, XmlSchemaSet schemaSet, XmlSchemaValidationFlags validationFlags, ValidationEventHandler validationEventHandler)

        {

            var settings = new XmlReaderSettings();

            settings.ValidationType = ValidationType.Schema;

            settings.ValidationFlags |= validationFlags;

            if (validationEventHandler != null)

                settings.ValidationEventHandler += validationEventHandler;

            settings.Schemas = schemaSet;

            node.Validate(settings);

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            TestClass.Test();

        }

    }

​

    public static class XmlSerializationHelper

    {

        public static T LoadFromXML<T>(this string xmlString)

        {

            using (StringReader reader = new StringReader(xmlString))

            {

                return (T)new XmlSerializer(typeof(T)).Deserialize(reader);

            }

        }

​

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

        {

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

            }

        }

    }

​