LinkedList <T> ne peut pas être sérialisé à l'aide de XMLSerializer

Question

Une LinkedList can't be serialized en utilisant XmlSerializer.

Maintenant, comment enregistrer/récupérer des données d'un objet sérialisé LinkedList. Dois-je implémenter la sérialisation personnalisée?

Ce que j'ai essayé de faire:

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); } 
    } 
} 

Ce que j'ai obtenu (addind nom, l'âge et certains éléments du 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> 

Ainsi, les éléments de la liste chaînée n'a pas été sérialisé ... :(

Answer 1

Une possibilité serait la création d'une collection sérialisable qui contient les mêmes objets que la liste chaînée, par exemple (non testé):

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

Puis sérialiser list à la place. Cela ne va pas créer beaucoup de surcharge si Foo est un type de référence, et vous vous fichez du fait que les insertions/suppressions sont maintenant plus chères, car vous n'utilisez que le List<T> pour contenir des références au données à des fins de sérialisation et de désérialisation. Lorsque vous le sortez du flux sérialisé, vous pouvez simplement le retourner dans un LinkedList<T> pour obtenir tous les avantages que vous utilisiez pour une liste liée en premier lieu.

---

Voici une petite application de console que je viens de fouetter pour démontrer. Je l'ai fait dans VS2008, mais je ne pense pas avoir utilisé quelque chose de surprenant - juste la syntaxe d'initialisation de tableau pour sauver de l'espace vertical.

Exemple de 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); } 
    } 
} 

Et le principal code d'application:

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; 
    } 
} 

Ce kicks ce qui suit sur la 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>