CodeProject.html

<h2>Welcome!</h2>

<p>Welcome to ExtendedXmlSerializer's source repository, our little home on the webternets for ExtendedXmlSerializer.  Please have a look around.  If you have a question about our serializer, please do not hesitate to post a question in our issues:</p>
<p>https://github.com/wojtpl2/ExtendedXmlSerializer/issues/new/</p>
<p></p>
<p>We will mark it as a question/discussion and talk it through with you using sample code.  This process is currently being used to fill in the gaps with our documentation, which could use a little love.</p>
<p></p>
<p>Additionally, please make use of our documentation tag seen here:</p>
<p></p>
<p>https://github.com/wojtpl2/ExtendedXmlSerializer/issues?q=is%3Aissue+label%3ADocumentation</p>
<p></p>
<p>You can see the history of questions asked that we feel could eventually be added to our documentation.  We'll eventually get to it, we swear. 😆</p>
<p></p>
<p></p>
<h2>Information</h2>

<p>Support platforms:</p>

<ul>
<li>.NET 4.5</li>
<li>.NET Standard 2.0</li>
</ul>

<p>Support features:</p>

<ul>
<li>Deserialization xml from standard <code>XMLSerializer</code> (mostly, see: https://github.com/wojtpl2/ExtendedXmlSerializer/issues/240)</li>
<li>Serialization class, struct, generic class, primitive type, generic list and dictionary, array, enum</li>
<li>Serialization class with property interface</li>
<li>Serialization circular reference and reference Id</li>
<li>Deserialization of old version of xml</li>
<li>Property encryption</li>
<li>Custom serializer</li>
<li>Support <code>XmlElementAttribute</code>, <code>XmlRootAttribute</code>, and <code>XmlTypeAttribute</code> for identity resolution.</li>
<li>Additional attribute support: <code>XmlIgnoreAttribute</code>, <code>XmlAttributeAttribute</code>, and <code>XmlEnumAttribute</code>.</li>
<li>POCO - all configurations (migrations, custom serializer...) are outside the clas</li>
</ul>

<p>Standard XML Serializer in .NET is very limited:</p>

<ul>
<li>Does not support serialization of class with circular reference or class with interface property.</li>
<li>There is no mechanism for reading the old version of XML.</li>
<li>Does not support properties that are defined with interface types.</li>
<li>Does not support read-only collection properties (like Xaml does).</li>
<li>Does not support parameterized constructors.</li>
<li>Does not support private constructors.</li>
<li>If you want create custom serializer, your class must inherit from <code>IXmlSerializable</code>. This means that your class will not be a POCO class.</li>
<li>Does not support IoC</li>
</ul>

<h2>The Basics</h2>

<p>Everything in <code>ExtendedXmlSerializer</code> begins with a configuration container, from which you can use to configure the serializer and ultimately create it:</p>

<pre lang="cs">
    IExtendedXmlSerializer serializer = new ConfigurationContainer()
                                                // Configure...
                                                .Create();
</pre>

<p>Using this simple subject class:</p>

<pre lang="cs">
    public sealed class Subject
    {
        public string Message { get; set; }
    
        public int Count { get; set; }
    }
</pre>

<p>The results of the default serializer will look like this:</p>

<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;Subject xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Introduction;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Message&gt;Hello World!&lt;/Message&gt;
      &lt;Count&gt;6776&lt;/Count&gt;
    &lt;/Subject&gt;
</pre>

<p>We can take this a step further by configuring the <code>Subject</code>'s Type and Member properties, which will effect how its Xml is emitted.  Here is an example of configuring the <code>Subject</code>'s name to emit as <code>ModifiedSubject</code>:</p>

<pre lang="cs">
    IExtendedXmlSerializer serializer = new ConfigurationContainer().ConfigureType&lt;Subject&gt;()
                                                                    .Name(&quot;ModifiedSubject&quot;)
                                                                    .Create();
</pre>


<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;ModifiedSubject xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Introduction;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Message&gt;Hello World!&lt;/Message&gt;
      &lt;Count&gt;6776&lt;/Count&gt;
    &lt;/ModifiedSubject&gt;
</pre>

<p>Diving a bit further, we can also configure the type's member information. For example, configuring <code>Subject.Message</code> to emit as <code>Text</code> instead:</p>

<pre lang="cs">
    IExtendedXmlSerializer serializer = new ConfigurationContainer().ConfigureType&lt;Subject&gt;()
                                                                    .Member(x =&gt; x.Message)
                                                                    .Name(&quot;Text&quot;)
                                                                    .Create();
</pre>


<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;Subject xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Introduction;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Text&gt;Hello World!&lt;/Text&gt;
      &lt;Count&gt;6776&lt;/Count&gt;
    &lt;/Subject&gt;
</pre>

<h2>Xml Settings</h2>

<p>In case you want to configure the XML write and read settings via <code>XmlWriterSettings</code> and <code>XmlReaderSettings</code> respectively, you can do that via extension methods created for you to do so:</p>

<pre lang="cs">
    Subject subject = new Subject{ Count = 6776, Message = &quot;Hello World!&quot; };
    IExtendedXmlSerializer serializer = new ConfigurationContainer().Create();
    string contents = serializer.Serialize(new XmlWriterSettings {Indent = true}, subject);
    // ...
</pre>

<p>And for reading:</p>

<pre lang="cs">
    Subject instance = serializer.Deserialize&lt;Subject&gt;(new XmlReaderSettings{IgnoreWhitespace = false}, contents);
    // ...
</pre>

<h2>Serialization</h2>

<p>Now that your configuration container has been configured and your serializer has been created, it's time to get to the serialization.</p>

<pre lang="cs">
    
    
    IExtendedXmlSerializer serializer = new ConfigurationContainer().Create();
    TestClass obj = new TestClass();
    string xml = serializer.Serialize(obj);
</pre>

<h2>Deserialization</h2>


<pre lang="cs">
    
    
    TestClass obj2 = serializer.Deserialize&lt;TestClass&gt;(xml);
</pre>

<h2>Classic Serialization/Deserialization</h2>

<p>Most of the code examples that you see in this documentation make use of useful extension methods that make serialization and deserialization a snap with <code>ExtendedXmlSerializer.  However, if you would like to break down into the basic, classical pattern of serialization, and deserialization, this is supported too, as seen by the following examples.  Here's serialization:</p>

<pre lang="cs">
    
    
                IExtendedXmlSerializer serializer = new ConfigurationContainer().Create();
                TestClass              instance   = new TestClass();
                MemoryStream           stream     = new MemoryStream();
                using (XmlWriter writer = XmlWriter.Create(stream))
                {
                    serializer.Serialize(writer, instance);
                    writer.Flush();
                }
    
                stream.Seek(0, SeekOrigin.Begin);
                string contents = new StreamReader(stream).ReadToEnd();
    
</pre>

<p>And here's how to deserialize:</p>

<pre lang="cs">
    
    
                TestClass deserialized;
                MemoryStream contentStream = new MemoryStream(Encoding.UTF8.GetBytes(contents));
                using (XmlReader reader = XmlReader.Create(contentStream))
                {
                    deserialized = (TestClass)serializer.Deserialize(reader);
                }
    
</pre>

<h2>Serialization/Deserialization with Settings Overrides</h2>

<p>Additionally, <code>ExtendedXmlSerializer</code> also supports overrides for serialization and deserialization that allow you to pass in <code>XmlWriterSettings</code> and <code>XmlReaderSettings</code> respectively.  Here's an example of this for serialization:</p>

<pre lang="cs">
    
    
                IExtendedXmlSerializer serializer = new ConfigurationContainer().Create();
                TestClass              instance   = new TestClass();
                MemoryStream           stream     = new MemoryStream();
    
                string contents = serializer.Serialize(new XmlWriterSettings { /* ... */ }, stream, instance);
    
</pre>

<p>And for deserialization:</p>

<pre lang="cs">
    
    
                MemoryStream contentStream = new MemoryStream(Encoding.UTF8.GetBytes(contents));
                TestClass deserialized = serializer.Deserialize&lt;TestClass&gt;(new XmlReaderSettings{ /* ... */ }, contentStream);
    
</pre>

<h2>Fluent API</h2>

<p>ExtendedXmlSerializer use fluent API to configuration. Example:</p>

<pre lang="cs">
    
                IExtendedXmlSerializer serializer = new ConfigurationContainer()
                    .UseEncryptionAlgorithm(new CustomEncryption())
                    .Type&lt;Person&gt;() // Configuration of Person class
                        .Member(p =&gt; p.Password) // First member
                            .Name(&quot;P&quot;)
                            .Encrypt()
                        .Member(p =&gt; p.Name) // Second member
                            .Name(&quot;T&quot;)
                    .Type&lt;TestClass&gt;() // Configuration of another class
                        .CustomSerializer(new TestClassSerializer())
                    .Create();
</pre>

<h2>Serialization of dictionary</h2>

<p>You can serialize generic dictionary, that can store any type.</p>

<pre lang="cs">
    
    public class TestClass
    {
        public Dictionary&lt;int, string&gt; Dictionary { get; set; }
    }
</pre>


<pre lang="cs">
    
    TestClass obj = new TestClass
    {
        Dictionary = new Dictionary&lt;int, string&gt;
        {
            {1, &quot;First&quot;},
            {2, &quot;Second&quot;},
            {3, &quot;Other&quot;},
        }
    };
</pre>

<p>Output XML will look like:</p>

<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;TestClass xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Dictianary;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Dictionary&gt;
        &lt;Item xmlns=&quot;https://extendedxmlserializer.github.io/system&quot;&gt;
          &lt;Key&gt;1&lt;/Key&gt;
          &lt;Value&gt;First&lt;/Value&gt;
        &lt;/Item&gt;
        &lt;Item xmlns=&quot;https://extendedxmlserializer.github.io/system&quot;&gt;
          &lt;Key&gt;2&lt;/Key&gt;
          &lt;Value&gt;Second&lt;/Value&gt;
        &lt;/Item&gt;
        &lt;Item xmlns=&quot;https://extendedxmlserializer.github.io/system&quot;&gt;
          &lt;Key&gt;3&lt;/Key&gt;
          &lt;Value&gt;Other&lt;/Value&gt;
        &lt;/Item&gt;
      &lt;/Dictionary&gt;
    &lt;/TestClass&gt;
</pre>

<p>If you use UseOptimizedNamespaces function xml will look like:</p>

<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;TestClass xmlns:sys=&quot;https://extendedxmlserializer.github.io/system&quot; xmlns:exs=&quot;https://extendedxmlserializer.github.io/v2&quot; xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Dictianary;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Dictionary&gt;
        &lt;sys:Item&gt;
          &lt;Key&gt;1&lt;/Key&gt;
          &lt;Value&gt;First&lt;/Value&gt;
        &lt;/sys:Item&gt;
        &lt;sys:Item&gt;
          &lt;Key&gt;2&lt;/Key&gt;
          &lt;Value&gt;Second&lt;/Value&gt;
        &lt;/sys:Item&gt;
        &lt;sys:Item&gt;
          &lt;Key&gt;3&lt;/Key&gt;
          &lt;Value&gt;Other&lt;/Value&gt;
        &lt;/sys:Item&gt;
      &lt;/Dictionary&gt;
    &lt;/TestClass&gt;
</pre>

<h2>Custom serialization</h2>

<p>If your class has to be serialized in a non-standard way:</p>

<pre lang="cs">
    
    
    public class TestClass
    {
        public TestClass(string paramStr, int paramInt)
        {
            PropStr = paramStr;
            PropInt = paramInt;
        }
    
        public string PropStr { get; private set; }
        public int PropInt { get; private set; }
    }
</pre>

<p>You must create custom serializer:</p>

<pre lang="cs">
    
    
    public class TestClassSerializer : IExtendedXmlCustomSerializer&lt;TestClass&gt;
    {
        public TestClass Deserialize(XElement element)
        {
            XElement xElement = element.Member(&quot;String&quot;);
            XElement xElement1 = element.Member(&quot;Int&quot;);
            if (xElement != null &amp;&amp; xElement1 != null)
            {
                string strValue = xElement.Value;
    
                int intValue = Convert.ToInt32(xElement1.Value);
                return new TestClass(strValue, intValue);
            }
            throw new InvalidOperationException(&quot;Invalid xml for class TestClassWithSerializer&quot;);
        }
    
        public void Serializer(XmlWriter writer, TestClass obj)
        {
            writer.WriteElementString(&quot;String&quot;, obj.PropStr);
            writer.WriteElementString(&quot;Int&quot;, obj.PropInt.ToString(CultureInfo.InvariantCulture));
        }
    }
</pre>

<p>Then, you have to add custom serializer to configuration of TestClass:</p>

<pre lang="cs">
    
    
    IExtendedXmlSerializer serializer = new ConfigurationContainer().Type&lt;TestClass&gt;()
                                                                    .CustomSerializer(new TestClassSerializer())
                                                                    .Create();
</pre>

<h2>Deserialize old version of xml</h2>

<p>In standard <code>XMLSerializer</code> you can't deserialize XML in case you change model. In <code>ExtendedXMLSerializer</code> you can create migrator for each class separately. E.g.: If you have big class, that uses small class and this small class will be changed you can create migrator only for this small class. You don't have to modify whole big XML. Now I will show you a simple example:</p>
<p>If you had a class:</p>

<pre lang="cs">
    
        public class TestClass
        {
            public int Id { get; set; }
            public string Type { get; set; }
        }
</pre>

<p>and generated XML look like:</p>

<pre lang="xml">
    
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;TestClass xmlns=&quot;clr-namespace:ExtendedXmlSerialization.Samples.MigrationMap;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Id&gt;1&lt;/Id&gt;
      &lt;Type&gt;Type&lt;/Type&gt;
    &lt;/TestClass&gt;
</pre>

<p>Then you renamed property:</p>

<pre lang="cs">
    
        public class TestClass
        {
            public int Id { get; set; }
            public string Name { get; set; }
        }
</pre>

<p>and generated XML look like:</p>

<pre lang="xml">
    
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;TestClass xmlns:exs=&quot;https://extendedxmlserializer.github.io/v2&quot; exs:version=&quot;1&quot; xmlns=&quot;clr-namespace:ExtendedXmlSerialization.Samples.MigrationMap;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Id&gt;1&lt;/Id&gt;
      &lt;Name&gt;Type&lt;/Name&gt;
    &lt;/TestClass&gt;
</pre>

<p>Then, you added new property and you wanted to calculate a new value during deserialization.</p>

<pre lang="cs">
    
    
    public class TestClass
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Value { get; set; }
    }
</pre>

<p>and new XML should look like:</p>

<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;TestClass xmlns:exs=&quot;https://extendedxmlserializer.github.io/v2&quot; exs:version=&quot;2&quot; xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.MigrationMap;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Id&gt;1&lt;/Id&gt;
      &lt;Name&gt;Type&lt;/Name&gt;
      &lt;Value&gt;Calculated&lt;/Value&gt;
    &lt;/TestClass&gt;
</pre>

<p>You can migrate (read) old version of XML using migrations:</p>

<pre lang="cs">
    
    
    public class TestClassMigrations : IEnumerable&lt;Action&lt;XElement&gt;&gt;
    {
        public static void MigrationV0(XElement node)
        {
            XElement typeElement = node.Member(&quot;Type&quot;);
            // Add new node
            node.Add(new XElement(&quot;Name&quot;, typeElement.Value));
            // Remove old node
            typeElement.Remove();
        }
    
        public static void MigrationV1(XElement node)
        {
            // Add new node
            node.Add(new XElement(&quot;Value&quot;, &quot;Calculated&quot;));
        }
    
        IEnumerator IEnumerable.GetEnumerator() =&gt; GetEnumerator();
    
        public IEnumerator&lt;Action&lt;XElement&gt;&gt; GetEnumerator()
        {
            yield return MigrationV0;
            yield return MigrationV1;
        }
    }
</pre>

<p>Then, you must register your <code>TestClassMigrations</code> class in configuration</p>

<pre lang="cs">
    
    
    IExtendedXmlSerializer serializer = new ConfigurationContainer().ConfigureType&lt;TestClass&gt;()
                                                                    .AddMigration(new TestClassMigrations())
                                                                    .Create();
</pre>

<h2>Extensibility</h2>

<p>With type and member configuration out of the way, we can turn our attention to what really makes ExtendedXmlSeralizer tick: extensibility.  As its name suggests, ExtendedXmlSeralizer offers a very flexible (but albeit new) extension model from which you can build your own extensions.  Pretty much all if not all features you encounter with ExtendedXmlSeralizer are through extensions.  There are quite a few in our latest version here that showcase this extensibility.  The remainder of this document will showcase the top features of ExtendedXmlSerializer that are accomplished through its extension system.</p>
<p></p>
<h2>Object reference and circular reference</h2>

<p>If you have a class:</p>

<pre lang="cs">
    
    
    public class Person
    {
        public int Id { get; set; }
        public string Name { get; set; }
    
        public Person Boss { get; set; }
    }
    
    public class Company
    {
        public List&lt;Person&gt; Employees { get; set; }
    }
</pre>

<p>then you create object with circular reference, like this:</p>

<pre lang="cs">
    
    
    Person boss = new Person {Id = 1, Name = &quot;John&quot;};
    boss.Boss = boss; //himself boss
    Person worker = new Person {Id = 2, Name = &quot;Oliver&quot;};
    worker.Boss = boss;
    Company obj = new Company
    {
        Employees = new List&lt;Person&gt;
        {
            worker,
            boss
        }
    };
</pre>

<p>You must configure Person class as reference object:</p>

<pre lang="cs">
    
    
    IExtendedXmlSerializer serializer = new ConfigurationContainer().ConfigureType&lt;Person&gt;()
                                                                    .EnableReferences(p =&gt; p.Id)
                                                                    .Create();
</pre>

<p>Output XML will look like this:</p>

<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;Company xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.ObjectReference;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Employees&gt;
        &lt;Capacity&gt;4&lt;/Capacity&gt;
        &lt;Person Id=&quot;2&quot;&gt;
          &lt;Name&gt;Oliver&lt;/Name&gt;
          &lt;Boss Id=&quot;1&quot;&gt;
            &lt;Name&gt;John&lt;/Name&gt;
            &lt;Boss xmlns:exs=&quot;https://extendedxmlserializer.github.io/v2&quot; exs:entity=&quot;1&quot; /&gt;
          &lt;/Boss&gt;
        &lt;/Person&gt;
        &lt;Person xmlns:exs=&quot;https://extendedxmlserializer.github.io/v2&quot; exs:entity=&quot;1&quot; /&gt;
      &lt;/Employees&gt;
    &lt;/Company&gt;
</pre>

<h2>Property Encryption</h2>

<p>If you have a class with a property that needs to be encrypted:</p>

<pre lang="cs">
    
    
    public class Person
    {
        public string Name { get; set; }
        public string Password { get; set; }
    }
</pre>

<p>You must implement interface IEncryption. For example, it will show the Base64 encoding, but in the real world better to use something safer, eg. RSA.:</p>

<pre lang="cs">
    
    
    public class CustomEncryption : IEncryption
    {
        public string Parse(string data)
            =&gt; Encoding.UTF8.GetString(Convert.FromBase64String(data));
    
        public string Format(string instance)
            =&gt; Convert.ToBase64String(Encoding.UTF8.GetBytes(instance));
    }
</pre>

<p>Then, you have to specify which properties are to be encrypted and register your IEncryption implementation.</p>

<pre lang="cs">
    
    
    IExtendedXmlSerializer serializer = new ConfigurationContainer().UseEncryptionAlgorithm(new CustomEncryption())
                                                                    .ConfigureType&lt;Person&gt;()
                                                                    .Member(p =&gt; p.Password)
                                                                    .Encrypt()
                                                                    .Create();
</pre>

<h2>Custom Conversion</h2>

<p>ExtendedXmlSerializer does a pretty decent job (if we do say so ourselves) of composing and decomposing objects, but if you happen to have a type that you want serialized in a certain way, and this type can be destructured into a <code>string</code>, then you can register a custom converter for it.</p>
<p></p>
<p>Using the following:</p>

<pre lang="cs">
    
    
    public sealed class CustomStructConverter : IConverter&lt;CustomStruct&gt;
    {
        public static CustomStructConverter Default { get; } = new CustomStructConverter();
        CustomStructConverter() {}
    
        public bool IsSatisfiedBy(TypeInfo parameter) =&gt; typeof(CustomStruct).GetTypeInfo()
                                                                             .IsAssignableFrom(parameter);
    
        public CustomStruct Parse(string data) =&gt;
            int.TryParse(data, out int number) ? new CustomStruct(number) : CustomStruct.Default;
    
        public string Format(CustomStruct instance) =&gt; instance.Number.ToString();
    }
    
    public struct CustomStruct
    {
        public static CustomStruct Default { get; } = new CustomStruct(6776);
    
        public CustomStruct(int number)
        {
            Number = number;
        }
        public int Number { get; }
    }
</pre>

<p>Register the converter:</p>

<pre lang="cs">
    
    IExtendedXmlSerializer serializer = new ConfigurationContainer().Register(CustomStructConverter.Default).Create();
    CustomStruct subject = new CustomStruct(123);
    string contents = serializer.Serialize(subject);
    // ...
</pre>


<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;CustomStruct xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Extensibility;assembly=ExtendedXmlSerializer.Samples&quot;&gt;123&lt;/CustomStruct&gt;
</pre>

<h2>Optimized Namespaces</h2>

<p>By default Xml namespaces are emitted on an "as needed" basis:</p>

<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;List xmlns:exs=&quot;https://extendedxmlserializer.github.io/v2&quot; exs:arguments=&quot;Object&quot; xmlns=&quot;https://extendedxmlserializer.github.io/system&quot;&gt;
      &lt;Capacity&gt;4&lt;/Capacity&gt;
      &lt;Subject xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Extensibility;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
        &lt;Message&gt;First&lt;/Message&gt;
      &lt;/Subject&gt;
      &lt;Subject xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Extensibility;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
        &lt;Message&gt;Second&lt;/Message&gt;
      &lt;/Subject&gt;
      &lt;Subject xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Extensibility;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
        &lt;Message&gt;Third&lt;/Message&gt;
      &lt;/Subject&gt;
    &lt;/List&gt;
</pre>

<p>But with one call to the <code>UseOptimizedNamespaces</code> call, namespaces get placed at the root of the document, thereby reducing document footprint:</p>

<pre lang="cs">
    
    
    IExtendedXmlSerializer serializer = new ConfigurationContainer().UseOptimizedNamespaces()
                                                                    .Create();
    List&lt;object&gt; subject = new List&lt;object&gt;
                    {
                        new Subject {Message = &quot;First&quot;},
                        new Subject {Message = &quot;Second&quot;},
                        new Subject {Message = &quot;Third&quot;}
                    };
    string contents = serializer.Serialize(subject);
    // ...
</pre>


<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;List xmlns:ns1=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Extensibility;assembly=ExtendedXmlSerializer.Samples&quot; xmlns:exs=&quot;https://extendedxmlserializer.github.io/v2&quot; exs:arguments=&quot;Object&quot; xmlns=&quot;https://extendedxmlserializer.github.io/system&quot;&gt;
      &lt;Capacity&gt;4&lt;/Capacity&gt;
      &lt;ns1:Subject&gt;
        &lt;Message&gt;First&lt;/Message&gt;
      &lt;/ns1:Subject&gt;
      &lt;ns1:Subject&gt;
        &lt;Message&gt;Second&lt;/Message&gt;
      &lt;/ns1:Subject&gt;
      &lt;ns1:Subject&gt;
        &lt;Message&gt;Third&lt;/Message&gt;
      &lt;/ns1:Subject&gt;
    &lt;/List&gt;
</pre>

<h2>Implicit Namespaces/Typing</h2>

<p>If you don't like namespaces at all, you can register types so that they do not emit namespaces when they are rendered into a document:</p>

<pre lang="cs">
    IExtendedXmlSerializer serializer = new ConfigurationContainer().EnableImplicitTyping(typeof(Subject))
                                                                    .Create();
    Subject subject = new Subject{ Message = &quot;Hello World!  No namespaces, yay!&quot; };
    string contents = serializer.Serialize(subject);
    // ...
</pre>


<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;Subject&gt;
      &lt;Message&gt;Hello World!  No namespaces, yay!&lt;/Message&gt;
    &lt;/Subject&gt;
</pre>

<h2>Auto-Formatting (Attributes)</h2>

<p>The default behavior for emitting data in an Xml document is to use elements, which can be a little chatty and verbose:</p>

<pre lang="cs">
    
    
    IExtendedXmlSerializer serializer = new ConfigurationContainer().UseOptimizedNamespaces()
                                                                    .Create();
    List&lt;object&gt; subject = new List&lt;object&gt;
                    {
                        new Subject {Message = &quot;First&quot;},
                        new Subject {Message = &quot;Second&quot;},
                        new Subject {Message = &quot;Third&quot;}
                    };
    string contents = serializer.Serialize(subject);
    // ...
</pre>


<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;SubjectWithThreeProperties xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Extensibility;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Number&gt;123&lt;/Number&gt;
      &lt;Message&gt;Hello World!&lt;/Message&gt;
      &lt;Time&gt;2018-05-26T11:52:19.4981212-04:00&lt;/Time&gt;
    &lt;/SubjectWithThreeProperties&gt;
</pre>

<p>Making use of the <code>UseAutoFormatting</code> call will enable all types that have a registered <code>IConverter</code> (convert to string and back) to emit as attributes:</p>

<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;SubjectWithThreeProperties Number=&quot;123&quot; Message=&quot;Hello World!&quot; Time=&quot;2018-05-26T11:52:19.4981212-04:00&quot; xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Extensibility;assembly=ExtendedXmlSerializer.Samples&quot; /&gt;
</pre>

<h2>Verbatim Content (CDATA)</h2>

<p>If you have an element with a member that can hold lots of data, or data that has illegal characters, you configure it to be a verbatim field and it will emit a CDATA section around it:</p>

<pre lang="cs">
    
    IExtendedXmlSerializer serializer = new ConfigurationContainer().Type&lt;Subject&gt;()
                                                                    .Member(x =&gt; x.Message)
                                                                    .Verbatim()
                                                                    .Create();
    Subject subject = new Subject {Message = @&quot;&lt;{&quot;&quot;Ilegal characters and such&quot;&quot;}&gt;&quot;};
    string contents = serializer.Serialize(subject);
    // ...
</pre>


<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;Subject xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Extensibility;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Message&gt;&lt;![CDATA[&lt;{&quot;Ilegal characters and such&quot;}&gt;]]&gt;&lt;/Message&gt;
    &lt;/Subject&gt;
</pre>

<p>You can also denote these fields with an attribute and get the same functionality:</p>

<pre lang="cs">
    
    public sealed class VerbatimSubject
    {
        [Verbatim]
        public string Message { get; set; }
    }
</pre>

<h2>Private Constructors</h2>

<p>One of the limitations of the classic <code>XmlSerializer</code> is that it does not support private constructors, but <code>ExtendedXmlSerializer</code> does via its <code>EnableAllConstructors</code> call:</p>

<pre lang="cs">
    public sealed class SubjectByFactory
    {
        public static SubjectByFactory Create(string message) =&gt; new SubjectByFactory(message);
    
        SubjectByFactory() : this(null) {} // Used by serializer.
    
        SubjectByFactory(string message) =&gt; Message = message;
    
        public string Message { get; set; }
    }
</pre>


<pre lang="cs">
    IExtendedXmlSerializer serializer = new ConfigurationContainer().EnableAllConstructors()
                                                                    .Create();
    SubjectByFactory subject = SubjectByFactory.Create(&quot;Hello World!&quot;);
    string contents = serializer.Serialize(subject);
    // ...
</pre>


<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;SubjectByFactory xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Extensibility;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Message&gt;Hello World!&lt;/Message&gt;
    &lt;/SubjectByFactory&gt;
</pre>

<h2>Parameterized Members and Content</h2>

<p>Taking this concept bit further leads to a favorite feature of ours in <code>ExtendedXmlSerlializer</code>. The classic serializer only supports parameterless public constructors. With <code>ExtendedXmlSerializer</code>, you can use the <code>EnableParameterizedContent</code> call to enable parameterized parameters in the constructor that by convention have the same name as the property for which they are meant to assign:</p>

<pre lang="cs">
    public sealed class ParameterizedSubject
    {
        public ParameterizedSubject(string message, int number, DateTime time)
        {
            Message = message;
            Number = number;
            Time = time;
        }
    
        public string Message { get; }
        public int Number { get; }
        public DateTime Time { get; }
    }
</pre>


<pre lang="cs">
    IExtendedXmlSerializer serializer = new ConfigurationContainer().EnableParameterizedContent()
                                                                    .Create();
    ParameterizedSubject subject = new ParameterizedSubject(&quot;Hello World!&quot;, 123, DateTime.Now);
    string contents = serializer.Serialize(subject);
    // ...
</pre>


<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;ParameterizedSubject xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Extensibility;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Message&gt;Hello World!&lt;/Message&gt;
      &lt;Number&gt;123&lt;/Number&gt;
      &lt;Time&gt;2018-05-26T11:52:19.7551187-04:00&lt;/Time&gt;
    &lt;/ParameterizedSubject&gt;
</pre>

<h2>Tuples</h2>

<p>By enabling parameterized content, it opens up a lot of possibilities, like being able to serialize Tuples. Of course, serializable Tuples were introduced recently with the latest version of C#. Here, however, you can couple this with our member-naming funtionality and provide better naming for your tuple properties:</p>

<pre lang="cs">
    IExtendedXmlSerializer serializer = new ConfigurationContainer().EnableParameterizedContent()
                                                                    .Type&lt;Tuple&lt;string&gt;&gt;()
                                                                    .Member(x =&gt; x.Item1)
                                                                    .Name(&quot;Message&quot;)
                                                                    .Create();
    Tuple&lt;string&gt; subject = Tuple.Create(&quot;Hello World!&quot;);
    string contents = serializer.Serialize(subject);
    // ...
</pre>


<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;Tuple xmlns:exs=&quot;https://extendedxmlserializer.github.io/v2&quot; exs:arguments=&quot;string&quot; xmlns=&quot;https://extendedxmlserializer.github.io/system&quot;&gt;
      &lt;Message&gt;Hello World!&lt;/Message&gt;
    &lt;/Tuple&gt;
</pre>

<h2>Experimental Xaml-ness: Attached Properties</h2>

<p>We went ahead and got a little cute with v2 of <code>ExtendedXmlSerializer</code>, adding support for Attached Properties on objects in your serialized object graph. But instead of constraining it to objects that inherit from <code>DependencyObject</code>, *every* object can benefit from it. Check it out:</p>

<pre lang="cs">
        sealed class NameProperty : ReferenceProperty&lt;Subject, string&gt;
        {
            public const string DefaultMessage = &quot;The Name Has Not Been Set&quot;;
    
            public static NameProperty Default { get; } = new NameProperty();
            NameProperty() : base(() =&gt; Default, x =&gt; DefaultMessage) {}
        }
    
        sealed class NumberProperty : StructureProperty&lt;Subject, int&gt;
        {
            public const int DefaultValue = 123;
    
            public static NumberProperty Default { get; } = new NumberProperty();
            NumberProperty() : base(() =&gt; Default, x =&gt; DefaultValue) {}
        }
    
</pre>


<pre lang="cs">
    IExtendedXmlSerializer serializer = new ConfigurationContainer()
                                        .EnableAttachedProperties(NameProperty.Default, NumberProperty.Default)
                                        .Create();
    Subject subject = new Subject {Message = &quot;Hello World!&quot;};
    subject.Set(NameProperty.Default, &quot;Hello World from Attached Properties!&quot;);
    subject.Set(NumberProperty.Default, 123);
    
    string contents = serializer.Serialize(subject);
    // ...
</pre>


<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;Subject xmlns=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Extensibility;assembly=ExtendedXmlSerializer.Samples&quot;&gt;
      &lt;Message&gt;Hello World!&lt;/Message&gt;
      &lt;NameProperty.Default&gt;Hello World from Attached Properties!&lt;/NameProperty.Default&gt;
      &lt;NumberProperty.Default&gt;123&lt;/NumberProperty.Default&gt;
    &lt;/Subject&gt;
</pre>

<p>(Please note that this feature is experimental, but please try it out and let us know what you think!)</p>
<p></p>
<h2>Experimental Xaml-ness: Markup Extensions</h2>

<p>Saving the best feaure for last, we have experimental support for one of Xaml's greatest features, Markup Extensions:</p>

<pre lang="cs">
    sealed class Extension : IMarkupExtension
    {
        const string Message = &quot;Hello World from Markup Extension! Your message is: &quot;, None = &quot;N/A&quot;;
    
        readonly string _message;
    
        public Extension() : this(None) {}
    
        public Extension(string message)
        {
            _message = message;
        }
    
        public object ProvideValue(IServiceProvider serviceProvider) =&gt; string.Concat(Message, _message);
    }
</pre>


<pre lang="cs">
    string contents =
        @&quot;&lt;?xml version=&quot;&quot;1.0&quot;&quot; encoding=&quot;&quot;utf-8&quot;&quot;?&gt;
            &lt;Subject xmlns=&quot;&quot;clr-namespace:ExtendedXmlSerializer.Samples.Extensibility;assembly=ExtendedXmlSerializer.Samples&quot;&quot;
            Message=&quot;&quot;{Extension &#39;PRETTY COOL HUH!!!&#39;}&quot;&quot; /&gt;&quot;;
    IExtendedXmlSerializer serializer = new ConfigurationContainer().EnableMarkupExtensions()
                                                                    .Create();
    Subject subject = serializer.Deserialize&lt;Subject&gt;(contents);
    Console.WriteLine(subject.Message); // &quot;Hello World from Markup Extension! Your message is: PRETTY COOL HUH!!!&quot;
</pre>

<p>(Please note that this feature is experimental, but please try it out and let us know what you think!)</p>
<p></p>
<h2>How to Upgrade from v1.x to v2</h2>

<p>Finally, if you have documents from v1, you will need to upgrade them to v2 to work. This involves reading the document in an instance of v1 serializer, and then writing it in an instance of v2 serializer. We have provided the <code>ExtendedXmlSerializer.Legacy</code> nuget package to assist in this goal.</p>

<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;&lt;ArrayOfSubject&gt;&lt;Subject type=&quot;ExtendedXmlSerializer.Samples.Introduction.Subject&quot;&gt;&lt;Message&gt;First&lt;/Message&gt;&lt;Count&gt;0&lt;/Count&gt;&lt;/Subject&gt;&lt;Subject type=&quot;ExtendedXmlSerializer.Samples.Introduction.Subject&quot;&gt;&lt;Message&gt;Second&lt;/Message&gt;&lt;Count&gt;0&lt;/Count&gt;&lt;/Subject&gt;&lt;Subject type=&quot;ExtendedXmlSerializer.Samples.Introduction.Subject&quot;&gt;&lt;Message&gt;Third&lt;/Message&gt;&lt;Count&gt;0&lt;/Count&gt;&lt;/Subject&gt;&lt;/ArrayOfSubject&gt;
</pre>


<pre lang="cs">
    
    ExtendedXmlSerialization.ExtendedXmlSerializer legacySerializer = new ExtendedXmlSerialization.ExtendedXmlSerializer();
    string content = File.ReadAllText(@&quot;bin\Upgrade.Example.v1.xml&quot;); // Path to your legacy xml file.
    List&lt;Subject&gt; subject = legacySerializer.Deserialize&lt;List&lt;Subject&gt;&gt;(content);
    
    // Upgrade:
    IExtendedXmlSerializer serializer = new ConfigurationContainer().Create();
    string contents = serializer.Serialize(new XmlWriterSettings {Indent = true}, subject);
    File.WriteAllText(@&quot;bin\Upgrade.Example.v2.xml&quot;, contents);
    // ...
</pre>


<pre lang="xml">
    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;List xmlns:ns1=&quot;clr-namespace:ExtendedXmlSerializer.Samples.Introduction;assembly=ExtendedXmlSerializer.Samples&quot; xmlns:exs=&quot;https://extendedxmlserializer.github.io/v2&quot; exs:arguments=&quot;ns1:Subject&quot; xmlns=&quot;https://extendedxmlserializer.github.io/system&quot;&gt;
      &lt;Capacity&gt;4&lt;/Capacity&gt;
      &lt;ns1:Subject&gt;
        &lt;Message&gt;First&lt;/Message&gt;
        &lt;Count&gt;0&lt;/Count&gt;
      &lt;/ns1:Subject&gt;
      &lt;ns1:Subject&gt;
        &lt;Message&gt;Second&lt;/Message&gt;
        &lt;Count&gt;0&lt;/Count&gt;
      &lt;/ns1:Subject&gt;
      &lt;ns1:Subject&gt;
        &lt;Message&gt;Third&lt;/Message&gt;
        &lt;Count&gt;0&lt;/Count&gt;
      &lt;/ns1:Subject&gt;
    &lt;/List&gt;
</pre>

<h2>History</h2>


<ul>
<li>2017-11-14 - v2.0.0 - Rewritten version</li>
</ul>

<h2>Authors</h2>


<ul>
<li><code>Wojciech Nagórski <https://github.com/wojtpl2></code>__</li>
<li><code>Mike-EEE <https://github.com/Mike-EEE></code>__</li>
</ul>