配置文件读写方法

using System;
using System.Collections.Generic;
using System.Data;
using System.Xml;

namespace Lib.Text
{
///
/// 常用 XML配置文件读写方法
///
public class XMLSetFile
{
///
/// 写入自定义节点的键值对
///
///
/// 键
/// 值
/// XML文件路径
/// bool
public static bool SetSectionValue(string Section, string Key, string Value, string FilePath)
{
try
{
if (IsNum(Section))
{ throw new Exception(“Section不能以数字开头”); }
if (IsNum(Key))
{ throw new Exception(“Key不能以数字开头”); }
if (IsSpecialChar(Key))
{ throw new Exception(“Key不允许包含特殊字符”); }
XmlDocument doc = Get_RootDoc(FilePath);
//4、给文档添加根节点
XmlElement config = doc.DocumentElement;
XmlElement xe= config[“Section”];
XmlElement Sec = xe[Section];
if (Sec == null)
{
Sec = doc.CreateElement(Section);
xe.AppendChild(Sec);
}
XmlNode nodeparams2 = Sec.SelectSingleNode(Key);//子节点
if (nodeparams2 == null)
{
XmlElement name = doc.CreateElement(Key);
name.InnerText = Value;
Sec.AppendChild(name);
}
else
{

                XmlNodeList nodelist = nodeparams2.ChildNodes;
                if (nodelist != null)
                {
                    XmlNode ID = nodelist[0];
                    if (ID != null)
                    { ID.InnerText = Value; }
                    else
                    { nodeparams2.InnerText = Value; }
                }
            }
            doc.Save(FilePath);
            return true;
        }
        catch (Exception ex)
        {

            throw ex;
        }
    }
    /// <summary>
    /// 写入自定义节点的键值对
    /// </summary>
    /// <param name="Section">节点</param>
    /// <param name="dic">字典</param>
    /// <param name="FilePath">XML文件路径</param>
    /// <returns>bool</returns>
    public static bool SetSectionValue(string Section, Dictionary<string, string> dic, string FilePath)
    {
        try
        {
            if (string.IsNullOrEmpty(Section))
            { throw new Exception("Section不能为空"); }
            if (IsNum(Section))
            { throw new Exception("Section不能以数字开头"); }

            XmlDocument doc = Get_RootDoc(FilePath);
            //4、给文档添加根节点
            XmlElement config = doc.DocumentElement;
            XmlElement xe = config["Section"];
            XmlElement Sec = xe[Section];
            if (Sec == null)
            {
                Sec = doc.CreateElement(Section);
                xe.AppendChild(Sec);
                foreach (var item in dic)
                {
                    if (string.IsNullOrEmpty(item.Key.ToString()))
                    { throw new Exception("Key不能为空"); }
                    if (IsNum(item.Key.ToString()))
                    { throw new Exception("Key不能以数字开头"); }
                    if (IsSpecialChar(item.Key.ToString()))
                    { throw new Exception("Key不允许包含特殊字符"); }

                    XmlElement key = doc.CreateElement(item.Key.ToString());

                    key.InnerText = item.Value;
                    Sec.AppendChild(key);
                }
            }

            else
            {
                Sec.RemoveAll();
                foreach (var item in dic)
                {
                    if (string.IsNullOrEmpty(item.Key.ToString()))
                    { throw new Exception("Key不能为空"); }
                  

                    if (IsNum(item.Key.ToString()))
                    { throw new Exception("Key不能以数字开头"); }
                    if (IsSpecialChar(item.Key.ToString()))
                    { throw new Exception("Key不允许包含特殊字符"); }

                    XmlElement key = doc.CreateElement(item.Key.ToString());
                    key.InnerText = item.Value;
                    Sec.AppendChild(key);
                }
            }
            doc.Save(FilePath);
            return true;
        }
        catch (Exception ex)
        {

            throw ex;
        }
    }
    /// <summary>
    /// 读取自定义节点的键值对
    /// </summary>
    /// <param name="Section">节点</param>
    /// <param name="Key">键</param>
    /// <param name="FilePath">XML文件路径</param>
    /// <returns>Dictionary</returns>
    public static string GetSectionValue(string Section, string Key, string FilePath)
    {
        try
        {
            string value = string.Empty;
            XmlDocument doc = Get_RootDoc(FilePath);
            //4、给文档添加根节点
            XmlElement config = doc.DocumentElement;
            XmlElement xe = config["Section"];
            XmlElement Sec = xe[Section];
            if (Sec == null)
            { return value; }
            XmlNode nodeparams2 = Sec.SelectSingleNode(Key);//子节点
            if (nodeparams2 != null)
            {
                XmlNodeList nodelist = nodeparams2.ChildNodes;
                if (nodelist != null && nodelist.Count > 0)
                {
                    XmlNode ID = nodelist[0];
                    if (ID.InnerText != null)
                        value = ID.InnerText;
                }

            }
            return value;

        }
        catch (Exception ex)
        {

            throw ex;
        }
    }
    /// <summary>
    /// 读取自定义节点的键值对
    /// </summary>
    /// <param name="Section">节点</param>
    /// <param name="FilePath">XML文件路径</param>
    /// <returns>Dictionary</returns>
    public static Dictionary<string, string> GetSectionValue(string Section, string FilePath)
    {
        try
        {
            Dictionary<string, string> dic = new Dictionary<string, string>();
            XmlDocument doc = Get_RootDoc(FilePath);
            //4、给文档添加根节点
            XmlElement config = doc.DocumentElement;
            XmlElement xe = config["Section"];
        
            XmlNode nodeparams2 = xe.SelectSingleNode(Section);//子节点
            if (nodeparams2 != null)
            {
                XmlNodeList nodelist = nodeparams2.ChildNodes;
                if (nodelist != null)
                {
                    foreach (XmlNode item in nodelist)
                    {
                        if (!dic.ContainsKey(item.Name))
                            dic.Add(item.Name, item.InnerText);
                    }
                }
            }
            return dic;
        }
        catch (Exception ex)
        {

            throw ex;
        }
    }
    /// <summary>
    /// 设置值
    /// </summary>
    /// <param name="Key">Key</param>
    /// <param name="Value">Value</param>
    /// <param name="FilePath">XML文件路径</param>
    /// <returns>bool</returns>
    public static bool SetValue(string Key, string Value, string FilePath)
    {
        try
        {
            if (string.IsNullOrEmpty(Key))
            { throw new Exception("Key不能为空"); }
          
            if (IsNum(Key))
            { throw new Exception("Key不能以数字开头"); }
            if (IsSpecialChar(Key))
            { throw new Exception("Key不允许包含特殊字符"); }
            XmlDocument doc = Get_RootDoc(FilePath);
            //4、给文档添加根节点
            XmlElement config = doc.DocumentElement;
            XmlElement Set = config["Set"];
            XmlNode nodeparams2 = Set.SelectSingleNode(Key);//子节点
            if (nodeparams2 == null)
            {
                XmlElement name = doc.CreateElement(Key);
                name.InnerText = Value;
                Set.AppendChild(name);
            }
            else
            {

                XmlNodeList nodelist = nodeparams2.ChildNodes;
                if (nodelist != null)
                {
                    XmlNode ID = nodelist[0];
                    if (ID != null)
                    { ID.InnerText = Value; }
                    else
                    { nodeparams2.InnerText = Value; }


                }
            }
            doc.Save(FilePath);
            return true;
        }
        catch (Exception ex)
        {

            throw ex;
        }
    }
    /// <summary>
    /// 获取值
    /// </summary>
    /// <param name="Key">Key</param>
    /// <param name="FilePath">XML文件路径</param>
    /// <returns>string</returns>
    public static string GetValue(string Key, string FilePath)
    {
        try
        {
            string value = string.Empty;
            XmlDocument doc = Get_RootDoc(FilePath);
            //4、给文档添加根节点
            XmlElement config = doc.DocumentElement;
            XmlElement Set = config["Set"];
            XmlNode nodeparams2 = Set.SelectSingleNode(Key);//子节点
            if (nodeparams2 != null)
            {
                XmlNodeList nodelist = nodeparams2.ChildNodes;
                if (nodelist != null && nodelist.Count > 0)
                {
                    XmlNode ID = nodelist[0];
                    if (ID.InnerText != null)
                        value = ID.InnerText;
                }

            }
            return value;

        }
        catch (Exception ex)
        {

            throw ex;
        }
    }
    /// <summary>
    /// 获取字典
    /// </summary>
    /// <param name="Key">Key</param>
    /// <param name="dic">字典</param>
    /// <param name="FilePath">XML文件路径</param>
    /// <returns>bool</returns>
    public static bool SetDic(string Key, Dictionary<string, string> dic, string FilePath)
    {

        try
        {
            if (string.IsNullOrEmpty(Key))
            { throw new Exception("Key不能为空"); }
           

            if (IsNum(Key))
            { throw new Exception("Key不能以数字开头"); }
            if (IsSpecialChar(Key))
            { throw new Exception("Key不允许包含特殊字符"); }

            XmlDocument doc = Get_RootDoc(FilePath);
            //4、给文档添加根节点
            XmlElement config = doc.DocumentElement;
            XmlElement Dic = config["Dic"];
            XmlNode nodeparams2 = Dic.SelectSingleNode(Key);//子节点
            if (nodeparams2 == null)
            {
                XmlElement name = doc.CreateElement(Key);
                Dic.AppendChild(name);
                foreach (var item in dic)
                {
                    if (string.IsNullOrEmpty(item.Key.ToString()))
                    { throw new Exception("Key不能为空"); }
                   

                    if (IsNum(item.Key.ToString()))
                    { throw new Exception("Key不能以数字开头"); }
                    if (IsSpecialChar(item.Key.ToString()))
                    { throw new Exception("Key不允许包含特殊字符"); }
                    XmlElement key = doc.CreateElement(item.Key.ToString());
                    key.InnerText = item.Value;
                    name.AppendChild(key);
                }
            }
            else
            {
                nodeparams2.RemoveAll();
                foreach (var item in dic)
                {
                    if (string.IsNullOrEmpty(item.Key.ToString()))
                    { throw new Exception("Key不能为空"); }
                   
                    if (IsNum(item.Key.ToString()))
                    { throw new Exception("Key不能以数字开头"); }
                    if (IsSpecialChar(item.Key.ToString()))
                    { throw new Exception("Key不允许包含特殊字符"); }
                    XmlElement key = doc.CreateElement(item.Key.ToString());
                    key.InnerText = item.Value;
                    nodeparams2.AppendChild(key);
                }
            }
            doc.Save(FilePath);
            return true;
        }
        catch (Exception ex)
        {

            throw ex;
        }
    }
    /// <summary>
    /// 设置字典
    /// </summary>
    /// <param name="Key">Key</param>
    /// <param name="FilePath">XML文件路径</param>
    /// <returns>Dictionary</returns>
    public static Dictionary<string, string> GetDic(string Key, string FilePath)
    {
        try
        {
            Dictionary<string, string> dic = new Dictionary<string, string>();
            XmlDocument doc = Get_RootDoc(FilePath);
            //4、给文档添加根节点
            XmlElement config = doc.DocumentElement;
            XmlElement Dic = config["Dic"];
            XmlNode nodeparams2 = Dic.SelectSingleNode(Key);//子节点
            if (nodeparams2 != null)
            {
                XmlNodeList nodelist = nodeparams2.ChildNodes;
                if (nodelist != null)
                {
                    foreach (XmlNode item in nodelist)
                    {
                        if (!dic.ContainsKey(item.Name))
                            dic.Add(item.Name, item.InnerText);
                    }
                }
            }
            return dic;
        }
        catch (Exception ex)
        {

            throw ex;
        }
    }
    /// <summary>
    /// 写入DataSet
    /// </summary>
    /// <param name="Key">DataSet名称</param>
    /// <param name="ds">DataSet</param>
    /// <param name="FilePath">文件路径</param>
    /// <returns></returns>
    public static bool SetDataSet(string Key, DataSet ds, string FilePath)
    {
        if (string.IsNullOrEmpty(Key))
        { throw new Exception("Key不能为空"); }
        

        if (IsNum(Key))
        { throw new Exception("Key不能以数字开头"); }
        if (IsSpecialChar(Key))
        { throw new Exception("Key不允许包含特殊字符"); }
        XmlDocument doc = Get_RootDoc(FilePath);
        //4、给文档添加根节点
        XmlElement config = doc.DocumentElement;
        XmlElement DS = config["DataSet"];
        XmlNode nodeparams2 = DS.SelectSingleNode(Key);//子节点
        if (nodeparams2 == null)
        {
            XmlElement nameds = doc.CreateElement(Key);
            DS.AppendChild(nameds);
            foreach (DataTable dt in ds.Tables)
            {
                XmlElement name_dt = doc.CreateElement("Tables");
                name_dt.SetAttribute("TableName", dt.TableName);
                nameds.AppendChild(name_dt);
                XmlNode nodeparams_dt = DS.SelectSingleNode(Key);//子节点
                //创建列 <DataColumn>
                XmlElement DataColumn = doc.CreateElement("DataColumn");
                name_dt.AppendChild(DataColumn);
                foreach (DataColumn colums in dt.Columns)
                {
                    if (string.IsNullOrEmpty(colums.ColumnName))
                    { throw new Exception("ColumnName不能为空"); }
                    if (IsNum(colums.ColumnName))
                    { throw new Exception("ColumnName不能以数字开头"); }
                    XmlElement ColumnName = doc.CreateElement(colums.ColumnName);
                    if (colums.Unique)
                    { ColumnName.SetAttribute("Unique", colums.Unique.ToString()); }
                    if (colums.AutoIncrement)
                    {
                        ColumnName.SetAttribute("AutoIncrement", colums.AutoIncrement.ToString());
                        if (colums.AutoIncrementStep > 0)
                        { ColumnName.SetAttribute("AutoIncrementStep", colums.AutoIncrementStep.ToString()); }
                        if (colums.AutoIncrementSeed > 0)
                        { ColumnName.SetAttribute("AutoIncrementSeed", colums.AutoIncrementSeed.ToString()); }
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(colums.DefaultValue.ToString()))
                        { ColumnName.SetAttribute("DefaultValue", colums.DefaultValue.ToString()); }
                    }
                    if (colums.ReadOnly)
                    { ColumnName.SetAttribute("ReadOnly", colums.ReadOnly.ToString()); }
                    ColumnName.SetAttribute("DataType", colums.DataType.ToString());
                    ColumnName.SetAttribute("Caption", colums.Caption.ToString());
                    ColumnName.InnerText = colums.ColumnName;
                    DataColumn.AppendChild(ColumnName);

                }
                foreach (DataRow row in dt.Rows)
                {
                    if (row.RowState == DataRowState.Deleted)
                    { continue; }
                    XmlElement table = doc.CreateElement("table");
                    name_dt.AppendChild(table);
                    foreach (DataColumn colums in dt.Columns)
                    {
                        if (string.IsNullOrEmpty(colums.ColumnName))
                        { throw new Exception("ColumnName不能为空"); }
                        if (IsNum(colums.ColumnName))
                        { throw new Exception("ColumnName不能以数字开头"); }
                        XmlElement c = doc.CreateElement(colums.ColumnName);
                        if (!string.IsNullOrEmpty(row[colums.ColumnName].ToString()))
                        {
                            //object ob = row[colums.ColumnName];
                            //string dfdfd = row[colums.ColumnName].ToString();
                            c.InnerText = WriteStr(colums.DataType.ToString(), row[colums.ColumnName]);
                        }
                        else
                        {
                            c.InnerText = "System.DBNull.Value";
                        }
                        //c.InnerText = row[colums.ColumnName].ToString();
                        table.AppendChild(c);
                    }
                }
            }

        }
        else
        {
            nodeparams2.RemoveAll();
            foreach (DataTable dt in ds.Tables)
            {
                XmlElement name_dt = doc.CreateElement("Tables");
                name_dt.SetAttribute("TableName", dt.TableName);

                nodeparams2.AppendChild(name_dt);
                XmlNode nodeparams_dt = DS.SelectSingleNode(Key);//子节点

                //创建列 <DataColumn>
                XmlElement DataColumn = doc.CreateElement("DataColumn");
                name_dt.AppendChild(DataColumn);


                foreach (DataColumn colums in dt.Columns)
                {
                    if (string.IsNullOrEmpty(colums.ColumnName))
                    { throw new Exception("ColumnName不能为空"); }
                    if (IsNum(colums.ColumnName))
                    { throw new Exception("ColumnName不能以数字开头"); }
                    XmlElement ColumnName = doc.CreateElement(colums.ColumnName);
                    if (colums.Unique)
                    { ColumnName.SetAttribute("Unique", colums.Unique.ToString()); }
                    if (colums.AutoIncrement)
                    {
                        ColumnName.SetAttribute("AutoIncrement", colums.AutoIncrement.ToString());
                        if (colums.AutoIncrementStep > 0)
                        { ColumnName.SetAttribute("AutoIncrementStep", colums.AutoIncrementStep.ToString()); }
                        if (colums.AutoIncrementSeed > 0)
                        { ColumnName.SetAttribute("AutoIncrementSeed", colums.AutoIncrementSeed.ToString()); }
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(colums.DefaultValue.ToString()))
                        { ColumnName.SetAttribute("DefaultValue", colums.DefaultValue.ToString()); }
                    }
                    ColumnName.SetAttribute("DataType", colums.DataType.ToString());
                    ColumnName.SetAttribute("Caption", colums.Caption.ToString());
                    ColumnName.InnerText = colums.ColumnName;
                    DataColumn.AppendChild(ColumnName);
                }
                foreach (DataRow row in dt.Rows)
                {
                    if (row.RowState == DataRowState.Deleted)
                    { continue; }
                    XmlElement table = doc.CreateElement("table");
                    name_dt.AppendChild(table);
                    foreach (DataColumn colums in dt.Columns)
                    {
                        if (string.IsNullOrEmpty(colums.ColumnName))
                        { throw new Exception("ColumnName不能为空"); }
                        if (IsNum(colums.ColumnName))
                        { throw new Exception("ColumnName不能以数字开头"); }
                        XmlElement c = doc.CreateElement(colums.ColumnName);
                        if (!string.IsNullOrEmpty(row[colums.ColumnName].ToString()))
                        {
                            c.InnerText = WriteStr(colums.DataType.ToString(), row[colums.ColumnName]).NullToString();
                        }
                        else
                        {
                            c.InnerText = "System.DBNull.Value";
                        }
                        table.AppendChild(c);
                    }
                }
            }

        }
        doc.Save(FilePath);
        return true;

    }
    /// <summary>
    /// 读取DataSet
    /// </summary>
    /// <param name="Key">DataSet名称</param>
    /// <param name="FilePath">文件路径</param>
    /// <param name="AInc">是否忽略列的AutoIncrement属性，true如果保存表有自增行，就重新获取自增的序号；false按保存的原始数据输出</param>
    /// <returns></returns>
    public static DataSet GetDataSet(string Key, string FilePath, bool AInc = true)
    {
        try
        {
            XmlDocument doc = Get_RootDoc(FilePath);
            //4、给文档添加根节点
            XmlElement config = doc.DocumentElement;
            XmlElement DT = config["DataSet"];
            XmlNode nodeparams2 = DT.SelectSingleNode(Key);//子节点
            if (nodeparams2 == null)
            { return null; }



            DataSet ds = new DataSet();
            XmlNodeList Tablelist = nodeparams2.ChildNodes;


            DataColumn newColumn;
            if (nodeparams2 == null)
            {
                return null;
            }
            if (Tablelist.Count == 0)
            {
                return null;
            }
            foreach (XmlNode tableitem in Tablelist)
            {
                Dictionary<string, XmlNode> dc = new Dictionary<string, XmlNode>();
                DataTable dt = new DataTable();
                dt.TableName = tableitem.Attributes["TableName"].Value;
                // tableitem.ChildNodes.Item
                XmlNodeList DataColumnlist = tableitem["DataColumn"].ChildNodes;//子节点//tableitem.ChildNodes;
                foreach (XmlNode item in DataColumnlist)
                {

                    newColumn = new DataColumn();
                    newColumn.ColumnName = item.InnerText;
                    if (!dc.ContainsKey(item.Name))
                    { dc.Add(item.Name, item); }
                    bool AutoIncrement = false;
                    #region 列读取
                    if (item.Attributes.GetNamedItem("DataType") != null)
                    {
                        if (!string.IsNullOrEmpty(item.Attributes.GetNamedItem("DataType").Value.ToString()))
                        { newColumn.DataType = System.Type.GetType(item.Attributes.GetNamedItem("DataType").Value.ToString()); }
                    }
                    if (item.Attributes.GetNamedItem("Caption") != null)
                    {
                        if (!string.IsNullOrEmpty(item.Attributes.GetNamedItem("Caption").Value.ToString()))
                        { newColumn.Caption = item.Attributes.GetNamedItem("Caption").Value.ToString(); }
                    }
                    if (item.Attributes.GetNamedItem("Unique") != null)
                    {
                        newColumn.Unique = GetStrigToBool(item.Attributes.GetNamedItem("Unique").Value.ToString());
                    }
                    if (item.Attributes.GetNamedItem("AutoIncrement") != null && AInc)
                    {
                        AutoIncrement = GetStrigToBool(item.Attributes.GetNamedItem("AutoIncrement").Value.ToString());
                        newColumn.AutoIncrement = AutoIncrement;
                    }
                    if (AutoIncrement && AInc)
                    {
                        if (item.Attributes.GetNamedItem("AutoIncrementStep") != null)
                        {
                            if (StringToLong(item.Attributes.GetNamedItem("AutoIncrementStep").Value.ToString()) > 0)
                            {
                                newColumn.AutoIncrementStep = StringToLong(item.Attributes.GetNamedItem("AutoIncrementStep").Value.ToString());
                            }
                            if (StringToLong(item.Attributes.GetNamedItem("AutoIncrementSeed").Value.ToString()) > 0)
                            {
                                newColumn.AutoIncrementSeed = StringToLong(item.Attributes.GetNamedItem("AutoIncrementSeed").Value.ToString());
                            }
                        }
                    }
                    else
                    {
                        if (item.Attributes.GetNamedItem("DefaultValue") != null)
                        {
                            if (!string.IsNullOrEmpty(item.Attributes.GetNamedItem("DefaultValue").Value.ToString()))
                            { newColumn.DefaultValue = item.Attributes.GetNamedItem("DefaultValue").Value.ToString(); }
                        }
                    }
                    if (AInc == false)
                    {
                        if (item.Attributes.GetNamedItem("DefaultValue") != null)
                        {
                            if (!string.IsNullOrEmpty(item.Attributes.GetNamedItem("DefaultValue").Value.ToString()))
                            { newColumn.DefaultValue = item.Attributes.GetNamedItem("DefaultValue").Value.ToString(); }
                        }
                    }
                    if (!dt.Columns.Contains(newColumn.ColumnName))
                    { dt.Columns.Add(newColumn); }
                    #endregion
                }

                XmlNodeList nodelist = tableitem.SelectNodes("table");//子节点
                if (nodelist == null)
                {
                    return null;
                }
                if (nodelist.Count == 0)
                {
                    return null;
                }
                foreach (XmlNode item in nodelist)
                {
                    XmlNodeList table = item.ChildNodes;
                    DataRow row = dt.NewRow();
                    foreach (XmlNode nl in table)
                    {
                        string value = nl.InnerText.Trim();
                        XmlNode xn = dc[nl.Name];
                        if (xn != null)
                        {
                            bool AutoIncrement = false, ReadOnly = false; ;
                            string DataType = "System.String";
                            if (xn.Attributes.GetNamedItem("AutoIncrement") != null && AInc)
                            {
                                AutoIncrement = GetStrigToBool(xn.Attributes.GetNamedItem("AutoIncrement").Value.ToString());
                            }

                            if (xn.Attributes.GetNamedItem("ReadOnly") != null)
                            {
                                ReadOnly = GetStrigToBool(xn.Attributes.GetNamedItem("ReadOnly").Value.ToString());
                            }
                            if (xn.Attributes.GetNamedItem("DataType") != null)
                            {
                                DataType = xn.Attributes.GetNamedItem("DataType").Value.ToString();
                            }
                            if (!AutoIncrement && ReadOnly == false && !string.IsNullOrEmpty(value))
                            {
                                if (value == "System.DBNull.Value")
                                { row[nl.Name] = System.DBNull.Value; }
                                else
                                {
                                    //if (DataType != "System.Byte[]")
                                    //{ row[nl.Name] = GetValuesText(DataType, nl.InnerText); }
                                    //if (DataType == "System.Byte[]")
                                    //{
                                    //    row[nl.Name]= Convert.FromBase64String(nl.InnerText);
                                    //}
                                    row[nl.Name] = ReadStr(DataType, nl.InnerText);
                                }

                            }
                        }
                        else
                        {
                            if (value == "System.DBNull.Value")
                            { row[nl.Name] = System.DBNull.Value; }
                            else
                            { row[nl.Name] = value; }
                        }
                    }

                    dt.Rows.Add(row);
                }
                ds.Tables.Add(dt.Copy());
            }

            return ds;
        }
        catch (Exception ex)
        {

            throw ex;
        }

    }
    /// <summary>
    /// 设置DataTable
    /// </summary>
    /// <param name="Key">Key</param>
    /// <param name="dt">DataTable</param>
    /// <param name="FilePath">XML文件路径</param>
    /// <returns></returns>
    public static bool SetTable(string Key, DataTable dt, string FilePath)
    {
        try
        {
            if (string.IsNullOrEmpty(Key))
            { throw new Exception("Key不能为空"); }
          
            if (IsNum(Key))
            { throw new Exception("Key不能以数字开头"); }
            if (IsSpecialChar(Key))
            { throw new Exception("Key不允许包含特殊字符"); }
            XmlDocument doc = Get_RootDoc(FilePath);
            //4、给文档添加根节点
            XmlElement config = doc.DocumentElement;
            XmlElement DT = config["DataTable"];
            XmlNode nodeparams2 = DT.SelectSingleNode(Key);//子节点
            if (nodeparams2 == null)
            {
                XmlElement name = doc.CreateElement(Key);
                DT.AppendChild(name);
                //创建列 <DataColumn>
                XmlElement DataColumn = doc.CreateElement("DataColumn");
                name.AppendChild(DataColumn);
                foreach (DataColumn colums in dt.Columns)
                {
                    if (string.IsNullOrEmpty(colums.ColumnName))
                    { throw new Exception("ColumnName不能为空"); }
                    if (IsNum(colums.ColumnName))
                    { throw new Exception("ColumnName不能以数字开头"); }
                    XmlElement ColumnName = doc.CreateElement(colums.ColumnName);
                    if (colums.Unique)
                    { ColumnName.SetAttribute("Unique", colums.Unique.ToString()); }
                    if (colums.AutoIncrement)
                    {
                        ColumnName.SetAttribute("AutoIncrement", colums.AutoIncrement.ToString());
                        if (colums.AutoIncrementStep > 0)
                        { ColumnName.SetAttribute("AutoIncrementStep", colums.AutoIncrementStep.ToString()); }
                        if (colums.AutoIncrementSeed > 0)
                        { ColumnName.SetAttribute("AutoIncrementSeed", colums.AutoIncrementSeed.ToString()); }
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(colums.DefaultValue.ToString()))
                        { ColumnName.SetAttribute("DefaultValue", colums.DefaultValue.ToString()); }
                    }
                    if (colums.ReadOnly)
                    { ColumnName.SetAttribute("ReadOnly", colums.ReadOnly.ToString()); }
                    ColumnName.SetAttribute("DataType", colums.DataType.ToString());
                    ColumnName.SetAttribute("Caption", colums.Caption.ToString());
                    ColumnName.InnerText = colums.ColumnName;
                    DataColumn.AppendChild(ColumnName);
                }

                foreach (DataRow row in dt.Rows)
                {
                    if (row.RowState == DataRowState.Deleted)
                    { continue; }
                    XmlElement table = doc.CreateElement("table");
                    name.AppendChild(table);
                    foreach (DataColumn colums in dt.Columns)
                    {
                        if (string.IsNullOrEmpty(colums.ColumnName))
                        { throw new Exception("ColumnName不能为空"); }
                        if (IsNum(colums.ColumnName))
                        { throw new Exception("ColumnName不能以数字开头"); }
                        XmlElement c = doc.CreateElement(colums.ColumnName);
                        if (!string.IsNullOrEmpty(row[colums.ColumnName].ToString()))
                        { c.InnerText = WriteStr(colums.DataType.ToString(), row[colums.ColumnName]); }
                        else
                        {
                            c.InnerText = "System.DBNull.Value";
                        }

                        table.AppendChild(c);
                    }
                }
            }
            else
            {
                nodeparams2.RemoveAll();
                XmlElement DataColumn = doc.CreateElement("DataColumn");
                nodeparams2.AppendChild(DataColumn);
                foreach (DataColumn colums in dt.Columns)
                {
                    if (string.IsNullOrEmpty(colums.ColumnName))
                    { throw new Exception("ColumnName不能为空"); }
                    if (IsNum(colums.ColumnName))
                    { throw new Exception("ColumnName不能以数字开头"); }
                    XmlElement ColumnName = doc.CreateElement(colums.ColumnName);
                    if (colums.Unique)
                    { ColumnName.SetAttribute("Unique", colums.Unique.ToString()); }
                    if (colums.AutoIncrement)
                    {
                        ColumnName.SetAttribute("AutoIncrement", colums.AutoIncrement.ToString());
                        if (colums.AutoIncrementStep > 0)
                        { ColumnName.SetAttribute("AutoIncrementStep", colums.AutoIncrementStep.ToString()); }
                        if (colums.AutoIncrementSeed > 0)
                        { ColumnName.SetAttribute("AutoIncrementSeed", colums.AutoIncrementSeed.ToString()); }
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(colums.DefaultValue.ToString()))
                        { ColumnName.SetAttribute("DefaultValue", colums.DefaultValue.ToString()); }
                    }
                    ColumnName.SetAttribute("DataType", colums.DataType.ToString());
                    ColumnName.SetAttribute("Caption", colums.Caption.ToString());
                    ColumnName.InnerText = colums.ColumnName;
                    DataColumn.AppendChild(ColumnName);
                }
                foreach (DataRow row in dt.Rows)
                {
                    if (row.RowState == DataRowState.Deleted)
                    { continue; }
                    XmlElement table = doc.CreateElement("table");
                    nodeparams2.AppendChild(table);
                    foreach (DataColumn colums in dt.Columns)
                    {
                        if (IsNum(colums.ColumnName))
                        { throw new Exception("ColumnName不能以数字开头"); }
                        XmlElement c = doc.CreateElement(colums.ColumnName);
                        if (!string.IsNullOrEmpty(row[colums.ColumnName].ToString()))
                        { c.InnerText = WriteStr(colums.DataType.ToString(), row[colums.ColumnName]); }
                        else
                        {
                            c.InnerText = "System.DBNull.Value";
                        }
                        table.AppendChild(c);
                    }
                }
            }
            doc.Save(FilePath);
            return true;
        }
        catch (Exception ex)
        {

            throw ex;
        }

    }
    /// <summary>
    /// 读取DataTable
    /// </summary>
    /// <param name="Key">Key</param>
    /// <param name="FilePath">XML文件路径</param>
    /// <param name="AInc">是否忽略列的AutoIncrement属性，true如果保存表有自增行，就重新获取自增的序号；false按保存的原始数据输出</param>
    /// <returns>DataTable</returns>
    public static DataTable GetDataTable(string Key, string FilePath, bool AInc = true)
    {
        try
        {
            XmlDocument doc = Get_RootDoc(FilePath);
            //4、给文档添加根节点
            XmlElement config = doc.DocumentElement;
            XmlElement DT = config["DataTable"];
            XmlNode nodeparams2 = DT.SelectSingleNode(Key);//子节点
            if (nodeparams2 == null)
            { return null; }
            XmlNode xDc = nodeparams2.SelectSingleNode("DataColumn");//子节点
            if (xDc == null)
            { return null; }
            DataTable dt = new DataTable();
            XmlNodeList DataColumnlist = nodeparams2["DataColumn"].ChildNodes; //xDc.ChildNodes;
            Dictionary<string, XmlNode> dc = new Dictionary<string, XmlNode>();
            DataColumn newColumn;
            if (nodeparams2 == null)
            {
                return null;
            }
            if (DataColumnlist.Count == 0)
            {
                return null;
            }
            foreach (XmlNode item in DataColumnlist)
            {
                newColumn = new DataColumn();
                newColumn.ColumnName = item.InnerText;
                if (!dc.ContainsKey(item.InnerText))
                { dc.Add(item.InnerText, item); }
                bool AutoIncrement = false;
                if (item.Attributes.GetNamedItem("DataType") != null)
                {
                    if (!string.IsNullOrEmpty(item.Attributes.GetNamedItem("DataType").Value.ToString()))
                    { newColumn.DataType = System.Type.GetType(item.Attributes.GetNamedItem("DataType").Value.ToString()); }
                }
                if (item.Attributes.GetNamedItem("Caption") != null)
                {
                    if (!string.IsNullOrEmpty(item.Attributes.GetNamedItem("Caption").Value.ToString()))
                    { newColumn.Caption = item.Attributes.GetNamedItem("Caption").Value.ToString(); }
                }
                if (item.Attributes.GetNamedItem("Unique") != null)
                {
                    newColumn.Unique = GetStrigToBool(item.Attributes.GetNamedItem("Unique").Value.ToString());
                }
                if (item.Attributes.GetNamedItem("AutoIncrement") != null && AInc)
                {
                    AutoIncrement = GetStrigToBool(item.Attributes.GetNamedItem("AutoIncrement").Value.ToString());
                    newColumn.AutoIncrement = AutoIncrement;
                }
                if (AutoIncrement && AInc)
                {
                    if (item.Attributes.GetNamedItem("AutoIncrementStep") != null)
                    {
                        if (StringToLong(item.Attributes.GetNamedItem("AutoIncrementStep").Value.ToString()) > 0)
                        {
                            newColumn.AutoIncrementStep = StringToLong(item.Attributes.GetNamedItem("AutoIncrementStep").Value.ToString());
                        }
                        if (StringToLong(item.Attributes.GetNamedItem("AutoIncrementSeed").Value.ToString()) > 0)
                        {
                            newColumn.AutoIncrementSeed = StringToLong(item.Attributes.GetNamedItem("AutoIncrementSeed").Value.ToString());
                        }
                    }
                }
                else
                {
                    if (item.Attributes.GetNamedItem("DefaultValue") != null)
                    {
                        if (!string.IsNullOrEmpty(item.Attributes.GetNamedItem("DefaultValue").Value.ToString()))
                        { newColumn.DefaultValue = item.Attributes.GetNamedItem("DefaultValue").Value.ToString(); }
                    }
                }
                if (AInc == false)
                {
                    if (item.Attributes.GetNamedItem("DefaultValue") != null)
                    {
                        if (!string.IsNullOrEmpty(item.Attributes.GetNamedItem("DefaultValue").Value.ToString()))
                        { newColumn.DefaultValue = item.Attributes.GetNamedItem("DefaultValue").Value.ToString(); }
                    }
                }
                if (!dt.Columns.Contains(newColumn.ColumnName))
                { dt.Columns.Add(newColumn); }
            }

            XmlNodeList nodelist = nodeparams2.SelectNodes("table");//子节点
            if (nodelist == null)
            {
                return null;
            }
            if (nodelist.Count == 0)
            {
                return null;
            }
            foreach (XmlNode item in nodelist)
            {
                XmlNodeList table = item.ChildNodes;
                DataRow row = dt.NewRow();
                foreach (XmlNode nl in table)
                {
                    string value = nl.InnerText.Trim();
                    XmlNode xn = dc[nl.Name];
                    if (xn != null)
                    {
                        bool AutoIncrement = false, ReadOnly = false;
                        string DataType = "System.String";
                        if (xn.Attributes.GetNamedItem("AutoIncrement") != null && AInc)
                        {
                            AutoIncrement = GetStrigToBool(xn.Attributes.GetNamedItem("AutoIncrement").Value.ToString());
                        }

                        if (xn.Attributes.GetNamedItem("ReadOnly") != null)
                        {
                            ReadOnly = GetStrigToBool(xn.Attributes.GetNamedItem("ReadOnly").Value.ToString());
                        }
                        if (xn.Attributes.GetNamedItem("DataType") != null)
                        {
                            DataType = xn.Attributes.GetNamedItem("DataType").Value.ToString();
                        }
                        if (!AutoIncrement && ReadOnly == false && !string.IsNullOrEmpty(value))
                        {
                            if (value == "System.DBNull.Value")
                            { row[nl.Name] = System.DBNull.Value; }
                            else
                            {
                                //if (DataType != "System.Byte[]")
                                //{ row[nl.Name] = GetValuesText(DataType, nl.InnerText); }
                                //if (DataType == "System.Byte[]")
                                //{
                                //    row[nl.Name] = Convert.FromBase64String(nl.InnerText);
                                //}
                                row[nl.Name] = ReadStr(DataType, nl.InnerText);
                            }

                        }
                    }
                    else
                    {
                        if (value == "System.DBNull.Value")
                        { row[nl.Name] = System.DBNull.Value; }
                        else
                        {
                            row[nl.Name] = value;
                        }
                    }
                }

                dt.Rows.Add(row);
            }

            return dt;
        }
        catch (Exception ex)
        {

            throw ex;
        }
    }
    #region 辅助方法
    /// <summary>
    /// 获取XmlDocument
    /// </summary>
    /// <param name="FilePath">文件路径</param>
    /// <returns></returns>
    private static XmlDocument Get_RootDoc(string FilePath)
    {
        try
        {
            if (!System.IO.File.Exists(FilePath))
            {
                CreateXMLFile(FilePath);
            }
            XmlDocument doc = new XmlDocument();//创建XmlDocument对象                                  
            doc.Load(FilePath);
            return doc;
        }
        catch
        {
            return null;
        }

    }
    #region 创建文件
    /// <summary>
    /// 创建文件
    /// </summary>
    /// <param name="FilePath">XLM文件路径</param>
    /// <returns></returns>
    private static bool CreateXMLFile(string FilePath)
    {
        try
        {


            if (!System.IO.File.Exists(FilePath))
            {
                //1、创建一个XML文档
                XmlDocument doc = new XmlDocument();//创建XmlDocument对象                                  
                                                    //2、创建第一行描述信息
                XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "utf-8", null);
                //3、将创建的第一行描述信息添加到文档中
                doc.AppendChild(dec);
                //4、给文档添加根节点
                XmlElement config = doc.CreateElement("ConfigRoot");
                doc.AppendChild(config);
                XmlElement Set = doc.CreateElement("Set");
                config.AppendChild(Set);
                XmlElement Dir = doc.CreateElement("Dic");
                config.AppendChild(Dir);
                XmlElement Table = doc.CreateElement("DataTable");
                config.AppendChild(Table);
                XmlElement Sec = doc.CreateElement("Section");
                config.AppendChild(Sec);
                XmlElement DataSet = doc.CreateElement("DataSet");
                config.AppendChild(DataSet);
                doc.Save(FilePath);
            }
            return true;
        }
        catch (Exception ex)
        {

            throw ex;
        }

    }
    #endregion
    #region 值转换
    #region 数据表值转为XML中保存的值
    public static string WriteStr(string type, object Values)
    {
        string reval = string.Empty;

        switch (type)
        {

            case "System.Int16":
                reval = GetStrigToInt(Values.ToString());
                break;
            case "System.Int32":
                reval = GetStrigToInt(Values.ToString());
                break;
            case "System.Int64":
                reval = GetStrigToInt(Values.ToString());
                break;
            case "System.String":
                if (!string.IsNullOrEmpty(Values.ToString()))
                { reval = Values.ToString(); }
                else
                { reval = ""; }
                break;
            case "System.Decimal":
                reval = GetStringTodecimal(Values.ToString());
                break;
            case "System.Char":
                reval = Values.ToString();
                break;
            case "System.Double":
                reval = GetStringToDouble(Values.ToString());
                break;
            case "System.DateTime":
                string v_Values = DateTimeToString(Values);
                if (v_Values != "")
                { reval = v_Values; }
                else
                { reval = ""; }

                break;
            case "System.Boolean":
                reval = GetStrigToBool(Values.ToString()).ToString();
                break;
            //
            case "System.Byte[]":
                reval = ByteToString(Values);
                break;
            default:
                if (!string.IsNullOrEmpty(Values.ToString()))
                { reval = Values.ToString(); }
                else
                { reval = ""; }
                break;
        }
        return reval;
    }
    private static object ReadStr(string type, object Values)
    {
        object reval = string.Empty;

        switch (type)
        {

            case "System.Int16":
                reval = GetStrigToInt(Values.ToString()).ToString();
                break;
            case "System.Int32":
                reval = GetStrigToInt(Values.ToString()).ToString();
                break;
            case "System.Int64":
                reval = GetStrigToInt(Values.ToString()).ToString();
                break;
            case "System.String":
                if (!string.IsNullOrEmpty(Values.ToString()))
                { reval = Values.ToString(); }
                else
                { reval = ""; }
                break;
            case "System.Decimal":
                reval = GetStringTodecimal(Values.ToString()).ToString();
                break;
            case "System.Char":
                reval = Values.ToString();
                break;
            case "System.Double":
                reval = GetStringToDouble(Values.ToString());
                break;
            case "System.DateTime":
             
                if (Values != null)
                { reval = StringToDateTime(Values.ToString()); }
                else
                { reval = ""; }

                break;
            case "System.Boolean":
                reval = GetStrigToBool(Values.ToString()).ToString();
                break;
            //
            case "System.Byte[]":
                reval = StringToByte(Values);
                break;
            default:
                if (!string.IsNullOrEmpty(Values.ToString()))
                { reval = Values.ToString(); }
                else
                { reval = ""; }
                break;
        }
        return reval;

    }
    private static string GetStrigToInt(string Values)
    {
        try
        {
            int i = 0;
            if (int.TryParse(Values, out i))
            { return i.ToString(); }
            else
            { return "0"; }
        }
        catch { return "0"; }
    }
    private static bool GetStrigToBool(string values)
    {
        if (values == "0")
        { values = "False"; }
        if (values == "1")
        { values = "True"; }
        if (values == "是")
        { values = "True"; }
        if (values == "否")
        { values = "False"; }
        if (values.ToLower() == "yes")
        { values = "True"; }
        if (values.ToLower() == "no")
        { values = "False"; }
        if (values.ToLower() == "y")
        { values = "True"; }
        if (values.ToLower() == "n")
        { values = "False"; }
        bool i = false;
        if (bool.TryParse(values, out i))
        {
            return i;
        }
        else
        { return false; }
    }
    private static string ByteToString(object values)
    {
        if (values != null)
        {
           
                byte[] bytes = (byte[])values;
                return Convert.ToBase64String(bytes);    //strTextTostrBin(bytes);
          
           
        }
        else
        { return string.Empty; }
    }
    private static object StringToByte(object values)
    {
        if (values != null)
        {
           return Convert.FromBase64String(values.NullToString());//strBinTostrText(values.NullToString());
           

        }
        else
        { return string.Empty; }
    }
    private static string GetStringTodecimal(string Values)
    {
        decimal d = 0;
        try
        {
            if (decimal.TryParse(Values, out d))
            {
                return d.ToString();
            }
            else { return "0"; }
        }
        catch { return "0"; }
    }
    private static string GetStringToDouble(string Values)
    {
        double d = 0;
        try
        {
            if (double.TryParse(Values, out d))
            {
                return d.ToString();
            }
            else { return "0"; }
        }
        catch { return "0"; }
    }
    private static string GetStringToFloat(string Values)
    {
        float d = 0;
        try
        {
            if (float.TryParse(Values, out d))
            {
                return d.ToString();
            }
            else { return "0"; }
        }
        catch { return "0"; }
    }
    /// <summary>
    /// DateTime毫秒问题
    /// </summary>
    /// <param name="Values"></param>
    /// <returns></returns>
    private static string DateTimeToString(object Values)
    {
        try
        {
            DateTime d = DateTime.Now;
            if (DateTime.TryParse(Values.ToString(), out d))
            {
                DateTime CreatDate = (DateTime)(Values);
                return CreatDate.ToString("yyyy-MM-dd HH:mm:ss.fff");
            }
            else { return "0001-01-01"; }
        }
        catch 
        {
            return "0001-01-01";
        }
    }
    public static DateTime StringToDateTime(string Values)
    {
        try
        {
            string Str = Values.ToString();
            if (Str.IndexOf('.') < 0)
            {
                DateTime d = DateTime.Now;
                if (DateTime.TryParse(Values.ToString(), out d))
                {
                    return d;
                }
                else { return DateTime.Parse("0001-01-01"); }
            }
            else
            {
                string Start_Str = Str.Remove(Str.IndexOf("."));
                string End_Str = Str.Substring(Str.LastIndexOf(".") + 1);
                double md = 0, md2 = 0;
                if (double.TryParse(End_Str, out md))
                { md2 = md; }
                DateTime d = DateTime.Now;
                if (DateTime.TryParse(Start_Str, out d))
                {
                    if (md2 > 0)
                    {
                        d = d.AddMilliseconds(md2);
                       // DateTime CreatDate = (DateTime)(d);
                        return d;
                    }
                    else
                    { return d; }
                }
                else
                { return DateTime.Parse("0001-01-01"); }


            }
        }
        catch { return DateTime.Parse( "0001-01-01"); }
    }
    #endregion
    #region String值转为DataTable的原始值
    private static long StringToLong(string Values)
    {
        long d = 0;
        try
        {
            if (long.TryParse(Values, out d))
            {
                return d;
            }
            else { return 0; }
        }
        catch { return 0; }
    }
    #endregion
    #endregion
    /// <summary>
    /// 判断字符串是否以数字开头
    /// </summary>
    /// <param name="value">字符串</param>
    /// <returns>bool</returns>
  
    private static bool IsNum(string value)
    {
        System.Text.RegularExpressions.Regex regNum = new System.Text.RegularExpressions.Regex("^[0-9]");
        return regNum.IsMatch(value);
    }
    /// <summary>
    /// 只允许包含数字、字母、汉字下划线
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    private static bool IsSpecialChar(string str)
    {
        System.Text.RegularExpressions.Regex regExp = new System.Text.RegularExpressions.Regex("[^0-9a-zA-Z-_.+$\u4e00-\u9fa5]");
        return regExp.IsMatch(str);
    }

    #endregion
}

}