看到不错的xml代码分享下

using System;
using System.Text;
using System.Xml;
using System.Xml.XPath;
using System.Collections;
using System.Data;
using Dll.CommonOperation;
using System.Collections.Generic;
namespace Dll.OperateXmlDatabase
{
    public enum ParameterDirection
    {
        /// <summary>
        /// 插入
        /// </summary>
        Insert,      //插入
        /// <summary>
        /// 更新
        /// </summary>
        Update,      //更新
        /// <summary>
        /// 相等
        /// </summary>
        Equal,       //相等
        /// <summary>
        /// 不等
        /// </summary>
        NotEqual,    //不相等
        /// <summary>
        /// 小于
        /// </summary>
        Little,      //小于
        /// <summary>
        /// 大于
        /// </summary>
        Great,       //大于
        /// <summary>
        /// 模糊匹配
        /// </summary>
        Like         //模糊匹配
    }
    //定义该类为密封类，阻止该类被继承    
    public sealed class XmlParamter
    {
        //实例构造函数
        public XmlParamter() { }
        //定义属性Name
        private string name;
        /// <summary>
        /// 名称
        /// </summary>
        public string Name
        {
            get { return this.name; }
            set { this.name = value; }
        }
        //定义属性Value
        private string value;

        /// <summary>
        /// 值
        /// </summary>
        public string Value
        {
            get { return this.value; }
            set { this.value = value; }
        }
        //定义属性Direction
        private ParameterDirection direction;
        /// <summary>
        /// 对xml的操作
        /// </summary>
        public ParameterDirection Direction
        {
            get { return this.direction; }
            set { this.direction = value; }
        }
    }

    public class XmlDatabase
    {
        public XmlDatabase() { }

        #region 获取XML中的数据
        /// <summary>
        /// 构造缓存
        /// </summary>
        private static Dictionary<string, DataTable> DataTableSchem
            = new Dictionary<string, DataTable>();

        /// <summary>
        /// 得到构造
        /// </summary>
        /// <param name="Path"></param>
        /// <param name="TableName"></param>
        /// <returns></returns>
        private static DataTable GetDataTableSchem(string Path, string TableName)
        {
            if (DataTableSchem.ContainsKey(Path))
            {
                return DataTableSchem[Path];
            }

            //创建XmlDocument类的实例
            XmlDocument xmldoc = new XmlDocument();
            //调用XmlDocument类中的Load()方法加载XML文件
            xmldoc.Load(Path);
            //创建DataTable类型的变量dt
            DataTable dt = new DataTable();
            ///获取根节点
            XmlNode rootNode = xmldoc.SelectSingleNode(TableName);
            //判断节点及其子节点是否为空,为空将返空值
            if (rootNode == null) return null;
            if (rootNode.ChildNodes.Count <= 0) return null;


            ///创建保存记录的数据列
            foreach (XmlAttribute attr in rootNode.ChildNodes[0].Attributes)
            {   //--这里开始是亮点-读所有列的名称，作为表格列的名称
                //--不过这里没有定义类型可惜啊－全部是子符串类型--遗憾
                dt.Columns.Add(new DataColumn(attr.Name, typeof(string)));
            }

            try
            {
                DataTableSchem.Add(Path, dt);
            }
            catch
            { 
            
            }


            return dt;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="inputSchem">带有构造的datatable</param>
        /// <param name="path"></param>
        /// <param name="tableName"></param>
        /// <returns></returns>
        private static DataTable GetData(DataTable inputSchem, string Path, string TableName)
        {

            //创建XmlDocument类的实例
            XmlDocument xmldoc = new XmlDocument();
            //调用XmlDocument类中的Load()方法加载XML文件
            xmldoc.Load(Path);
            //创建DataTable类型的变量dt
            DataTable dt = new DataTable();
            ///获取根节点
            XmlNode rootNode = xmldoc.SelectSingleNode(TableName);


            foreach (XmlNode node in rootNode.ChildNodes)
            {
                //创建数据表行，并在其中添加数据
                DataRow row = inputSchem.NewRow();
                foreach (DataColumn column in inputSchem.Columns)
                {   ///读取每一个属性
                    row[column.ColumnName] = node.Attributes[column.ColumnName].Value;
                }
                //将数据表行添加到数据表中
                inputSchem.Rows.Add(row);
            }
            //返回DataTable对象dt
            return inputSchem;
        }



        /// <summary>
        /// 获取xml的数据
        /// </summary>
        /// <param name="path">xml文件路径</param>
        /// <param name="tableName">表名称（实际上是跟目录）</param>
        /// <returns></returns>
        public static DataTable GetData(string path, string tableName)
        {

          

            //--得到dt的构造信息
            DataTable dt = GetDataTableSchem(path, "/" +tableName + "s");
            if (dt == null) return null;

            string xmlPath = "/" + tableName + "s/" + tableName;
            
            //--得到数据
            GetData(dt, path, xmlPath);
            return dt;
        }

        /// <summary>
        /// 读数据并且用特定的条件搜索
        /// </summary>
        /// <param name="path">路径</param>
        /// <param name="tableName">表名</param>
        /// <param name="param">参数</param>
        /// <returns></returns>
        public static DataTable GetData(string path, string tableName, params XmlParamter[] param)
        {

            //--得到dt的构造信息
            DataTable dt = GetDataTableSchem(path, "/" + tableName + "s");
            if (dt == null) return null;


            string xmlPath = "/" + tableName + "s/" + tableName;
            int operationCount = 0;
            StringBuilder operation = new StringBuilder();
            foreach (XmlParamter p in param)
            {
                //--如果参数是插入或者更新就跳过这次
                if (p.Direction == ParameterDirection.Insert
                    || p.Direction == ParameterDirection.Update)
                {
                    continue;
                }
                ///创建条件表达式(解稀器模式)
                switch (p.Direction)
                {
                    case ParameterDirection.Equal:
                        operation.Append("@" + p.Name + "='" + p.Value + "'");
                        break;
                    case ParameterDirection.NotEqual:
                        operation.Append("@" + p.Name + "<>'" + p.Value + "'");
                        break;
                    case ParameterDirection.Little:
                        operation.Append("@" + p.Name + "<'" + p.Value + "'");
                        break;
                    case ParameterDirection.Great:
                        operation.Append("@" + p.Name + ">'" + p.Value + "'");
                        break;
                    case ParameterDirection.Like:
                        operation.Append("contains(@" + p.Name + ",'" + p.Value + "')");
                        break;
                    default: break;
                }
                operationCount++;
                operation.Append(" and ");
            }
            if (operationCount > 0)
            {   ///修正XPath
                operation.Remove(operation.Length - 5, 5);
                //--在路径语句中拼合上面的条件
                xmlPath += "[" + operation.ToString() + "]";
            }

            //--得到数据--dt是带结构不带数据,path文件路径,xmlpath-查询语句
            GetData(dt, path, xmlPath);
            return dt;
        }

        #endregion

        #region 添加数据

        public static int AddXmlData(string path, string tableName, params XmlParamter[] param)
        {
            //创建XmlDocument类的实例
            XmlDocument xmldoc = new XmlDocument();
            //调用XmlDocument类中的Load()方法加载XML文件
            xmldoc.Load(path);
            ///选择根节点
            XmlNode node = xmldoc.SelectSingleNode("/" + tableName + "s");
            if (node == null) return -1;

            ///创建新记录的ID值
            int newID;
            if (node.LastChild == null)
            {
                newID = 1;
            }
            else
            {
                //--生成id是最后一个id+1就取得了新的id
                newID = DataTypeConvert.ConvertToInt(node.LastChild.Attributes["ID"].Value) + 1;
            }
            if (newID < 1) return -1;
            ///创建一个新节点
            XmlNode newNode = xmldoc.CreateNode(XmlNodeType.Element, tableName, null);
            if (newNode == null) return -1;
            ///添加ID的值
            newNode.Attributes.Append(CreateNodeAttribute(xmldoc, "ID", newID.ToString()));
            ///添加新节点的属性
            foreach (XmlParamter p in param)
            {
                newNode.Attributes.Append(CreateNodeAttribute(xmldoc, p.Name, p.Value));
            }
            ///将新节点追加到根节点中
            node.AppendChild(newNode);
            //保存XML文档
            xmldoc.Save(path);
            return newID;
        }

        #endregion

        #region 更新数据
        public static int UpdateData(string path, string tableName, params XmlParamter[] param)
        {
            //创建XmlDocument类的实例
            XmlDocument xmldoc = new XmlDocument();
            //调用XmlDocument类中的Load()方法加载XML文件
            xmldoc.Load(path);
            ///创新选择被修改节点的XPath
            string xmlPath = "/" + tableName + "s/" + tableName;
            int operationCount = 0;
            StringBuilder operation = new StringBuilder();
            foreach (XmlParamter p in param)
            {
                if (p.Direction == ParameterDirection.Insert
                    || p.Direction == ParameterDirection.Update)
                {
                    continue;
                }
                //创建条件表达式
                switch (p.Direction)
                {
                    case ParameterDirection.Equal:
                        operation.Append("@" + p.Name + "='" + p.Value + "'");
                        break;
                    case ParameterDirection.NotEqual:
                        operation.Append("@" + p.Name + "<>'" + p.Value + "'");
                        break;
                    case ParameterDirection.Little:
                        operation.Append("@" + p.Name + "<'" + p.Value + "'");
                        break;
                    case ParameterDirection.Great:
                        operation.Append("@" + p.Name + ">'" + p.Value + "'");
                        break;
                    case ParameterDirection.Like:
                        operation.Append("contains(@" + p.Name + ",'" + p.Value + "')");
                        break;
                    default: break;
                }
                operationCount++;
                //应用StringBuilder类中的Append方法追加"and"字符串
                operation.Append(" and ");
            }
            if (operationCount > 0)
            {
                operation.Remove(operation.Length - 5, 5);
                xmlPath += "[" + operation.ToString() + "]";
            }
            //获取XML文件中的所有节点
            XmlNodeList nodeList = xmldoc.SelectNodes(xmlPath);
            if (nodeList == null) return -1;
            //遍历XML文件中节点中的所有子节点
            foreach (XmlNode node in nodeList)
            {    ///修改单个节点的属性
                foreach (XmlParamter p in param)
                {
                    if (p.Direction == ParameterDirection.Update)
                    {
                        node.Attributes[p.Name].Value = p.Value;
                    }
                }
            }
            ///保存XML文档
            xmldoc.Save(path);
            return nodeList.Count;
        }

        #endregion

        #region 删除数据

        public static int DeleteXmlData(string path, string tableName, params XmlParamter[] param)
        {
            //创建XmlDocument类的实例
            XmlDocument xmldoc = new XmlDocument();
            //调用XmlDocument类中的Load()方法加载XML文件
            xmldoc.Load(path);
            ///创新选择被删除节点的XPath
            string xmlPath = "/" + tableName + "s/" + tableName;
            int operationCount = 0;
            StringBuilder operation = new StringBuilder();
            foreach (XmlParamter p in param)
            {
                if (p.Direction == ParameterDirection.Insert
                    || p.Direction == ParameterDirection.Update)
                {
                    continue;
                }
                switch (p.Direction)
                {
                    case ParameterDirection.Equal:
                        operation.Append("@" + p.Name + "='" + p.Value + "'");
                        break;
                    case ParameterDirection.NotEqual:
                        operation.Append("@" + p.Name + "<>'" + p.Value + "'");
                        break;
                    case ParameterDirection.Little:
                        operation.Append("@" + p.Name + "<'" + p.Value + "'");
                        break;
                    case ParameterDirection.Great:
                        operation.Append("@" + p.Name + ">'" + p.Value + "'");
                        break;
                    case ParameterDirection.Like:
                        operation.Append("contains(@" + p.Name + ",'" + p.Value + "')");
                        break;
                    default: break;
                }
                operationCount++;
                operation.Append(" and ");
            }
            if (operationCount > 0)
            {
                operation.Remove(operation.Length - 5, 5);
                xmlPath += "[" + operation.ToString() + "]";
            }
            //获取XML文件中的所有节点
            XmlNodeList nodeList = xmldoc.SelectNodes(xmlPath);
            if (nodeList == null) return -1;
            ///删除被选择的节点
            foreach (XmlNode node in nodeList)
            {    ///删除单个节点
                XmlNode parentNode = node.ParentNode;
                parentNode.RemoveChild(node);
            }
            ///保存删除后的XML文档
            xmldoc.Save(path);
            return nodeList.Count;
        }

        #endregion

        #region 创建参数
        /// <summary>
        /// 创建一个参数
        /// </summary>
        /// <param name="doc">文档</param>
        /// <param name="name">节点</param>
        /// <param name="value">参数</param>
        /// <returns></returns>
        private static XmlAttribute CreateNodeAttribute(XmlDocument doc, String name, String value)
        {
            XmlAttribute attribute = doc.CreateAttribute(name, null);
            attribute.Value = value;
            return attribute;
        }
        /// <summary>
        /// 创建参数组
        /// </summary>
        /// <param name="name">节点</param>
        /// <param name="value">数值</param>
        /// <param name="direciton">操作</param>
        /// <returns></returns>
        private static XmlParamter CreateParameter(string name, string value, ParameterDirection direciton)
        {
            XmlParamter p = new XmlParamter();
            p.Name = name;
            p.Value = value;
            p.Direction = direciton;

            return p;
        }
        /// <summary>
        /// 创建插入
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static XmlParamter CreateInsertParameter(string name, string value)
        {
            return CreateParameter(name, value, ParameterDirection.Insert);
        }

        /// <summary>
        /// 创建更新
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static XmlParamter CreateUpdateParameter(string name, string value)
        {
            return CreateParameter(name, value, ParameterDirection.Update);
        }

        public static XmlParamter CreateEqualParameter(string name, string value)
        {
            return CreateParameter(name, value, ParameterDirection.Equal);
        }
        /// <summary>
        /// 大于
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static XmlParamter CreateGreatParameter(string name, string value)
        {
            return CreateParameter(name, value, ParameterDirection.Great);
        }

        /// <summary>
        /// 小于
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static XmlParamter CreateLittleParameter(string name, string value)
        {
            return CreateParameter(name, value, ParameterDirection.Little);
        }

        /// <summary>
        /// 不等于
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static XmlParamter CreateNotEqualParameter(string name, string value)
        {
            return CreateParameter(name, value, ParameterDirection.NotEqual);
        }

        /// <summary>
        /// 模糊搜索
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static XmlParamter CreateLikeParameter(string name, string value)
        {
            return CreateParameter(name, value, ParameterDirection.Like);
        }

        #endregion
    }
}

 

using System;
using System.Text;
using System.Data;
using System.Web.UI.WebControls;
using System.Data.SqlClient;
using System.Web;
using System.Web.UI;
using System.Xml;

namespace Dll.CommonOperation
{


    public class DataBinder
    {
        #region 绑定控件的数据

        public DataBinder() { }

        /// <summary>
        /// 绑定列表控件的数据，数据源为SqlDataReader对象
        /// </summary>
        /// <param name="list"></param>
        /// <param name="dataSource"></param>
        /// <param name="dataTextField"></param>
        /// <param name="dataValueField"></param>
        public static void BindListData(ListControl list, SqlDataReader dataSource,
            string dataTextField, string dataValueField)
        {
            if (dataSource == null) { return; }
            ///绑定数据
            list.DataSource = dataSource;
            list.DataTextField = dataTextField;
            list.DataValueField = dataValueField;
            list.DataBind();
            ///关闭数据源
            dataSource.Close();
        }

        /// <summary>
        /// 绑定列表控件的数据，数据源为DataSet对象
        /// </summary>
        /// <param name="list"></param>
        /// <param name="dataSource"></param>
        /// <param name="dataTextField"></param>
        /// <param name="dataValueField"></param>
        public static void BindListData(ListControl list, DataSet dataSource,
            string dataTextField, string dataValueField)
        {
            if (dataSource == null) { return; }
            ///绑定数据
            list.DataSource = dataSource;
            list.DataTextField = dataTextField;
            list.DataValueField = dataValueField;
            list.DataBind();
        }

        /// <summary>
        /// 绑定列表控件的数据，数据源为DataTable对象
        /// </summary>
        /// <param name="list"></param>
        /// <param name="dataSource"></param>
        /// <param name="dataTextField"></param>
        /// <param name="dataValueField"></param>
        public static void BindListData(ListControl list, DataTable dataSource,
            string dataTextField, string dataValueField)
        {
            if (dataSource == null) { return; }
            ///绑定数据
            list.DataSource = dataSource;
            list.DataTextField = dataTextField;
            list.DataValueField = dataValueField;
            list.DataBind();
        }

        /// <summary>
        /// 绑定GridView控件的数据，数据源为SqlDataReader对象
        /// </summary>
        /// <param name="gv"></param>
        /// <param name="dataSource"></param>
        public static void BindGridViewData(GridView gv, SqlDataReader dataSource)
        {
            if (dataSource == null) { return; }
            ///绑定数据
            gv.DataSource = dataSource;
            gv.DataBind();
            ///关闭数据源
            dataSource.Close();
        }

        /// <summary>
        /// 绑定GridView控件的数据，数据源为DataSet对象
        /// </summary>
        /// <param name="gv"></param>
        /// <param name="dataSource"></param>
        public static void BindGridViewData(GridView gv, DataSet dataSource)
        {
            if (dataSource == null) { return; }
            ///绑定数据
            gv.DataSource = dataSource;
            gv.DataBind();
        }

        /// <summary>
        /// 绑定GridView控件的数据，数据源为DataTable对象
        /// </summary>
        /// <param name="gv"></param>
        /// <param name="dataSource"></param>
        public static void BindGridViewData(GridView gv, DataTable dataSource)
        {
            if (dataSource == null) { return; }
            ///绑定数据
            gv.DataSource = dataSource;
            gv.DataBind();
        }

        /// <summary>
        /// 绑定DataList控件的数据，数据源为SqlDataReader对象
        /// </summary>
        /// <param name="list"></param>
        /// <param name="dataSource"></param>
        public static void BindDataListData(DataList list, SqlDataReader dataSource)
        {
            if (dataSource == null) { return; }
            ///绑定数据
            list.DataSource = dataSource;
            list.DataBind();
            ///关闭数据源
            dataSource.Close();
        }

        /// <summary>
        /// 绑定DataList控件的数据，数据源为DataSet对象
        /// </summary>
        /// <param name="list"></param>
        /// <param name="dataSource"></param>
        public static void BindDataListData(DataList list, DataSet dataSource)
        {
            if (dataSource == null) { return; }
            ///绑定数据
            list.DataSource = dataSource;
            list.DataBind();
        }

        /// <summary>
        /// 绑定DataList控件的数据，数据源为DataTable对象
        /// </summary>
        /// <param name="list"></param>
        /// <param name="dataSource"></param>
        public static void BindDataListData(DataList list, DataTable dataSource)
        {
            if (dataSource == null) { return; }
            ///绑定数据
            list.DataSource = dataSource;
            list.DataBind();
        }

        #endregion
    }

    public class ButtonEnable
    {
        #region 设置按钮的可用性

        public ButtonEnable() { }

        /// <summary>
        /// 根据整数列表设置按钮的可用性
        /// </summary>
        /// <param name="button"></param>
        /// <param name="idList"></param>
        public static void ControlButtonEnable(Button button, int[] idList)
        {   ///计算按钮的可用性
            bool IsEnabled = true;
            ///列表为空
            if (idList == null)
            {
                button.Enabled = IsEnabled;
                return;
            }
            foreach (int id in idList)
            {   ///如果id值大于0，则按钮可用
                IsEnabled = IsEnabled && (id > 0 ? true : false);
                if (IsEnabled == false) { break; }
            }
            button.Enabled = IsEnabled;
        }

        /// <summary>
        /// 根据列表控件列表设置按钮的可用性
        /// </summary>
        /// <param name="button"></param>
        /// <param name="listControl"></param>
        public static void ControlButtonEnable(Button button,
            params ListControl[] listControl)
        {
            bool IsEnabled = true;
            ///列表为空
            if (listControl == null)
            {
                button.Enabled = IsEnabled;
                return;
            }
            foreach (ListControl control in listControl)
            {
                if (control != null)
                {   ///列表包含选择项，则按钮可用
                    IsEnabled = IsEnabled && (control.Items.Count > 0 ? true : false);
                    if (IsEnabled == false) { break; }
                }
            }
            button.Enabled = IsEnabled;
        }

        /// <summary>
        /// 根据整数列表和列表控件列表共同设置按钮的可用性
        /// </summary>
        /// <param name="button"></param>
        /// <param name="idList"></param>
        /// <param name="listControl"></param>
        public static void ControlButtonEnable(Button button, int[] idList,
            params ListControl[] listControl)
        {   ///根据参数idList设置按钮可用性
            ControlButtonEnable(button, idList);
            ///根据参数listControl设置按钮的可用性
            ControlButtonEnable(button, listControl);
        }

        #endregion
    }

    public class ListSelectedItem
    {
        #region 设置列表控件的选择项

        public ListSelectedItem() { }

        /// <summary>
        ///  根据Value属性把列表控件的选择项设置为指定项
        /// </summary>
        /// <param name="list"></param>
        /// <param name="value"></param>
        public static void ListSelectedItemByValue(ListControl list, string value)
        {
            if (list == null) return;
            ///选择项为空
            if (list.Items.Count <= 0)
            {
                list.SelectedIndex = -1;
                return;
            }
            ///逐项进行比较，设置选择项
            for (int i = 0; i < list.Items.Count; i++)
            {
                if (list.Items[i].Value == value)
                {
                    list.SelectedIndex = i;
                    return;
                }
            }
            ///没有符合条件的选择项
            list.SelectedIndex = -1;
        }

        /// <summary>
        /// 根据Text属性把列表控件的选择项设置为指定项
        /// </summary>
        /// <param name="list"></param>
        /// <param name="text"></param>
        public static void ListSelectedItemByText(ListControl list, string text)
        {
            if (list == null) return;
            ///选择项为空
            if (list.Items.Count <= 0)
            {
                list.SelectedIndex = -1;
                return;
            }
            ///逐项进行比较，设置选择项
            for (int i = 0; i < list.Items.Count; i++)
            {
                if (list.Items[i].Text == text)
                {
                    list.SelectedIndex = i;
                    return;
                }
            }
            ///没有符合条件的选择项
            list.SelectedIndex = -1;
        }

        #endregion
    }

    public class DealwithString
    {
        #region 字符串处理

        public DealwithString() { }

        /// <summary>
        /// 根据时间创建字符串
        /// </summary>
        /// <returns></returns>
        public static string CreatedStringByTime()
        {
            DateTime now = DateTime.Now;
            string str = now.Year.ToString()
                + now.Month.ToString()
                + now.Day.ToString()
                + now.Hour.ToString()
                + now.Minute.ToString()
                + now.Second.ToString()
                + now.Millisecond.ToString();
            return (str);
        }

        /// <summary>
        /// 格式化显示字符串的长度，如果超过指定的长度，则显示...
        /// </summary>
        /// <param name="str"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static string FormatStringLength(string str, int length)
        {
            if (string.IsNullOrEmpty(str)) return string.Empty;

            ///如果包含中文字符，中文字符的长度加倍
            if (Encoding.UTF8.GetByteCount(str) > str.Length)
            {   ///调整为中文的长度，等于英文的一半
                length = length / 2;
            }
            if (str.Length > length)
            {
                return str.Substring(0, length) + "...";
            }
            return str;
        }

        #endregion
    }

    public class Dialog
    {
        public Dialog() { }

        #region 显示对话框

        public static void OpenDialog(HttpResponse response, string message)
        {
            response.Write("<script>alert('" + message + "')</script>");
        }

        public static void OpenDialogInAjax(Control c, string message)
        {
            //--System.Web.Extension必须引用
           ScriptManager.RegisterClientScriptBlock(
                c,
                c.GetType(),
                c.ID + DealwithString.CreatedStringByTime(),
                "alert('" + message + "')",
                true);
        }
        #endregion
    }
}