Serializable Extra Types for .NET 4

You may follow this code @ 


This is an updated article and code base from my original publication [Serialization for Rapid Application Development: A Better Approach] here at CodeProject.  After several years of growth in ability and advances in technology I decided it was time to update that code base and article for use in .Net 4.  The result of this is a much smaller code base, unit tests to back them up and fixes to some issues concerning discovery within a web environment.  


In short, the problems with the XmlSerializer that existed when I wrote the first article, still exist today. They are classic issues that there is still no unified approach in dealing with. The major problem is still how do you resolve unknown classes when serializing and deserializing. 

There have been several attempts that I've followed over the years to get around this, anywhere from the creation of entire frameworks like YAXLib to instructions on how to make use of the IXmlSerializable interface at various levels of sophistication.

With all of these solution, the major problem from a developer perspective that has always crept in is cumbersomeness of the implementation.  IXmlSerializable asks the developer to write some form of a customized implementation per class.  YAXLib and others asks the developer to use different attributes or handle outputs that don't look like the clean(ish) xml generated by the XmlSerializer.  The [XmlInclude(Type type)] attibute demands that all types to be serialized be within the same library. None of them (that I know of) in my opinion relieves the developer from the tedium of working with these solutions. 

Goals Realized 

Serializable Extra Types is designed to make be as thoughtless as possible with an absolute minimum of develop consideration.  What it does is make use of the standard XmlSerializer and a slightly un-hyped overloaded constructor it has to incorporate extra type definitions for use in type resolution during serialization and deserialization. 

Its actually a very simple idea.  Keep a list of all the possible types that the XmlSerializer may have need of during a serialization/deserialization process.  Register those types using Attribute adornments and provide some extension methods to make incorporating those lists thoughtless to the developer.  

It works under a parent child relationship.  I can best describe it as saying, its the reverse of the XmlInclude attribute.  The XmlInclude attribute is placed on a class to give the serializer knowledge of other classes when serializing the class that is adorned.  SerializableExtraType is placed on a class to give the other class knowledge of the adorned class when the other class is serialized. 


XmlInclude = Parent => Child 

SerializableExtraType = Child => Parent 

This allows the SerializableExtraTypes code to integrate related classes across libraries.  Additionally, I have exposed a method by which you may register additional relationships at runtime.  This solves any situation that you may come across with libraries and applications having complex implied relationships.   

Using the code  

The code available in the download and at codeplex site. Both have a series of test libraries and a consuming test project that show usage very well.  Here I will outline the quick and dirty of how to make use of it.  

First adorn a class with the required attribute like this: 

// example 1 of registering class and all derived classes
// example 2 of registering class with an unrelated class
// example 3 of registering with multiple classes in same attribute
[SerializableExtraType(typeof(ClassOne), typeof(ClassTwo))]
public class Foo { public Foo() {} } 

The extension methods to make use of the SerializableExtraTypes is under System.Xml.Serialization

Now make use of the extension methods to serialize and deserialize objects.

// example 1 assuming that ClassOne and ClassTwo inherit from Foo
string xml = new Foo { ClassList = {new ClassOne(), new ClassTwo(), }, }.SerializeEx();
Foo obj = "<Foo><ClassList><ClassOne /><ClassTwo /></Foo>".DeserializeEx<Foo>();  
// example 2 assuming that Foo bears no relationship with SomethingElse
string xml = new SomethingElse { ObjectList = { new Foo(), new Foo(), }, }.SerializeEx();
SomethingElse obj = "<SomethingElse><ArrayOfObject><Foo /><Foo /></ArrayOfObject></SomethingElse>".DeserializeEx<SomethingElse>();

There is more functionality built into the code base but that is a quick and dirty sample.  Please take a look at the download for further examples.  


This is the second publication of this method. Please send any comments or suggestions on how to improve it. You can email me at