XmlSerializer élément de liste Nom de l'élément

Question

J'ai une classe PersonList

[XmlRoot("Persons")] 
PersonList : List<Human> 

quand je sérialisez au format XML, par défaut, il produira quelque chose comme ceci:

<Persons> 
    <Human>...</Human> 
    <Human>...</Human> 
</Persons> 

Ma question est ce qui doit être fait afin de changer l'élément Human à Person dans la sortie? de sorte que la sortie serait:

<Persons> 
    <Person>...</Person> 
    <Person>...</Person> 
</Persons> 

et, comment désérialiser le XML ci-dessus à l'objet de classe PersonList?

par les conseils de Nick, voici mon code d'essai:

[XmlRoot("Persons")] 
public class Persons : List<Human> 
{ 

} 

[XmlRoot("Person")] 
public class Human 
{ 
    public Human() 
    { 
    } 

    public Human(string name) 
    { 
     Name = name; 
    } 

    [XmlElement("Name")] 
    public string Name { get; set; } 

} 

void TestXmlSerialize() 
{ 
    Persons personList = new Persons(); 
    personList.Add(new Human("John")); 
    personList.Add(new Human("Peter")); 

    try 
    { 
     using (StringWriter writer = new StringWriter()) 
     { 
      XmlSerializer serializer = new XmlSerializer(typeof(Persons)); 
      XmlWriterSettings settings = new XmlWriterSettings(); 
      settings.OmitXmlDeclaration = true; 

      XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces(); 
      namespaces.Add(string.Empty, string.Empty); 

      XmlWriter xmlWriter = XmlWriter.Create(writer, settings); 
      serializer.Serialize(xmlWriter, personList, namespaces); 

      Console.Out.WriteLine(writer.ToString()); 
     } 
    } 
    catch (Exception e) 
    { 
     Console.Out.WriteLine(e.ToString()); 
    } 
} 

La sortie du code de test est:

<Persons> 
    <Human> 
    <Name>John</Name> 
    </Human> 
    <Human> 
    <Name>Peter</Name> 
    </Human> 
</Persons> 

Comme le montre la sortie, le [XmlRoot("Person")] sur Human ne change pas la balise à Person de Human.

Answer 1

Je ne pense pas qu'il existe un moyen de contrôler le nom des éléments de tableau générés.

Si vous pouvez cependant envelopper la collection Persons dans une autre classe, vous aurez alors un contrôle complet sur la sortie générée en utilisant XmlArrayAttribute et XmlArrayItemAttribute.

Si vous ne pouvez pas créer cette nouvelle classe, vous pouvez utiliser IXmlSerializable, mais c'est beaucoup plus complexe.

Un exemple pour la première alternative suivante:

[XmlRoot("Context")] 
public class Context 
{ 
    public Context() { this.Persons = new Persons(); } 

    [XmlArray("Persons")] 
    [XmlArrayItem("Person")] 
    public Persons Persons { get; set; } 
} 

public class Persons : List<Human> { } 

public class Human 
{ 
    public Human() { } 
    public Human(string name) { Name = name; } 
    public string Name { get; set; } 
} 

class Program 
{ 
    public static void Main(string[] args) 
    { 
     Context ctx = new Context(); 
     ctx.Persons.Add(new Human("john")); 
     ctx.Persons.Add(new Human("jane")); 

     var writer = new StringWriter(); 
     new XmlSerializer(typeof(Context)).Serialize(writer, ctx); 

     Console.WriteLine(writer.ToString()); 
    } 
} 

Answer 2

Réglez le XmlRoot sur l'homme:

[XmlRoot("Person")] 

Barre latérale:

Personnes devrait probablement être Les gens

Answer 3

Si vous n'avez pas accès à la source la classe Human (dans ce cas, la définition de XmlRoot n'est pas possible), vous pouvez créer un XmlElementAttribute, Puis ajoutez-le à un XmlAttributeOverride et utilisez-le lors de la création d'une instance de votre XmlSerializer. See this MSDN article for more details.

Answer 4

j'ai eu le même problème avec mon sérialiseur. Aucune des réponses ci-dessus n'a fonctionné exactement. J'ai trouvé que l'attribut XmlRoot de la classe Human est clairement ignoré car ce n'est pas l'élément racine du document. Envelopper la liste dans un objet de contexte n'était pas une option pour moi parce que je ne peux pas changer le schéma XML. La solution est de changer la classe Personnes. Au lieu de sous-classer une liste générique, vous l'intégrez dans un objet et modifiez la manière dont elle est sérialisée.Voir l'exemple de code ci-dessous:

[XmlRoot("Persons")] 
public class Persons 
{ 
    public Persons() 
    { 
     People = new List<Human>(); 
    } 

    [XmlElement("Person")] 
    public List<Human> People 
    { get; set; } 
} 

public class Human 
{ 
    public Human() 
    { 
    } 

    public Human(string name) 
    { 
     Name = name; 
    } 

    [XmlElement("Name")] 
    public string Name { get; set; } 
} 

sérialisation votre liste générique à l'aide XmlElement signifie qu'il ne sera pas placé l'enveloppe autour de votre liste comme XmlArray fait ou comme le fait subclassing. Il vous donne également l'option de bonus d'ajout d'attributs à la classe des personnes, ce qui est là que j'ai eu l'idée de:

How do I add a attribute to a XmlArray element (XML Serialization)?

Answer 5

Marquez votre classe avec les attributs suivants:

[XmlType("Account")] 
[XmlRoot("Account")] 

Answer 6

C'est Code d'essai de la mine

using System.Collections.Generic; 
using System.Xml.Serialization; 

namespace TestLoadingMultiXml 
{ 
[XmlRoot(ElementName=@"main")] 
public class XmlMain 
{ 
    private XmlDataTest data; 

    [XmlElement(ElementName=@"datalist")] 
    public XmlDataTest Data 
    { 
     get { return data; } 
     set { data = value; } 
    } // public XmlDataTest Data 

    public XmlMain() 
    { 
     data = new XmlDataTest(); 
    } 
} 

[XmlRoot(ElementName=@"xmldata")] 
public class XmlDataTest 
{ 
    private List<DataDetails> listData; 

    [XmlElement(ElementName=@"listdata")] 
    public List<DataDetails> Data 
    { 
     get { return listData; } 
     set { listData = value; } 
    } 

    public XmlDataTest() 
    { 
     listData = new List<DataDetails>(); 
     for (int i = 0; i < 10; i++) 
     { 
      DataDetails d = new DataDetails(string.Format("{0}", i)); 
      listData.Add(d); 
     } // for (int i=0; i < 10; i++) 
    } // public XmlDataTest() 
} // class XmlDataTest 

[XmlRoot(ElementName=@"datadetail")] 
public class DataDetails 
{ 
    private string name; 

    [XmlAttribute(AttributeName=@"name")] 
    public string Name 
    { 
     get 
     { 
      return name; 
     } 
     set { name = value; } 
    } 

    public DataDetails(string _value) 
    { 
     this.name = _value; 
    } // public DataDetails(string _value) 

    public DataDetails() 
    { 
     this.name = ""; 
    } // public DataDetails() 
} // public class DataDetails 
} 

et le programme en cours d'exécution

using System; 
using System.IO; 
using System.Windows.Forms; 
using System.Xml.Serialization; 

namespace TestLoadingMultiXml 
{ 
    public partial class Form1 : Form 
    { 
    private XmlMain xt; 
    private string xname = @"x.xml"; 

    public Form1() 
    { 
     InitializeComponent(); 
     this.FormClosing += new FormClosingEventHandler(Form1_FormClosing); 
    } 

    void Form1_FormClosing(object sender, FormClosingEventArgs e) 
    { 
     XmlSerializer x = new XmlSerializer(typeof(XmlMain)); 
     FileStream fs = new FileStream(xname, FileMode.Create); 
     x.Serialize(fs, xt); 
     fs.Close(); 
    } 

    private void Form1_Load(object sender, EventArgs e) 
    { 
     xt = new XmlMain(); 
     xname = Directory.GetCurrentDirectory() + @"\" + xname; 
     if (File.Exists(xname)) 
     { 
      XmlSerializer x = new XmlSerializer(typeof(XmlMain)); 
      FileStream fs = new FileStream(xname, FileMode.Open); 
      xt = (XmlMain)x.Deserialize(fs); 
      fs.Close(); 
     } // if (File.Exists(xname)) 
    } 
} 
} 

Aussi ceci est le résultat

<?xml version="1.0"?> 
<main xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
    <datalist> 
    <listdata name="0" /> 
    <listdata name="1" /> 
    <listdata name="2" /> 
    <listdata name="3" /> 
    <listdata name="4" /> 
    <listdata name="5" /> 
    <listdata name="6" /> 
    <listdata name="7" /> 
    <listdata name="8" /> 
    <listdata name="9" /> 
    </datalist> 
</main> 

Answer 7

Il existe une autre alternative. Vous pouvez toujours implémenter IXmlSerializable dans les collections (et dans toute autre classe ou structure) pour contrôler entièrement la façon dont les éléments sont écrits ou lus. Beaucoup d'entre vous le savent déjà, il n'est généralement pas préférable, bien sûr, que vous finissiez par écrire du code "boiler-plate" à la main, ce qui devrait être une logique automatique spécifiée avec des attributs.

Pour les collections qui doivent correspondre à un schéma sensible, c'est justifiable. Parce que le cadre a une limitation stricte ici et que le code de sérialisation du type d'élément existant n'a pas à être dupliqué correctement; Par exemple, ne réécrivez pas la sérialisation de l'élément dans le code de collection, créez/appelez un XmlSerializer enfant dans votre implémentation ReadXml/WriteXml. Une conséquence de l'utilisation de IXmlSerializable est qu'il ne vous permet pas d'appliquer XmlTypeAttribute (une erreur d'exécution vous indiquant que seul XmlRootAttribute peut être utilisé) s'affiche. À la place, appliquez XmlSchemaProviderAttribute et renvoyez le même nom qualifié que celui que vous auriez mis dans XmlTypeAttribute. L'ancienne méthode GetSchema devrait renvoyer null de toute façon car il était seulement une méthode réservée (selon MSDN), probablement parce qu'ils ont oublié d'inclure la possibilité de spécifier un espace de noms différent. Personnellement, j'utilise le même nom de méthode "GetSchema" dans mon XmlSchemaProviderAttribute afin qu'il apparaisse comme un remplacement complet à côté de la méthode GetSchema de l'espace réservé hérité.

Bien sûr, la meilleure solution serait que Microsoft nous autorise à appliquer XmlArrayItemAttribute aux classes collection/list et à l'utiliser dans XmlSerializer. Par défaut, il utilise le nom d'élément de type XML dans les collections, ce qui me semble être un bogue car il devrait s'agir du nom de la racine XML lorsqu'il est spécifié ou du nom de la classe lorsqu'il ne l'est pas.

Quand j'aurai le temps je reviendrai et j'ajouterai un exemple. Pour l'instant, jetez un oeil aux exemples de documentation MSDN de IXmlSerializable et XmlSchemaProviderAttribute.

http://msdn.microsoft.com/en-us/library/system.xml.serialization.ixmlserializable(v=vs.110).aspx

http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlschemaproviderattribute(v=vs.110).aspx

Answer 8

Je sais qu'il est une vieille question, mais je suis tombé sur le même problème et aucune des solutions semble la question de adresse de l'OP.Voici donc ma solution (les commentaires sont en français si vous vous demandez):

#region Références 
using System.Collections.Generic; 
using System.Linq; 
using System.Xml; 
using System.Xml.Schema; 
using System.Xml.Serialization; 
#endregion 

namespace XmlSerializationTests 
{ 
    /// <summary> 
    /// Représente une liste qui peut être sérialisée en XML en tant que noeud racine. 
    /// </summary> 
    /// <typeparam name="T">Type des éléments de la liste.</typeparam> 
    public class XmlSerializableList<T> 
     : List<T>, IXmlSerializable 
    { 
     #region Variables 
     private static readonly XmlSerializer _ItemSerializer = new XmlSerializer(typeof(T)); 
     private static readonly string _ItemName; 
     private string _RootName; 
     #endregion 

     #region Méthodes 
     /// <summary> 
     /// Initialisation statique 
     /// </summary> 
     static XmlSerializableList() 
     { 
      _ItemName = (typeof(T).GetCustomAttributes(typeof(XmlRootAttribute), true).FirstOrDefault() as XmlRootAttribute)?.ElementName ?? typeof(T).Name; 
     } 

     /// <summary> 
     /// Obtient le nom racine. 
     /// </summary> 
     protected virtual string RootName 
     { 
      get 
      { 
       if (string.IsNullOrWhiteSpace(_RootName)) _RootName = (GetType().GetCustomAttributes(typeof(XmlRootAttribute), true).FirstOrDefault() as XmlRootAttribute)?.ElementName ?? GetType().Name; 
       return _RootName; 
      } 
     } 

     /// <summary> 
     /// Obtient le nom des éléments. 
     /// </summary> 
     protected virtual string ItemName 
     { 
      get { return _ItemName; } 
     } 

     /// <summary> 
     /// Cette méthode est réservée et ne doit pas être utilisée.Lorsque vous implémentez l'interface IXmlSerializable, vous devez retourner la valeur null (Nothing dans Visual Basic) à partir cette méthode et, si la spécification d'un schéma personnalisé est requise, appliquez à la place <see cref="T:System.Xml.Serialization.XmlSchemaProviderAttribute"/> à la classe. 
     /// </summary> 
     /// <returns> <see cref="T:System.Xml.Schema.XmlSchema"/> qui décrit la représentation XML de l'objet qui est généré par la méthode <see cref="M:System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)"/> et utilisé par la méthode <see cref="M:System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)"/>.</returns> 
     public XmlSchema GetSchema() 
     { 
      return null; 
     } 

     /// <summary> 
     /// Génère un objet à partir de sa représentation XML. 
     /// </summary> 
     /// <param name="reader"><see cref="T:System.Xml.XmlReader"/> source à partir de laquelle l'objet est désérialisé.</param> 
     public void ReadXml(XmlReader reader) 
     { 
      if (!reader.IsEmptyElement) 
      { 
       reader.ReadStartElement(); 
       while (reader.NodeType != XmlNodeType.EndElement) 
       { 
        T item = (T) _ItemSerializer.Deserialize(reader); 
        Add(item); 
       } 
       reader.ReadEndElement(); 
      } 
      else reader.ReadStartElement(); 
     } 

     /// <summary> 
     /// Convertit un objet en sa représentation XML. 
     /// </summary> 
     /// <param name="writer"><see cref="T:System.Xml.XmlWriter"/> flux dans lequel l'objet est sérialisé.</param> 
     public void WriteXml(XmlWriter writer) 
     { 
      foreach (var i in this) 
      { 
       XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); 
       ns.Add("", ""); 
       _ItemSerializer.Serialize(writer, i, ns); 
      } 
     } 
     #endregion 
    } 
} 

Et ici une classe de test unitaire pour démontrer l'utilisation et les résultats:

#region Références 
using System.IO; 
using System.Text; 
using System.Xml.Serialization; 
using Microsoft.VisualStudio.TestTools.UnitTesting; 
#endregion 

namespace XmlSerializationTests 
{ 
    [TestClass] 
    public class XmlSerializableListTests 
    { 
     public class Person 
     { 
      public string FirstName { get; set; } 
      public string LastName { get; set; } 
      public int Birth { get; set; } 
     } 

     [XmlRoot("color")] 
     public class ColorDefinition 
     { 
      [XmlElement("name")] public string Name { get; set; } 
      [XmlElement("r")] public int Red { get; set; } 
      [XmlElement("g")] public int Green { get; set; } 
      [XmlElement("b")] public int Blue { get; set; } 
     } 

     public class Persons : XmlSerializableList<Person> 
     { 
     } 

     [XmlRoot("colors")] 
     public class ColorList : XmlSerializableList<ColorDefinition> 
     { 
     } 

     private T ReadXml<T>(string text) where T : class 
     { 
      XmlSerializer serializer = new XmlSerializer(typeof (T)); 
      using (StringReader sr = new StringReader(text)) 
      { 
       return serializer.Deserialize(sr) as T; 
      } 
     } 

     private string WriteXml<T>(T data) where T : class 
     { 
      XmlSerializer serializer = new XmlSerializer(typeof(T)); 
      StringBuilder sb = new StringBuilder(); 
      using (StringWriter sw = new StringWriter(sb)) 
      { 
       serializer.Serialize(sw, data); 
       return sb.ToString(); 
      } 
     } 

     [TestMethod] 
     public void ReadEmpty() 
     { 
      string xml = @"<?xml version=""1.0"" encoding=""utf-16""?> 
<XmlSerializableListOfInt32> 
</XmlSerializableListOfInt32>"; 
      XmlSerializableList<int> lst = ReadXml<XmlSerializableList<int>>(xml); 
      Assert.AreEqual(0, lst.Count); 
     } 

     [TestMethod] 
     public void ReadEmpty2() 
     { 
      string xml = @"<?xml version=""1.0"" encoding=""utf-16""?> 
<XmlSerializableListOfInt32 />"; 
      XmlSerializableList<int> lst = ReadXml<XmlSerializableList<int>>(xml); 
      Assert.AreEqual(0, lst.Count); 
     } 

     [TestMethod] 
     public void ReadSimpleItems() 
     { 
      string xml = @"<?xml version=""1.0"" encoding=""utf-16""?> 
<XmlSerializableListOfInt32> 
    <int>0</int> 
    <int>52</int> 
    <int>79</int> 
</XmlSerializableListOfInt32>"; 
      XmlSerializableList<int> lst = ReadXml<XmlSerializableList<int>>(xml); 
      Assert.AreEqual(3, lst.Count); 
      Assert.AreEqual(0, lst[0]); 
      Assert.AreEqual(52, lst[1]); 
      Assert.AreEqual(79, lst[2]); 
     } 

     [TestMethod] 
     public void ReadComplexItems() 
     { 
      string xml = @"<?xml version=""1.0"" encoding=""utf-16""?> 
<XmlSerializableListOfPerson> 
    <Person> 
    <FirstName>Linus</FirstName> 
    <LastName>Torvalds</LastName> 
    <Birth>1969</Birth> 
    </Person> 
    <Person> 
    <FirstName>Bill</FirstName> 
    <LastName>Gates</LastName> 
    <Birth>1955</Birth> 
    </Person> 
    <Person> 
    <FirstName>Steve</FirstName> 
    <LastName>Jobs</LastName> 
    <Birth>1955</Birth> 
    </Person> 
</XmlSerializableListOfPerson>"; 
      XmlSerializableList<Person> lst = ReadXml<XmlSerializableList<Person>>(xml); 
      Assert.AreEqual(3, lst.Count); 
      Assert.AreEqual("Linus", lst[0].FirstName); 
      Assert.AreEqual("Torvalds", lst[0].LastName); 
      Assert.AreEqual(1969, lst[0].Birth); 
      Assert.AreEqual("Bill", lst[1].FirstName); 
      Assert.AreEqual("Gates", lst[1].LastName); 
      Assert.AreEqual(1955, lst[1].Birth); 
      Assert.AreEqual("Steve", lst[2].FirstName); 
      Assert.AreEqual("Jobs", lst[2].LastName); 
      Assert.AreEqual(1955, lst[2].Birth); 
     } 

     [TestMethod] 
     public void ReadInheritedPersons() 
     { 
      string xml = @"<?xml version=""1.0"" encoding=""utf-16""?> 
<Persons> 
    <Person> 
    <FirstName>Linus</FirstName> 
    <LastName>Torvalds</LastName> 
    <Birth>1969</Birth> 
    </Person> 
    <Person> 
    <FirstName>Bill</FirstName> 
    <LastName>Gates</LastName> 
    <Birth>1955</Birth> 
    </Person> 
    <Person> 
    <FirstName>Steve</FirstName> 
    <LastName>Jobs</LastName> 
    <Birth>1955</Birth> 
    </Person> 
</Persons>"; 
      Persons lst = ReadXml<Persons>(xml); 
      Assert.AreEqual(3, lst.Count); 
      Assert.AreEqual("Linus", lst[0].FirstName); 
      Assert.AreEqual("Torvalds", lst[0].LastName); 
      Assert.AreEqual(1969, lst[0].Birth); 
      Assert.AreEqual("Bill", lst[1].FirstName); 
      Assert.AreEqual("Gates", lst[1].LastName); 
      Assert.AreEqual(1955, lst[1].Birth); 
      Assert.AreEqual("Steve", lst[2].FirstName); 
      Assert.AreEqual("Jobs", lst[2].LastName); 
      Assert.AreEqual(1955, lst[2].Birth); 
     } 

     [TestMethod] 
     public void ReadInheritedColors() 
     { 
      string xml = @"<?xml version=""1.0"" encoding=""utf-16""?> 
<colors> 
    <color> 
    <name>red</name> 
    <r>255</r> 
    <g>0</g> 
    <b>0</b> 
    </color> 
    <color> 
    <name>green</name> 
    <r>0</r> 
    <g>255</g> 
    <b>0</b> 
    </color> 
    <color> 
    <name>yellow</name> 
    <r>255</r> 
    <g>255</g> 
    <b>0</b> 
    </color> 
</colors>"; 
      ColorList lst = ReadXml<ColorList>(xml); 
      Assert.AreEqual(3, lst.Count); 
      Assert.AreEqual("red", lst[0].Name); 
      Assert.AreEqual(255, lst[0].Red); 
      Assert.AreEqual(0, lst[0].Green); 
      Assert.AreEqual(0, lst[0].Blue); 
      Assert.AreEqual("green", lst[1].Name); 
      Assert.AreEqual(0, lst[1].Red); 
      Assert.AreEqual(255, lst[1].Green); 
      Assert.AreEqual(0, lst[1].Blue); 
      Assert.AreEqual("yellow", lst[2].Name); 
      Assert.AreEqual(255, lst[2].Red); 
      Assert.AreEqual(255, lst[2].Green); 
      Assert.AreEqual(0, lst[2].Blue); 
     } 

     [TestMethod] 
     public void WriteEmpty() 
     { 
      string xml = @"<?xml version=""1.0"" encoding=""utf-16""?> 
<XmlSerializableListOfInt32 />"; 
      XmlSerializableList<int> lst = new XmlSerializableList<int>(); 
      string result = WriteXml(lst); 
      Assert.AreEqual(xml, result); 
     } 

     [TestMethod] 
     public void WriteSimpleItems() 
     { 
      string xml = @"<?xml version=""1.0"" encoding=""utf-16""?> 
<XmlSerializableListOfInt32> 
    <int>0</int> 
    <int>52</int> 
    <int>79</int> 
</XmlSerializableListOfInt32>"; 
      XmlSerializableList<int> lst = new XmlSerializableList<int>() {0, 52, 79}; 
      string result = WriteXml(lst); 
      Assert.AreEqual(xml, result); 
     } 

     [TestMethod] 
     public void WriteComplexItems() 
     { 
      string xml = @"<?xml version=""1.0"" encoding=""utf-16""?> 
<XmlSerializableListOfPerson> 
    <Person> 
    <FirstName>Linus</FirstName> 
    <LastName>Torvalds</LastName> 
    <Birth>1969</Birth> 
    </Person> 
    <Person> 
    <FirstName>Bill</FirstName> 
    <LastName>Gates</LastName> 
    <Birth>1955</Birth> 
    </Person> 
    <Person> 
    <FirstName>Steve</FirstName> 
    <LastName>Jobs</LastName> 
    <Birth>1955</Birth> 
    </Person> 
</XmlSerializableListOfPerson>"; 
      XmlSerializableList<Person> persons = new XmlSerializableList<Person> 
      { 
       new Person {FirstName = "Linus", LastName = "Torvalds", Birth = 1969}, 
       new Person {FirstName = "Bill", LastName = "Gates", Birth = 1955}, 
       new Person {FirstName = "Steve", LastName = "Jobs", Birth = 1955} 
      }; 
      string result = WriteXml(persons); 
      Assert.AreEqual(xml, result); 
     } 

     [TestMethod] 
     public void WriteInheritedPersons() 
     { 
      string xml = @"<?xml version=""1.0"" encoding=""utf-16""?> 
<Persons> 
    <Person> 
    <FirstName>Linus</FirstName> 
    <LastName>Torvalds</LastName> 
    <Birth>1969</Birth> 
    </Person> 
    <Person> 
    <FirstName>Bill</FirstName> 
    <LastName>Gates</LastName> 
    <Birth>1955</Birth> 
    </Person> 
    <Person> 
    <FirstName>Steve</FirstName> 
    <LastName>Jobs</LastName> 
    <Birth>1955</Birth> 
    </Person> 
</Persons>"; 
      Persons lst = new Persons 
      { 
       new Person {FirstName = "Linus", LastName = "Torvalds", Birth = 1969}, 
       new Person {FirstName = "Bill", LastName = "Gates", Birth = 1955}, 
       new Person {FirstName = "Steve", LastName = "Jobs", Birth = 1955} 
      }; 
      string result = WriteXml(lst); 
      Assert.AreEqual(xml, result); 
     } 

     [TestMethod] 
     public void WriteInheritedColors() 
     { 
      string xml = @"<?xml version=""1.0"" encoding=""utf-16""?> 
<colors> 
    <color> 
    <name>red</name> 
    <r>255</r> 
    <g>0</g> 
    <b>0</b> 
    </color> 
    <color> 
    <name>green</name> 
    <r>0</r> 
    <g>255</g> 
    <b>0</b> 
    </color> 
    <color> 
    <name>yellow</name> 
    <r>255</r> 
    <g>255</g> 
    <b>0</b> 
    </color> 
</colors>"; 
      ColorList lst = new ColorList 
      { 
       new ColorDefinition { Name = "red", Red = 255, Green = 0, Blue = 0 }, 
       new ColorDefinition { Name = "green", Red = 0, Green = 255, Blue = 0 }, 
       new ColorDefinition { Name = "yellow", Red = 255, Green = 255, Blue = 0 } 
      }; 
      string result = WriteXml(lst); 
      Assert.AreEqual(xml, result); 
     } 
    } 
}