Xml与DataTable等使用的类

 Xml其结构化的存储方式和数据DataTable其结构本身就有共性，两个可建立一系列的转化类库。

using  System;
using  System.ComponentModel;
using  System.Configuration;
using  System.Data;
using  System.IO;
using  System.Web;
using  System.Collections;

namespace  Beasyer.Lib
... {

    [DataObject(true)]
    public abstract class TodoXmlDataObject
    ...{
        private DataSet _ds;
        private DataSet DataSet
        ...{
            get
            ...{
                if (_ds == null)
                ...{
                    _ds = new DataSet();
                    _ds.ReadXmlSchema(XsdFile);
                    LoadData();
                }
                return _ds;
            }
        }

        private DataTable Table
        ...{
            get ...{ return DataSet.Tables[0]; }
        }

        protected abstract string RootPath
        ...{
            get;
        }
        protected abstract bool CanReadStream
        ...{
            get;
        }
        protected virtual bool CanWriteStream
        ...{
            get ...{ return true; }
        }
        protected abstract Stream XmlStream
        ...{
            get;
        }
        protected abstract string XsdFile
        ...{
            get;
        }

        [DataObjectMethod(DataObjectMethodType.Select)]
        public DataView Select(string sortkey)
        ...{
            Table.DefaultView.Sort = sortkey;
            return Table.DefaultView;
        }
        [DataObjectMethod(DataObjectMethodType.Select)]
        public DataView Select()
        ...{
            return Table.DefaultView;
        }
        [DataObjectMethod(DataObjectMethodType.Insert)]
        public int Insert(Hashtable ht)
        ...{
            DataRow dr = Table.NewRow();
            foreach (DictionaryEntry de in ht)
            ...{
                dr[de.Key.ToString()] = de.Value.ToString();
            }
            Table.Rows.Add(dr);
            SaveChanges();
            return 1;
        }
        [DataObjectMethod(DataObjectMethodType.Update)]
        public virtual int Update(Hashtable ht, int Original_ItemID)
        ...{
            DataRow[] rows = Table.Select(String.Format("ItemID={0}", Original_ItemID));

            if (rows.Length > 0)
            ...{
                DataRow dr = rows[0];
                dr.BeginEdit();
                foreach (DictionaryEntry de in ht)
                ...{
                    dr[de.Key.ToString()] = de.Value.ToString();
                }
                dr.EndEdit();
                SaveChanges();
                return 1;
            }
            return 0;
        }
        [DataObjectMethod(DataObjectMethodType.Delete)]
        public virtual int Delete(int Original_ItemID)
        ...{
            DataRow[] rows = Table.Select(String.Format("ItemID={0}", Original_ItemID));

            if (rows.Length > 0)
            ...{
                Table.Rows.Remove(rows[0]);
                SaveChanges();
                return 1;
            }
            return 0;
        }

        protected virtual void LoadData()
        ...{
            if (CanReadStream)
            ...{
                _ds.ReadXml(XmlStream, XmlReadMode.IgnoreSchema);
            }
        }
        protected virtual void SaveChanges()
        ...{
            DataSet.AcceptChanges();
            if (CanWriteStream)
            ...{
                XmlStream.Flush();
                DataSet.WriteXml(XmlStream, XmlWriteMode.IgnoreSchema);
            }
            else
            ...{
                throw new ApplicationException("不能写入Xml,检查是否为写保护");
            }
        }
    }

    public class TodoXmlDataObjectFromFile : TodoXmlDataObject
    ...{
        private Stream _stream;
        private string _xmlPath;
        private string _rootPath;
        private string _xsdfile;

        public TodoXmlDataObjectFromFile()
        ...{ }
        public TodoXmlDataObjectFromFile(string rootPath, string xsdPath, string xmlPath)
        ...{
            _rootPath = rootPath;
            _xmlPath = xmlPath;
            _xsdfile = xsdPath;
        }

        private string XmlFile
        ...{
            get ...{ return Path.Combine(RootPath, _xmlPath); }
        }

        protected override string RootPath
        ...{
            get
            ...{
                if (_rootPath != null)
                ...{
                    return _rootPath;
                }
                else if (HttpContext.Current != null)
                ...{
                    return HttpContext.Current.Server.MapPath(HttpContext.Current.Request.ApplicationPath);
                }
                else
                ...{
                    throw new ApplicationException("找不到应用程序的根目录");
                }
            }
        }
        protected override string XsdFile
        ...{
            get ...{ return Path.Combine(RootPath, _xsdfile); }
        }
        protected override bool CanReadStream
        ...{
            get ...{ return File.Exists(XmlFile); }
        }
        protected override Stream XmlStream
        ...{
            get
            ...{
                if (_stream == null)
                ...{
                    _stream = new FileStream(XmlFile, FileMode.OpenOrCreate, FileAccess.Read, FileShare.Read);
                }
                return _stream;
            }
        }

        protected override void LoadData()
        ...{
            XmlStream.Seek(0, SeekOrigin.Begin);
            base.LoadData();
        }
        protected override void SaveChanges()
        ...{
            XmlStream.Position = 0;
            XmlStream.SetLength(0);
            base.SaveChanges();
            XmlStream.Flush();
        }
    }

    public class TodoXmlDataObjectFromSession : TodoXmlDataObjectFromFile
    ...{
        private string _sessionkey;

        public TodoXmlDataObjectFromSession()
        ...{ }
        public TodoXmlDataObjectFromSession(string sessionKey)
        ...{
            _sessionkey = sessionKey;
        }

        private string SessionKey
        ...{
            get ...{ return _sessionkey; }
        }

        protected override Stream XmlStream
        ...{
            get
            ...{
                if (HttpContext.Current != null)
                ...{
                    Stream sessionStream = HttpContext.Current.Session[SessionKey] as Stream;

                    if (sessionStream == null)
                    ...{
                        if (CanReadStream && base.XmlStream != null)
                        ...{
                            Stream baseStream = base.XmlStream;

                            sessionStream = new MemoryStream((int)baseStream.Length);
                            byte[] data = new byte[baseStream.Length];
                            baseStream.Read(data, 0, (int)baseStream.Length);
                            sessionStream.Write(data, 0, data.Length);
                            sessionStream.Seek(0, SeekOrigin.Begin);
                        }
                        else
                        ...{
                            sessionStream = new MemoryStream(256);
                        }
                        HttpContext.Current.Session[SessionKey] = sessionStream;
                    }
                    return sessionStream;
                }

                throw new ApplicationException("不能从Session中加载xml文档");
            }
        }
    }
}