LinkedList<T> can not be serialized using the XMLSerializer

A LinkedList can't be serialized using XmlSerializer.

Now, how to however save/retrieve data from a serialized objet LinkedList. Should I implement custom serialization?

What I tried to do:

using System.Xml.Serialization;

[Serializable()]
public class TestClass
{
    private int _Id;
    private string _Name;
    private int _Age;
    private LinkedList<int> _linkedList = new LinkedList<int>();

    public string Name {
        get { return _Name; }
        set { _Name = value; }
    }
    
    public string Age {
        get { return _Age; }
        set { _Age = value; }
    }
    
    [XmlArray()]
    public List<int> MyLinkedList {
        get { return new List<int>(_linkedList); }
        set { _linkedList = new LinkedList<int>(value); }
    }
}

What I've obtained(addind name, age and some items in the mylinkedlist):

<开发者_开发知识库;?xml version="1.0"?>
<TestClass 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>testName</Name>
  <Age>10</Age>
  <MyLinkedList />
</TestClass>

So, the items in the linked list hadn't been serialized... :(

---

One possibility would be the creation of a serializable collection that contains the same objects as the linked list. E.g. (untested):

LinkedList<Foo> ll = PopulateLinkedList();
List<Foo> list = new List<Foo>(ll);

Then serialize list instead. This isn't going to create a lot of overhead if Foo is a reference type, and you don't care about the fact that insertions/deletions are now more expensive b/c you're only using the List<T> to hold references to the data for serialization and deserialization purposes. When you pull it out of the serialized stream, you can just turn it back into a LinkedList<T> to get all those advantages you were using a linked list for in the first place.

---

Here's a little console app I just whipped up to demonstrate. I did it in VS2008, but I don't think I used anything surprising-- just the array initialization syntax to save some vertical space.

Sample Code:

[Serializable]
public class MyClass
{
    private string name;
    private int age;
    private LinkedList<int> linkedList = new LinkedList<int>();

    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    public int Age
    {
        get { return age; }
        set { age = value; }
    }

    [XmlArray]
    public List<int> MyLinkedList
    {
        get { return new List<int>(linkedList); }
        set { linkedList = new LinkedList<int>(value); }
    }
}

And the main application code:

class Program
{
    static void Main(string[] args)
    {
        MyClass c = new MyClass();

        c.Age = 42;
        c.Name = "MyName";
        c.MyLinkedList = new List<int>() { 1, 4, 9 }; // Your property impl requires this be set all at once, not one element at a time via the property.

        XmlSerializer s = new XmlSerializer(typeof(MyClass));
        StringWriter outStream = new StringWriter();
        s.Serialize(outStream, c);

        Console.Write(outStream.ToString());

        return;
    }
}

This kicks the following out to the console:

<?xml version="1.0" encoding="utf-16"?>
<MyClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>MyName</Name>
  <Age>42</Age>
  <MyLinkedList>
    <int>1</int>
    <int>4</int>
    <int>9</int>
  </MyLinkedList>
</MyClass>