Сериализация объекта с вариациями того же свойства

Question

У меня есть метод, с помощью которого я могу сериализовать объект.

например.

List<Titles> lstCrmTitleSer = new List<Titles>(); 

Я просматриваю коллекцию строковых заголовков, и я добавляю их в список титров, чтобы их сериализовать.

foreach (var ls in lstCrmTitles) 
{ 
    Titles t = new Titles(); 

    t.title = ls; 
    lstCrmTitleSer.Add(t); 
} 

Это мой объект и метод, с помощью которых я сериализую объект.

static public void SerializeToXMLCollection(List<Titles> trainingTitles) 
{ 
    XmlSerializer serializer = new XmlSerializer(typeof(List<Titles>)); 
    string path = string.Concat(@"C:\Users\Arian\Desktop\Titles.xml"); 
    Console.WriteLine(path); 
    TextWriter textWriter = new StreamWriter(path); 
    serializer.Serialize(textWriter, trainingTitles); 
    textWriter.Close(); 
} 

public string title { get; set; } 

это отображается Вещь мой файл Xml, как следовать

<Titles> 
     <title>title a</title> 
</Titles> 
<Titles> 
     <title>title b</title> 
</Titles> 
<Titles> 
     <title>title c</title> 
</Titles> 

Что я хотел бы, если для моего XML, который будет отображаться в качестве последующих

<Titles> 
     <title>title a</title> 
     <title>title b</title> 
     <title>title c</title> 
</Titles> 

Как я могу настроить мой код для достижения вышеупомянутого результата?

Answer 1

Первый. Вот общий метод расширения для использования .. я написал несколько лет назад, и это будет сериализовать все:

/// <summary> 
/// <para>Serializes the specified System.Object and writes the XML document</para> 
/// <para>to the specified file.</para> 
/// </summary> 
/// <typeparam name="T">This item's type</typeparam> 
/// <param name="item">This item</param> 
/// <param name="fileName">The file to which you want to write.</param> 
/// <returns>true if successful, otherwise false.</returns> 
public static bool XmlSerialize<T>(this T item, string fileName) 
{ 
    return item.XmlSerialize(fileName, true); 
} 

/// <summary> 
/// <para>Serializes the specified System.Object and writes the XML document</para> 
/// <para>to the specified file.</para> 
/// </summary> 
/// <typeparam name="T">This item's type</typeparam> 
/// <param name="item">This item</param> 
/// <param name="fileName">The file to which you want to write.</param> 
/// <param name="removeNamespaces"> 
///  <para>Specify whether to remove xml namespaces.</para>para> 
///  <para>If your object has any XmlInclude attributes, then set this to false</para> 
/// </param> 
/// <returns>true if successful, otherwise false.</returns> 
public static bool XmlSerialize<T>(this T item, string fileName, bool removeNamespaces) 
{ 
    object locker = new object(); 

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

    XmlSerializer xmlSerializer = new XmlSerializer(typeof(T)); 

    XmlWriterSettings settings = new XmlWriterSettings(); 
    settings.Indent = true; 
    settings.OmitXmlDeclaration = true; 

    lock (locker) 
    { 
     using (XmlWriter writer = XmlWriter.Create(fileName, settings)) 
     { 
      if (removeNamespaces) 
      { 
       xmlSerializer.Serialize(writer, item, xmlns); 
      } 
      else { xmlSerializer.Serialize(writer, item); } 

      writer.Close(); 
     } 
    } 

    return true; 
} 

/// <summary> 
/// Serializes the specified System.Object and returns the serialized XML 
/// </summary> 
/// <typeparam name="T">This item's type</typeparam> 
/// <param name="item">This item</param> 
/// <param name="removeNamespaces"> 
///  <para>Specify whether to remove xml namespaces.</para>para> 
///  <para>If your object has any XmlInclude attributes, then set this to false</para> 
/// </param> 
/// <returns>Serialized XML for specified System.Object</returns> 
public static string XmlSerialize<T>(this T item, bool removeNamespaces = true) 
{ 
    object locker = new object(); 
    XmlSerializerNamespaces xmlns = new XmlSerializerNamespaces(); 
    xmlns.Add(string.Empty, string.Empty); 

    XmlSerializer xmlSerializer = new XmlSerializer(typeof(T)); 

    XmlWriterSettings settings = new XmlWriterSettings(); 
    settings.Indent = true; 
    settings.OmitXmlDeclaration = true; 

    lock (locker) 
    { 
     StringBuilder stringBuilder = new StringBuilder(); 
     using (StringWriter stringWriter = new StringWriter(stringBuilder)) 
     { 
      using (XmlWriter xmlWriter = XmlWriter.Create(stringWriter, settings)) 
      { 
       if (removeNamespaces) 
       { 
        xmlSerializer.Serialize(xmlWriter, item, xmlns); 
       } 
       else { xmlSerializer.Serialize(xmlWriter, item); } 

       return stringBuilder.ToString(); 
      } 
     } 
    } 
} 

Второй. Используйте его следующим образом:

internal class Program 
{ 
    private static void Main(string[] args) 
    { 
     var list = new MyObject(); 
     list.Titles.Add("title1"); 
     list.Titles.Add("title2"); 
     list.Titles.Add("title3"); 

     string serialized = list.XmlSerialize(); 

     //obviously here you would save to disk or whatever 
     Console.WriteLine(serialized); 
     Console.ReadLine(); 
    } 
} 

[XmlRoot("Titles")] 
public class MyObject 
{ 
    [XmlElement("title")] 
    public List<string> Titles { get; set; } 

    public MyObject() 
    { 
     Titles = new List<string>(); 
    } 
} 

В-третьих, этот код просто противный. Даже с приведенным выше предложением, я все еще думаю, что вам нужно сделать серьезный рефакторинг.

Успехов

БОНУС

Удлинитель deseralizing строку к вашему типу:

/// <summary> 
/// Deserializes the XML data contained by the specified System.String 
/// </summary> 
/// <typeparam name="T">The type of System.Object to be deserialized</typeparam> 
/// <param name="s">The System.String containing XML data</param> 
/// <returns>The System.Object being deserialized.</returns> 
public static T XmlDeserialize<T>(this string s) 
{ 
    if (string.IsNullOrEmpty(s)) 
    { 
     return default(T); 
    } 

    var locker = new object(); 
    var stringReader = new StringReader(s); 
    var reader = new XmlTextReader(stringReader); 
    try 
    { 
     var xmlSerializer = new XmlSerializer(typeof(T)); 
     lock (locker) 
     { 
      var item = (T)xmlSerializer.Deserialize(reader); 
      reader.Close(); 
      return item; 
     } 
    } 
    catch 
    { 
     return default(T); 
    } 
    finally 
    { 
     reader.Close(); 
    } 
} 

использовать его как это:

var myObject = someSerializedString.XmlDeserialize<MyObject>()