C＃反序列化的XML文件中以形成列表<T>

Question

我有以下类，我试图序列化和和一个XML文件反序列化：

public class cUrlData 
{ 
    public string ProgramName {get;set;} 
    public string ExeName { get; set; } 
    public string Category { get; set; } 
    public string URL { get; set; } 

    public cUrlData() 
    { 
    } 

    public void Add(string ProgramName, string ExeName, string Category, string ProgramURL) 
    { 
     this.ProgramName = ProgramName; 
     this.ExeName = ExeName; 
     this.URL = ProgramURL; 
     this.Category = Category; 
    } 

} 

我一直在使用下面的代码测试了这一点：

public List<cUrlData> SoftwareData = new List<cUrlData>(); 
cUrlData urlData; 
cXml xml; 

public frmUpdater() 
{ 
    InitializeComponent(); 

    xml = new cXml("data.xml", ref SoftwareData); 
    xml.Load(); // NOT WORKING - SO I GENERATE MY OWN DATA BELOW 

    // Set up some test data to work with 
    urlData = new cUrlData(); 
    urlData.Add("Program1", 
          "Program1.exe", 
          "myDownloads", 
          "http://www.source.com/program1.exe"); 

    SoftwareData.Add(urlData); 

    urlData = new cUrlData(); 
    urlData.Add("Program2", 
          "Program2.exe", 
          "myDownloads", 
          "http://www.source.com/program2.exe"); 

    SoftwareData.Add(urlData); 

    urlData = new cUrlData(); 
    urlData.Add("Program3", 
          "Program3.exe", 
          "myDownloads", 
          "http://www.source.com/program3.exe"); 
    SoftwareData.Add(urlData); 

} 

我遇到的问题是要找到一个可靠的方式来转换列表和XML文件。我目前循环遍历类的列表，并逐个节点手动创建xml文件节点，并在从xml文件读取类时执行相同的操作，但这很容易出错。我试图得到下面的代码来阅读文件，但无济于事，并会感谢一些建议，因为我确信它是一个编码问题！

public void Load() { 
    XmlSerializer serializer = new XmlSerializer(typeof(List<cUrlData>)); 

    using (XmlReader reader = XmlReader.Create("data.xml")) 
    { 
     cUrlData myXmlClass = (cUrlData)serializer.Deserialize(reader); 
    } 
} 

一旦加载，我想尝试并将其写回到xml文件。再次，以类似于上述代码的方式。

谢谢

Answer 1

这里应该是

private void SaveData(List<cUrlData> SoftwareData) 
{ 
    try 
    { 
     using (TextWriter reader = new StreamWriter("data.xml")) 
     { 
      (new XmlSerializer(typeof(List<cUrlData>))).Serialize(reader, SoftwareData); 
     } 
    } 
    catch (Exception e) 
    { 
     MessageBox.Show(e.Message); 
    } 
} 
private List<cUrlData> LoadData() 
{ 
    List<cUrlData> mysXmlClass = null; 

    try 
    { 
     using (TextReader reader = new StreamReader("data.xml")) 
     { 
      object myXmlClass = (object)(new XmlSerializer(typeof(List<cUrlData>))).Deserialize(reader); 
      mysXmlClass = (List<cUrlData>)myXmlClass; 
     } 
    } 
    catch (Exception e) 
    { 
     MessageBox.Show(e.Message); 
    } 

    return mysXmlClass; 
} 

它确实需要渡过了一些通用的解决方案，让你开始对保存和加载。我使用TextReaders和StreamReaders，因为我熟悉这些。

Answer 2

下面是我用一对夫妇的功能，希望他们帮助：

public static T FromXML<T>(string xml) 
{ 
    using (StringReader stringReader = new StringReader(xml)) 
    { 
    XmlSerializer serializer = new XmlSerializer(typeof(T)); 
    return (T)serializer.Deserialize(stringReader); 
    } 
} 

public string ToXML<T>(T obj) 
{ 
    using (StringWriter stringWriter = new StringWriter(new StringBuilder())) 
    { 
    XmlSerializer xmlSerializer = new XmlSerializer(typeof(T)); 
    xmlSerializer.Serialize(stringWriter, obj); 
    return stringWriter.ToString(); 
    } 
} 

Answer 3

MrNYE有正确的想法。以下是我们用于使用编码选项序列化和反序列化的完整类。

享受！

using System; 
using System.Collections.Generic; 
using System.Text; 
using System.Xml.Serialization; 
using System.Runtime.Serialization.Formatters.Binary; 
using System.IO; 
using System.Xml; 

namespace xml.serialization 
{ 
/// <summary> 
/// Class to serialize generic objects. 
/// </summary> 
public static class ObjectSerializer 
{ 
    /// <summary> 
    /// Decode from xml string with default UTF8 encoding 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="xml"></param> 
    /// <returns></returns> 
    public static T FromString<T>(string xml) 
    { 
     Encoding e = Encoding.UTF8; 
     return FromString<T>(xml, e); 
    } 

    /// <summary> 
    /// Decode from xml string with UTF16 unicode 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="xml"></param> 
    /// <returns></returns> 
    public static T FromStringUTF16<T>(string xml) 
    { 
     Encoding e = Encoding.Unicode; 
     return FromString<T>(xml, e); 
    } 

    /// <summary> 
    /// Decode from xml string with privided encoding type 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="xml"></param> 
    /// <param name="e"></param> 
    /// <returns></returns> 
    public static T FromString<T>(string xml, Encoding e) 
    { 
     Object ret = null; 
     XmlSerializer s = new XmlSerializer(typeof(T)); 

     using (MemoryStream stream = new MemoryStream(e.GetBytes(xml))) 
     { 
      XmlTextWriter xtWriter = new XmlTextWriter(stream, e); 
      ret = s.Deserialize(stream); 
      //xtWriter.Close(); 
     } 

     return (T)ret; 
    } 

    /// <summary> 
    /// Serialize to xml with default UTF8 encoding 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="obj"></param> 
    /// <returns></returns> 
    public static string ToString<T>(T obj) 
    { 
     Encoding e = Encoding.UTF8; 
     return ToString(obj, e); 
    } 

    /// <summary> 
    /// Serialize to xml with UTF16 encoding 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="obj"></param> 
    /// <returns></returns> 
    public static string ToStringUTF16<T>(T obj) 
    { 
     Encoding e = Encoding.Unicode; 
     return ToString(obj, e); 
    } 


    /// <summary> 
    /// Serialize to xml with specified encoding 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="obj"></param> 
    /// <param name="e"></param> 
    /// <returns></returns> 
    public static string ToString<T>(T obj, Encoding e) 
    { 
     string ret = String.Empty; 
     XmlSerializer s = new XmlSerializer(typeof(T)); 

     using (MemoryStream stream = new MemoryStream()) 
     { 
      XmlTextWriter xtWriter = new XmlTextWriter(stream, e); 
      s.Serialize(xtWriter, obj); 
      xtWriter.Close(); 
      ret = e.GetString(stream.ToArray()); 
     } 

     return ret; 
    } 


    /// <summary> 
    /// Serialize to xml to to a file with default UTF8 encoding 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="obj"></param> 
    /// <param name="filePath"></param> 
    public static void ToXmlFile<T>(T obj, string filePath) 
    { 
     Encoding e = Encoding.UTF8; 
     ToXmlFile<T>(obj, filePath, e); 
    } 

    /// <summary> 
    /// Serialize to xml to to a file with specific encoding 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="obj"></param> 
    /// <param name="filePath"></param> 
    /// <param name="e"></param> 
    public static void ToXmlFile<T>(T obj, string filePath, Encoding e) 
    { 
     XmlSerializer s = new XmlSerializer(typeof(T)); 

     using (TextWriter w = new StreamWriter(filePath, false, e)) 
     { 
      s.Serialize(w, obj); 
      w.Flush(); 
      w.Close(); 
     } 
    } 

    /// <summary> 
    /// Deserialize from a file of xml useing default UTF8 encoding 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="filePath"></param> 
    /// <returns></returns> 
    public static T FromXmlFile<T>(string filePath) 
    { 

     Encoding e = Encoding.UTF8; 
     return FromXmlFile<T>(filePath, e); 

    } 

    /// <summary> 
    /// Deserialize from a file of xml useing specific encoding 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="filePath"></param> 
    /// <param name="e"></param> 
    /// <returns></returns> 
    public static T FromXmlFile<T>(string filePath, Encoding e) 
    { 
     XmlSerializer s = new XmlSerializer(typeof(T)); 
     Object ret = null; 

     using (TextReader r = new StreamReader(filePath, e)) 
     { 
      ret = s.Deserialize(r); 
      r.Close(); 
     } 

     return (T)ret; 
    } 

    } 

}