Lista XmlSerializer Elemento Nombre del elemento

Question

tengo una clase PersonList

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

cuando serializar esto a XML, por defecto se producirá algo como esto:

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

Mi pregunta es ¿qué tiene que ser hecho para cambiar el elemento Human a Person en la salida? por lo que la salida sería:

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

y, cómo deserializar el XML anterior al objeto PersonList clase? consejos

por Nick, aquí está mi código de prueba:

[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 salida del código de prueba es:

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

Como muestra la salida, el [XmlRoot("Person")] en Human no cambia la etiqueta a Person de Human.

Answer 1

No creo que haya una forma de controlar el nombre de los elementos de matriz generados.

Si puede sin embargo ajustar la colección Persons dentro de otra clase, tendrá control total sobre la salida generada usando XmlArrayAttribute y XmlArrayItemAttribute.

Si no puede crear esta nueva clase, puede recurrir a la implementación de IXmlSerializable, pero esto es mucho más complejo.

Un ejemplo de la primera alternativa de la siguiente manera:

[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

Ajuste el XmlRoot Humanos a:

[XmlRoot("Person")] 

Recuadro:

Personas probablemente debería ser personas

Answer 3

Si usted no tiene acceso a la fuente de la clase Humana (en cuyo caso, establecer XmlRoot no es posible), puede crear un XmlElementAttribute, luego agréguelo a XmlAttributeOverride y utilícelo al crear una instancia de su XmlSerializer. See this MSDN article for more details.

Answer 4

tuve el mismo problema con mi serializador. Ninguna de las respuestas anteriores funcionó exactamente. Descubrí que el atributo XmlRoot en la clase humana simplemente se ignora porque no es el elemento raíz del documento. Envolver la lista en un objeto de contexto no era una opción para mí porque no puedo cambiar el esquema XML. La solución es cambiar la clase de personas. En lugar de subclasificar una lista genérica, la envuelve en un objeto y cambia la forma en que se serializa.Consulte el código de ejemplo a continuación:

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

números de serie a su lista genérica utilizando XmlElement significa que no va a poner el elemento de envoltura alrededor de su lista como XmlArray hace o como la subclasificación hace. También le da la opción de bonificación de añadir atributos a la clase de personas, que es donde me ocurrió la idea de:

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

Answer 5

Marque su clase con los siguientes atributos:

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

Answer 6

Este es prueba de la mina código

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 
} 

y ejecutando el programa

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

También este es el resultado

<?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

No hay otra alternativa. Siempre puede implementar IXmlSerializable en colecciones (y cualquier otra clase o estructura) para controlar completamente cómo se escriben o leen los elementos. Muchos de ustedes ya lo sabrán, por lo general no se prefiere, ya que es posible que terminen escribiendo a mano el código "placa de caldera", que en realidad debería ser una lógica automática especificada con atributos.

Para las colecciones que deben coincidir con un esquema razonable es justificable. Debido a que el marco tiene una gran limitación aquí y el código de serialización del tipo de elemento existente no tiene que ser duplicado cuando se hace correctamente; es decir, no vuelva a escribir la serialización del artículo en el código de recopilación, simplemente cree/llame a un XmlSerializer hijo dentro de su implementación de ReadXml/WriteXml.

Una consecuencia del uso de IXmlSerializable es que no le permite aplicar el atributo XmlTypeAttribute (arroja un error de tiempo de ejecución que le indica que solo se puede usar XmlRootAttribute). Entonces, en su lugar, aplique XmlSchemaProviderAttribute y devuelva el mismo nombre calificado que hubiera puesto en XmlTypeAttribute. El antiguo método GetSchema debería devolver nulo de todos modos, ya que era solo un método reservado (según MSDN), probablemente porque se olvidó de incluir la capacidad de especificar un espacio de nombres diferente. Personalmente utilizo el mismo nombre de método "GetSchema" en mi XmlSchemaProviderAttribute, por lo que aparece como una anulación completa junto al método heredado GetSchema marcador de posición.

Por supuesto, la mejor solución sería si Microsoft nos permitiera aplicar el atributo XmlArrayItemAttribute a las clases de colección/lista y usar eso en el XmlSerializer. De forma predeterminada, utiliza el nombre del elemento de tipo XML en las colecciones, lo que creo que es un error porque debe ser el nombre raíz XML cuando se especifica o el nombre de la clase cuando no lo está.

Cuando tenga tiempo, volveré y añadiré un ejemplo. Por ahora eche un vistazo a los ejemplos de documentación de MSDN de IXmlSerializable y 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

sé que es una vieja pregunta, pero me encontré con el mismo problema y ninguna de las soluciones parece Dirección pregunta del PO.Así que aquí está mi solución (los comentarios están en francés si usted se pregunta):

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

Y aquí una clase de prueba de unidad para demostrar el uso y los resultados:

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