Serializing and Deserializing Objects…to and from…XML
Over on the Asp.Net forums I recently had the opportunity* to help a few lost souls by showing them how to serialize objects to XML and deserialize the XML back into objects. Since the question has come up more than once, I decided to BLOG it so I could refer similar questions in the future to this post.
*I use the word opportunity because by helping others I am forced to think hard about the technology and to think even harder about how to communicate the technology. It makes me better at what I do. All right then, enough after-school-special-feel-good-about-yourself-I'm-ok-you're-ok fluffy nonsense… on with the code:
Here is a simple class I'm going to work with. It has both properties and fields:
public class MyClass
{ // old school property
private int _Age;
public int Age
{ get { return _Age; } set { _Age = value; } }
// new school property
public bool Citizen { get; set; }
// there's nothing wrong with using fields
public string Name;
}
Here are the two functions to Serialize and Deserialize an object:
/// ---- SerializeAnObject -----------------------------
/// <summary>
/// Serializes an object to an XML string
/// </summary>
/// <param name="AnObject">The Object to serialize</param>
/// <returns>XML string</returns>
public static string SerializeAnObject(object AnObject)
{ XmlDocument XmlDoc = new XmlDocument();
XmlSerializer Xml_Serializer = new XmlSerializer(AnObject.GetType());
MemoryStream MemStream = new MemoryStream();
try
{ Xml_Serializer.Serialize(MemStream, AnObject);
MemStream.Position = 0;
XmlDoc.Load(MemStream);
return XmlDoc.InnerXml;
}
finally
{ MemStream.Close();
}
}
/// ---- DeSerializeAnObject ------------------------------
/// <summary>
/// DeSerialize an object
/// </summary>
/// <param name="XmlOfAnObject">The XML string</param>
/// <param name="ObjectType">The type of object</param>
/// <returns>A deserialized object...must be cast to correct type</returns>
public static Object DeSerializeAnObject(string XmlOfAnObject, Type ObjectType)
{ StringReader StrReader = new StringReader(XmlOfAnObject);
XmlSerializer Xml_Serializer = new XmlSerializer(ObjectType);
XmlTextReader XmlReader = new XmlTextReader(StrReader);
try
{ Object AnObject = Xml_Serializer.Deserialize(XmlReader);
return AnObject;
}
finally
{ XmlReader.Close();
StrReader.Close();
}
}
Here is some sample code showing how to use the functions.
Note: I keep these functions (and other functions) in a class I call MiscUtilities. You will have to modify the code…depending on where you place the functions.
protected void Button1_Click(object sender, EventArgs e)
{ // create and initialize an object
MyClass Test = new MyClass();
Test.Age = 18;
Test.Name = "Rocky Balboa";
Test.Citizen = true;
// Serialize it
String XML;
XML = MiscUtilities.SerializeAnObject(Test);
// Deserialize it
MyClass Test2;
Test2 = MiscUtilities.DeSerializeAnObject(XML, typeof(MyClass)) as MyClass;
// TODO: Get a cup of coffee and bask in the glory of rock solid code.
}
Here is what the XML string looks like (after formatting):
<?xml version="1.0"?>
<MyClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Name>Rocky Balboa</Name>
<Age>18</Age>
<Citizen>true</Citizen>
</MyClass>
There are limitations: XmlSerializer does not serialize private fields, methods, indexers or read-only fields.
Once you have the XML string, you can email it, store it in a database, save it to disk, or…print a copy of it and have your mom tape it to the refrigerator next to the turkey picture you made in the second grade by tracing around your hand with a Crayola crayon.
I hope someone finds this useful.