• Home
• Articles
  • All Articles
  • Search Articles
  • Recent Articles
• Training
• Portfolio
  • Applications
    • Find Your Smart Phone
    • E Training Project
    • CMSLite
    • LWB Refractories
    • Best 3g Mobile Phones
  • Websites
    • www.churchdalecanalcruises.co.uk
    • www.rugeleychessclub.co.uk
    • www.katmaid.co.uk
    • www.taylorspoultryservices.co.uk
    • www.swarfegaexperience.co.uk
    • www.alliance-leicester.co.uk
    • www.planet-health.co.uk
    • www.floridahealth.co.uk
    • www.emcat.org.uk
    • www.emtex.org.uk
    • www.doff.co.uk
    • www.keith-hall.co.uk
    • www.money-minder.co.uk
    • www.raspberryvillage.co.uk
    • www.churchills-on-line.com
    • www.sheda.org.uk
    • www.mmbs.co.uk
    • www.emnet.co.uk
    • www.brownejacobson.com
    • www.bsga.co.uk
    • www.megabowl.co.uk
    • www.dishley.co.uk
    • www.katnip.co.uk
    • www.eon-uk.com
    • www.dudley.nhs.uk
  • Other
• Contact

Paxium is the company owned by myself, Dave Amour and used for providing IT contract development services including

• Application development - Desktop, Web, Services - with Classic ASP, Asp.net WebForms, Asp.net MVC, Asp.net Core
• Html, Css, JavaScript, jQuery, React, C#, SQL Server, Ado.net, Entity Framework, NHibernate, TDD, WebApi, GIT, IIS
• Database schema design, implementation & ETL activities
• Website design and hosting including email hosting
• Training - typically one to one sessions
• Reverse Engineering and documentation of undocumented systems
• Code Reviews
• Performance Tuning
• Located in Cannock, Staffordshire

Serialization of objects as XML or Binary Data

In .net applications there is a very useful feature which allows us to serialise an object as either xml or binary data.

What that means is that we can take an instance of an object running in our program and with just a few lines of code we can persist this to disk for example so that later on, perhaps even after we have closed down the program and opened it up another day, we are able to read that data back from disk and recreate our object just as it was when we serialised it.

This is incredibly useful particularly since we do not have to persist to disk.  We can serialise our object to a stream which gives us endless possibiliies.  For example we can serialise an object and transfer it across a network and recreate it at the other end - just like the transporters on Star Trek!

As well as being able to serialise to streams, we can also serialise to TextWriters and StreamWriters.  Consider the following entire console application when we are able to create an instance of a Person object and then serialise it to the Console in really just 2 lines of code!

 The output should look like this:

Deserialisation of an object is pretty much the reverse process but we cannot do that yet until we have something to read our data from.  We can't do it from the console right!

There are diferent serialisation classes and different methods for using those for serialising in different ways and to different objects - eg Streams, StreamWriters etc.  We won't cover all of these but rather we will look at a couple of different ways of doing things after which you should understand things enough to off and have a yourself with the other options.

Our other option of format encoding besides XML is binary.  Our example above modified shows us how easy we can do this as follows:

Our output when we run the above program should look like this:

Ok so now lets have a look at this in more detail with an explanation of the code.

We shall build a Windows Forms application to do some tinkering.  This will look like this so ahead and create this form.

If you want to cheat and can't be bothered to do all this then feel free to use my designer generated code as follows:

Ok so the purpose of this program should now be fairly apparent.  We are going  to enter a Firstname, Surname and Age into the form fields and then click Save.  This will create an instance of a Person class with property values corresponding to those entered on the form.   The person object will then be serialised to disk either as XML or binary depending on which radio button is selected on the form.  The location of the file we will serialise to is specified in the Data File Path textbox.

So we can then run the program and save a person object.  We can then close the program and start it up again and this time click on the Load button.  Providing we have selected the correct format then the object should be deserialised and the form fields repopulated.

So the first bit of code we need to write is a Serialise method which will take a person object as a parameter and serialise it.

This method should look like this:

Now in order for any of this to work we need to specify some namespaces with using statements. These will be as follows:

So this method has 3 parts or blocks of code.  The first bit is executed if the XmlFormat radio button is ticked.  This creates an instance of the class which does our xml serialisation which is the XmlSerialiser class.  This takes a type as a parameter to the constructor.  We then call the Serialize method of this object which in this example takes 2 parameters - there are many overloads availabel here so feel free to have a look and try those out too.  The first is a stream which we get by creating a new StreamWriter pointing at our file.  The second parameter is the obejct we want to serialise and that's pretty much all there is to it.  If this works ok then you should now have a text file on disk which should look something like this:

The second block of code will run if we have ticked the radio button to choose a binary format.

This then creates an instance of a BinaryFormatter object which comes from the System.Runtime.Serialization.Formatters.Binary namespace.

We then create a Stream object by using the static method of the System.IO.File class.  This is then used as one of the arguments of the Serialise method of our BinaryFormatter object, the other parameter being the object we want to serialise.  And that's all there is to it.  The Serialisation methods and classes are so well encapsulated that it really is very little work for us to use.

If you run this sucessfully and then open the file in notepad then you should see something like this:

The third block of code is just to give the user a message if they have not selected one of the radio buttons to specify which format they want to serialise in.

Ok so now we need to look at the reverse process.

First we can write the code for the event handler when our Load button is clicked.  This should look like this:

So all we are doing here is as follows:

• Create an instance of a Person
• Set that instance to the object returned from a method called DeSerialiseFromXML if the XML Format radio button is ticked
• Set that instance to the object returned from a method called DeSerialiseFromBinary if the Binary Format radio button is ticked
• Set the form fields to the corresponding properties of our person object
• Show the user an error message if they do not choose a format
• Wrap the whole lot in a try catch to show a handled exception message should somethign wrong

Something will in fact wrong if we try and deserialise an xml file using our binary deserialising code and vice versa.

Ok so now we can write our two methods to do our XML deserialisation and our Binary deserialisation.  Both of these need to return an instance of a Person class.  The first of these methods looks like this:

So all is does is create an instance of our BinaryFormatter object (It's the same object used for serialisation and deserialisation).  We then create an instance of a person class.  The Deserialize method of the BinaryFormater object needs a stream as a parameter so we create one by using the OpenRead method of teh System.IO.File class which points to our file.

We then set our person object to the object returned from the Deserialize method.  Since this method can work with many objects it of course doesn't return a person object bit returns a System.Object and so we need to cast it to a person adn then we simply return this person object to teh code which called this method.

The XML method is as follows:

This works pretty much the same (from a logic point of view) as the previous method so this should be self explanatory.

There are some further and interesting things you can do with serialisation.  Xml serialisation for exampel can be used in many way.  For exampel you may wish to serialise some object in xml and then use that as part of some other xml document rather than just serialising and deserialising it.

We will now have a quick look at some things you can and can't do with serialisation.

With binary serialisation for example it is possible to serialise many object to the same stream in sequential order.

To perform these exercises you will need to add two new classes to your project.  These classes are called Animal and Car and look like this:

Animal Class

Car Class 

If you now create the following and execute it you will see that we are able to serialise a person, animla and car and then deserilse them back as long as we do it in exactly the same order though.  To test this try chnaging the deserialisation order so that we try and retrieve a person then a car and then an animal and when you run this you will see that an exception is raised.

Out of interest, lets have a look at the binary file created by the above program.  You can either open this in Notepad but you will get a much better look at the contents if you open this with Visual Studio when you will see something like this:

So looking at this we can clearly see the 3 chunks of data representing our objects.

Now lets have a look at doing a simillar thing but with an xml format.

We will first start off with just code to do the serialisation.  Create your program as follows and run it.

So straight away you should be able that this is problematic as our xml document is not well formed.  For starters it has 3 xml lines - the lines which normally appear just once at the top of an xml file.  Even if there was only one of these then the document would still not be well formed since it would have no top level root node.

So this approach to multiple object serialisation is not an option.  You would need to serialise each object into it's own stream or file.  Alternativeley if you create another composite object which had an instance of a person, animal and car as properties then you could just serialise that one object.

So thats enough for now.  There are many more interesting things you can do with serialisation so and have a tinker.

Any comments are welcome via the form below.