求助啊！泛型怎么序列化为XML文件，要能追加的。(C#.NET)

Question

小弟自己在做微型的管理系统，数据不能存在数据库中，所以选择了XML，可是我现在不会怎么追加。
如Student是Models的一个类，有属性Name，Hobby。要序列化List<Student>泛型Students。谁能教教我啊，先谢谢了！

Answer 1

追加可以直接操作xml文件，当然这不是一个思维连贯的写法通常来说，如果思维连贯的写法是，反序列化回list<T>，add新项，在序列化成xml保存

Answer 2

泛型的xml序列化和普通的对象序列化没有什么区别。/// <summary>
    /// xml序列化到字符串
    /// </summary>
    /// <typeparam name="T">泛型对象</typeparam>
    /// <param name="obj">对象</param>
    /// <returns></returns>
    public static string XmlSerialize<T>(T obj)
    {
        try
        {
            XmlSerializer ser = new XmlSerializer(obj.GetType());
            StringBuilder sb = new StringBuilder();
            StringWriter sw = new StringWriter(sb);
            ser.Serialize(sw, obj);            return sb.ToString();
        }
        catch (Exception ex)
        {
            throw new Exception("序列化失败,原因:" + ex.Message);
        }   
    }    /// <summary>
    /// xml反序列化到对象
    /// </summary>
    /// <typeparam name="T">反序列化对象</typeparam>
    /// <param name="obj"></param>
    /// <param name="str"></param>
    /// <returns></returns>
    public static T XmlDeserialize<T>(T obj,string strxml)
    {
        try
        {
            XmlSerializer xs = new XmlSerializer(obj.GetType());
            StringReader sr = new StringReader(strxml);
            return (T)xs.Deserialize(sr);
        }
        catch (Exception ex)
        {
            throw new Exception("反序列化失败,原因:" + ex.Message);
        }
    }
//do
public class Student
    {
        string Name { set; get; }
        string Hobby { get; set; }
    }
 List<Student> stuList = new List<Student>();
           string xmlstr = Common.SerializeObj.XmlSerialize<List<Student>>(stuList);

Answer 3

3楼写好方法了 序列化成字符串了 你用FileStream写到文件里不就可以了.需要反序列化的时候 读文件 然后把文件内的字符串反序列化为对象.

Answer 4

    public class SerializableHelper
    {
        /// <summary>
        /// 序列化成一个字节数组
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static byte[] SerializeToBytes<T>(T t)
        {
            MemoryStream mStream = new MemoryStream();
            BinaryFormatter ser = new BinaryFormatter();
            ser.Serialize(mStream, t);
            return mStream.ToArray();
        }        /// <summary>
        /// 序列化成一个字符串
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns>序列化代码</returns>
        public static string SerializeToXml<T>(T t)
        {
            try
            {
                XmlSerializer s = new XmlSerializer(typeof(T));
                Stream stream = new MemoryStream();
                s.Serialize(stream, t);                stream.Seek(0, SeekOrigin.Begin); //这一点非常重要 否则无法读取
                string strSource = "";
                using (StreamReader reader = new StreamReader(stream))
                {
                    strSource = reader.ReadToEnd();
                }
                return strSource;
            }
            catch { return null; }        }
        /// <summary>
        /// xml 文件反序列化为泛型数组
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="path"></param>
        /// <returns></returns>
        public static T DeSerialize<T>(FileInfo fi)
        {
            if (fi.Exists == false) return default(T);            XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));            FileStream fs = fi.OpenRead();
            T t;
            try
            {
                t = (T)xmlSerializer.Deserialize(fs);
            }
            finally
            {
                fs.Close();
            }
            return t;
        }
        /// <summary>
        /// 字符串反序列化成一个类
        /// </summary>
        /// <param name="binary"></param>
        /// <returns></returns>
        public static T DeSerialize<T>(string xmlSource)
        { 
            if (string.IsNullOrEmpty(xmlSource)) return default(T);            try
            {
                XmlSerializer x = new XmlSerializer(typeof(T));                Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(xmlSource));
                stream.Seek(0, SeekOrigin.Begin);
                object obj = x.Deserialize(stream);
                stream.Close();                return (T)obj;
            }
            catch
            {
                return default(T);
            }
        }
        public static Dictionary<TKey, TValue> DeSerialize<TKey, TValue>(FileInfo fi)
        {
            if (fi.Exists == false) return default(Dictionary<TKey, TValue>);            FileStream fs = fi.OpenRead();
            if (fs.Length == 0) return default(Dictionary<TKey, TValue>);            XmlReader reader = XmlReader.Create(fs);
            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
            bool wasEmpty = reader.IsEmptyElement;            if (wasEmpty)
                return default(Dictionary<TKey, TValue>);            Dictionary<TKey, TValue> dic = new Dictionary<TKey, TValue>();
            while (reader.Read())
            {
                if (reader.NodeType != XmlNodeType.Element) continue;
                if (reader.Name == "Root") continue;                reader.ReadStartElement("Row");
                reader.ReadStartElement("Key");
                TKey key = (TKey)keySerializer.Deserialize(reader);
                reader.ReadEndElement();
                reader.ReadStartElement("Value");
                TValue value = (TValue)valueSerializer.Deserialize(reader);
                reader.ReadEndElement();
                dic.Add(key, value);
                reader.ReadEndElement();
                //reader.MoveToContent();            }
            return dic;
        }        /// <summary>
        /// 序列化泛型数组为xml文件
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <param name="FullName"></param>
        /// <returns>是否序列化成功</returns>
        public static bool Serialize<T>(T t, string FullName)
        {
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
            TextWriter writer = new StreamWriter(FullName);
            try
            {
                xmlSerializer.Serialize(writer, t);                return true;
            }
            catch
            {
                return false;
            }
            finally
            {
                writer.Close();
            }
        }
        /// <summary>
        /// 序列化 Dictionary
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <typeparam name="TValue"></typeparam>
        /// <param name="dic"></param>
        /// <param name="FullName"></param>
        /// <returns></returns>
        public static bool Serialize<TKey, TValue>(Dictionary<TKey, TValue> dic, string FullName)
        {
            try
            {
                System.Xml.XmlWriterSettings settings = new System.Xml.XmlWriterSettings();
                settings.Encoding = Encoding.UTF8;
                settings.Indent = true;
                settings.ConformanceLevel = ConformanceLevel.Fragment;                XmlWriter writer = XmlWriter.Create(FullName, settings);
                XmlSerializer KeySerializer = new XmlSerializer(typeof(TKey));
                XmlSerializer ValueSerializer = new XmlSerializer(typeof(TValue));
                writer.WriteStartElement("Root");
                foreach (KeyValuePair<TKey, TValue> kv in dic)
                {
                    writer.WriteStartElement("Row");
                    writer.WriteStartElement("Key");
                    KeySerializer.Serialize(writer, kv.Key);
                    writer.WriteEndElement();
                    writer.WriteStartElement("Value");
                    ValueSerializer.Serialize(writer, kv.Value);
                    writer.WriteEndElement();
                    writer.WriteEndElement();                } writer.WriteEndElement();
                writer.Close();                return true;
            }
            catch
            {
                try
                {
                    File.Delete(FullName);
                }
                catch { }
                return false;
            }
        }
        }
    [Serializable()]
    public class CollectionBase<T> : CollectionBase where T : class
    {
         public CollectionBase()
        {
        }
        public CollectionBase(CollectionBase<T> value)
        {
            this.AddRange(value);
        }        public CollectionBase(T[] value)
        {
            this.AddRange(value);
        }
        /// <summary>
        /// 成员索引
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T this[int index]
        {
            get
            {
                return (this.List[index]) as T;
            }
            set
            {
                this.List[index] = value;
            }
        }        /// <summary>
        /// 添加一个成员
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Add(T model)
        {
            return this.List.Add(model);
        }        /// <summary>
        /// 添加应用
        /// </summary>
        /// <param name="value"></param>
        public void AddRange(T[] value)
        {
            for (int i = 0; i < value.Length; i++)
            {
                this.Add(value[i]);
            }
        }        public void AddRange(TopWinCMS.Common.CollectionBase<T> value)
        {
            for (int i = 0; i < value.Count; i++)
            {
                this.Add((T)value.List[i]);
            }
        }
        /// <summary>
        /// 检查集合中是否包含某应用
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool Contains(T value)
        {
            return base.List.Contains(value);
        }        public void CopyTo(T[] array, int index)
        {
            base.List.CopyTo(array, index);
        }
        public new ApplicationCollectionEnumerator<T> GetEnumerator()
        {
            return new ApplicationCollectionEnumerator<T>(this);
        }
        public int IndexOf(T value)
        {
            return base.List.IndexOf(value);
        }        public void Insert(int index, T value)
        {
            base.List.Insert(index, value);
        }
        /// <summary>
        /// 移除一个成员
        /// </summary>
        /// <param name="model"></param>
        public void Remove(T model)
        {
            this.List.Remove(model);
        }
    } 

Answer 5

   public class ApplicationCollectionEnumerator<T> : IEnumerator where T : class
    {        private IEnumerator _enumerator;
        private IEnumerable _temp;
        public ApplicationCollectionEnumerator(CollectionBase<T> mappings)
        {
            this._temp = mappings;
            this._enumerator = this._temp.GetEnumerator();
        }        public bool MoveNext()
        {
            return this._enumerator.MoveNext();
        }        public void Reset()
        {
            this._enumerator.Reset();
        }        bool IEnumerator.MoveNext()
        {
            return this._enumerator.MoveNext();
        }        void IEnumerator.Reset()
        {
            this._enumerator.Reset();
        }
        public T Current
        {
            get
            {
                return (T)this._enumerator.Current;
            }
        }        object IEnumerator.Current
        {
            get
            {
                return this._enumerator.Current;
            }
        }
    }

Answer 6

http://blog.csdn.net/jiaao/archive/2008/08/01/2754033.aspx

Answer 7

    protected void Page_Load(object sender, EventArgs e)
    {
        List<Users> list = new List<Users>();
        Users users = new Users();
        users.ID = 1;
        users.Name = "csdn";
        list.Add(users);
        string seri = Seri(list);
        Response.Write(seri);
        List<Users> us = (List<Users>)Deseri(typeof(List<Users>), seri);
        if (us.Count>0)
        {
            Response.Write(us[0].ID + "===" + us[0].Name);
        }
    }
    public string Seri(object obj)
    {
        StringBuilder sb = new StringBuilder();
        XmlSerializer xml = new XmlSerializer(obj.GetType());
        MemoryStream ms = new MemoryStream();
        XmlTextWriter text = new XmlTextWriter(ms, Encoding.UTF8);
        text.Formatting = Formatting.Indented;
        xml.Serialize(text, obj);
        ms.Seek(0, SeekOrigin.Begin);
        using (StreamReader reader = new StreamReader(ms))
        {
            sb.Append(reader.ReadToEnd());
        }
        ms.Close(); ms.Dispose();
        return sb.ToString();
    }
    public object Deseri(Type type,string content)
    {
        XmlSerializer xml = new XmlSerializer(type);
        byte[] b = Encoding.UTF8.GetBytes(content);
        return xml.Deserialize(new MemoryStream(b));
    }