Serializing a List Containing Disjoint Class Instances

Posted on March 22, 2019 Updated on March 22, 2019

Serializing a list, all of the same class, is easy. Serializing a list of different class instances is not. (All class instances implement the same interface.) Since I couldn’t readily find how to do this anywhere else, I decided to write-up my results and share. Maybe I’ll need it again some day.

Just to make it perfectly clear, I want to serialize a list like the following

var serializeThis = new List<IActivity> {
   new Sport { Name = "Golf", Season = "Summer" },
   new Work { Name = "Dig ditches", MaxSalaray = 15000 },
   new Sport { Name = "Mountain Biking", Season = "Summer" },
   new Work { Name = "Wash dishes", MaxSalaray = 10000 }
};

Key Points

• Use DataContractSerializer to do the work
• When you initialize your serializer, provide a list of Types representing the class types in your list
• Mark your classes with a [DataContract] attribute
• Mark the class members to serialize with [DataMember] attribute
• Remember to add a reference to System.Runtime.Serialization

Note that the list contains Sport objects and Work objects; both implement IActivity. “Normal” serialization techniques won’t work here.

The Code

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Text;
using System.Windows;
using System.Xml;

namespace SerializeListOfInterfaceObjects {
    /// <summary>
    /// Illustrates how to serialize/deserialize a list of objects of different classes,
    /// all implementing the same interface
    /// </summary>
    /// <remarks>
    /// Use DataContracts and DataContracSerializer to do the work. Also use a MemoryStream
    /// to hold the result.
    /// </remarks>
    public partial class MainWindow : Window {
        public MainWindow() {
            InitializeComponent();
        }

        /// <summary>This is our practice data</summary>
        private List<IActivity> ListToSerialize {
            get {
                //Note the list has two different kinds of class instances:
                return new List<IActivity> {
                    new Sport { Name = "Golf", Season = "Summer" },
                    new Work  { Name = "Dig ditches", MaxSalaray = 15000 },
                    new Sport { Name = "Mountain Biking", Season = "Summer" },
                    new Work  { Name = "Wash dishes", MaxSalaray = 10000 }
                };
            }
        }

        /// <summary>
        /// Send the list to a memory stream as xml, use a StreamReader to read from 
        /// that MemoryStream and display the resulting text in the textbox
        /// </summary>
        /// <param name="sender">The button</param>
        /// <param name="e">Event args</param>
        private void BtnSerialize_Click(object sender, RoutedEventArgs e) {
            List<IActivity> serializeThis = ListToSerialize;

            //Note the list of class types; this tells the 
			//DataContractSerializer what to expect:
            var mySerializer = new DataContractSerializer(serializeThis.GetType(), 
                                        new Type[] { typeof(Sport), typeof(Work) });
            using (var memStr = new MemoryStream()) {
                mySerializer.WriteObject(memStr, serializeThis);

                memStr.Seek(0, SeekOrigin.Begin);

                using (var sw = new StreamReader(memStr)) {
                    var theText = sw.ReadToEnd();
                    txtSerialized.Text = theText;
                }
            }
            btnDeSerialize.IsEnabled = true;
        }

        /// <summary>
        /// Read the text in the textbox and deserialize it
        /// </summary>
        /// <param name="sender">The button</param>
        /// <param name="e">Event args</param>
        private void BtnDeserialize_Click(object sender, RoutedEventArgs e) {

            List<IActivity> activityList = null;
            //We will use a UTF8Encoding to write to this memory stream, 
            //the DataContractSerializer will read from it
            using (var memStr = new MemoryStream()) {
                UTF8Encoding utf8Enc = new UTF8Encoding();
                byte[] byteThis = utf8Enc.GetBytes(txtSerialized.Text);
                memStr.Write(byteThis, 0, byteThis.Length);
                memStr.Seek(0, SeekOrigin.Begin);

                //The MemoryStream has the data, the DataContractReader will now read from it:
                XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(memStr, 
                                                new XmlDictionaryReaderQuotas());
                var ser = new DataContractSerializer(typeof(List<IActivity>), 
                                        new Type[] { typeof(Sport), typeof(Work) });
                activityList = (List<IActivity>)ser.ReadObject(reader, true);
                reader.Close();
            }

            //activityList is now magically populated with a list of 
            //IActivity objects; display on screen:
            txtSerializedResult.Clear();
            foreach (IActivity act in activityList) {
                txtSerializedResult.Text += act.ToString() + "\n";
            }
        }

        /// <summary>
        /// Send the same list to a file
        /// </summary>
        /// <param name="sender">The button</param>
        /// <param name="e">Event args</param>
        private void BtnSerializeToFile_Click(object sender, RoutedEventArgs e) {
            var serializeThis = ListToSerialize;

            using (FileStream fs = new FileStream("ActivityList.xml", FileMode.Create)) {
                var mySerializer = new DataContractSerializer(serializeThis.GetType(), 
                                        new Type[] { typeof(Sport), typeof(Work) });
                mySerializer.WriteObject(fs, serializeThis);
            }

            btnDeserializeFromFile.IsEnabled = true;
            txtMessage.Text = "Serialized to file 'ActivityList.xml'";
        }

        /// <summary>
        /// Read the file we just wrote and deserialize into a list again
        /// </summary>
        /// <param name="sender">The button</param>
        /// <param name="e">Event args</param>
        private void BtnDeserializeFromFile_Click(object sender, RoutedEventArgs e) {
            List<IActivity> lstOfActivities = new List<IActivity>();

            using (FileStream fs = new FileStream("ActivityList.xml", FileMode.Open)) {
                var mySerializer = new DataContractSerializer(lstOfActivities.GetType(), 
                    new Type[] { typeof(Sport), typeof(Work) });
                lstOfActivities = (List<IActivity>)mySerializer.ReadObject(fs);
            }

            //Display the deserialized result:
            txtFromFile.Clear();
            foreach (var activity in lstOfActivities)
                txtFromFile.Text += activity.ToString() + "\n";
        }

    }

    ////////////////////////////////////////////////////////////////////////////
    /// <summary>We will serialize a list of these</summary>
    interface IActivity {
        string Name { get; set; }
    }

    ////////////////////////////////////////////////////////////////////////////
    /// <summary>This will be one of the items in the list we serialize</summary>
    /// <remarks>The following attribute enables the DataContractSerializer to work</remarks>
    [DataContract(Name = "Sport", Namespace = "http://www.TryStuff.com")]
    class Sport : IActivity {
        /// <summary>A parameterless constructor is required</summary>
        public Sport() { }

        /// <summary>Members with the following attribute will be serialized:</summary>
        [DataMember]
        public string Name { get; set; }
        [DataMember]
        public string Season { get; set; }

        public override string ToString() {
            return $"Name: {Name}, Season: {Season}";
        }
    }

    ////////////////////////////////////////////////////////////////////////////
    /// <summary>Another class implementing the same interface</summary>
    [DataContract(Name = "Work", Namespace = "http://www.TryStuff.com")]
    class Work : IActivity {
        public Work() { }

        [DataMember]
        public string Name { get; set; }
        [DataMember]
        public int MaxSalaray { get; set; }

        public override string ToString() {
            return $"Name: {Name}, MaxSalary:{MaxSalaray}";
        }
    }
}

Highlight: The Code That Does the Work

var mySerializer = new DataContractSerializer(serializeThis.GetType(), 
                            new Type[] { typeof(Sport), typeof(Work) });
using (var memStr = new MemoryStream()) {
    mySerializer.WriteObject(memStr, serializeThis);

Note the Type array I provide to the serializer, that tells what types to expect. You will need to replace this with a list of your own types, unfortunately it can’t autodetect your class types.

The serializer needs to send your text to a stream; MemoryStream is a handy place to send it when all you want to do is display it on screen. You can then use a StreamReader to get the XML out of the MemoryStream and do whatever you want with it.

Marking-Up My Classes

I had to decorate my classes with the following attribute:

[DataContract(Name = "Sport", Namespace = "http://www.TryStuff.com")]
class Sport : IActivity { ... }

And I had to decorate the class members to serialize with a [DataMember] tag. You can use the attribute on public and private members, but only certain data types are serializable. Anything you don’t want serialized –> omit the tag.

Possible Alternate Technique

I tried implementing the IXmlSerializable interface on my classes; that interface allows you to control how your classes are serialized. It seemed like it might work, but it didn’t. The bottom line is you will get an error to the effect of “A parameterless constructor is required“.

Since you can’t specify a constructor in an interface, this prevents you from serializing a list of interface intstances via this technique. Potentially you could the technique with abstract classes instead of interfaces; I was not in a position to refactor my code to try.

Summary

The DataContractSerializer will send your list to XML in a fairly automatic way. The Microsoft example shows how to do this (to a file) out-of-the-box. However, it doesn’t discuss handling different classes all in the same list. In order to do that, you need to provide a parameter specifying a list of types to serialize.

Unlike the MS example, if you want to manipulate your serialized XML without sending it to a file, you need to use a memory stream. You can read the results using a StreamReader (which is a lot easier than the examples Microsoft has on MSDN).

Reversing the process is fairly straightforward, the tricky part was I had to use a UTFEncoding to read from the memory stream; for some reason, XML doesn’t like to deserialize from Unicode, even though going the other way Unicode works perfectly fine. I didn’t experiment using a StreamReader, instead of a UTF8Encoding, but I’ll guess it won’t work.

Download the Code

You can download my code here, note that DropBox will ask you to create a new (free) account in order to access it.