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

    } 

}