DBHelper

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
using System.Collections;
using System.Xml;

namespace clsLibrarySQLHelper
{
    public class SQLHelper_Erp
    {
        //public static string sConnStr = ConfigurationManager.ConnectionStrings["ConnStr"].ToString();
        public static string sConnStr = ConfigurationManager.AppSettings["ConnStr"];

        //    private static SqlConnection conn;
        /// <summary>
        /// 静态类
        /// </summary>
        static SQLHelper_Erp()
        {
        }

        /// <summary>
        /// Connection
        /// </summary>
        /// <returns></returns>
        //        public static SqlConnection GetConn()
        //        {
        //            return conn ;
        //        }

        /// <summary>
        /// 执行Sql语句
        /// </summary>
        /// <param name="sSql"></param>
        /// <returns></returns>
        public static bool ExecuteSQl(string sSql, params int[] TimeOut)
        {
            sSql = XmlHelper.RefreshLanguageID(sSql);
            SqlConnection conn = new SqlConnection(sConnStr);
            SqlCommand cmd = new SqlCommand();

            if (TimeOut.Length > 0)
            {
                int t = TimeOut[0];
                cmd.CommandTimeout = t;
            }

            try
            {
                conn.Open();
                cmd.Connection = conn;
                cmd.CommandText = sSql;
                cmd.ExecuteNonQuery();
                return true;
            }
            catch (SqlException ex)
            {
                XmlHelper.WriteFileLog("SQl代码错误：" + sSql + "\r\n" + ex.StackTrace + " \r\n " + ex.Message, "SQl错误", "ExecuteSQl");
                throw ex;
                //return false;
            }
            catch (Exception ex)
            {
                XmlHelper.WriteFileLog("SQl代码错误：" + sSql + "\r\n" + ex.Message, "SQl错误", "ExecuteSQl");
                throw ex;
            }
            finally
            {
                cmd.Dispose();
                conn.Close();
            }
        }

        /// <summary>
        /// 执行Sql语句，并返回影响的记录的行
        /// </summary>
        /// <param name="sSql"></param>
        /// <returns></returns>
        public static int GetCount(string sSql)
        {
            sSql = XmlHelper.RefreshLanguageID(sSql);
            SqlConnection conn = new SqlConnection(sConnStr);
            SqlCommand cmd = new SqlCommand(sSql, conn);

            try
            {
                conn.Open();
                //cmd.Connection =conn;
                //cmd.CommandText=sSql;
                return cmd.ExecuteNonQuery();

            }
            catch (SqlException ex)
            {
                XmlHelper.WriteFileLog("SQl代码错误：" + sSql + "\r\n" + ex.Message, "SQl错误", "getCount");
                throw ex;
            }
            finally
            {
                cmd.Dispose();
                conn.Close();
            }
        }

        /// <summary>
        /// 返回数据表
        /// </summary>
        /// <param name="sSql">SQL语句</param>
        /// <param name="sTableName">SQL语句</param>
        /// <returns></returns>
        public DataTable GetDataTable(string sSql, string sTableName)
        {
            sSql = XmlHelper.RefreshLanguageID(sSql);
            SqlConnection conn = new SqlConnection(sConnStr);
            DataSet ds = new DataSet();
            SqlDataAdapter da = new SqlDataAdapter(sSql, conn);
            try
            {
                conn.Open();
                da.Fill(ds);
                return ds.Tables[sTableName.Trim()];
            }
            catch (Exception ex)
            {
                XmlHelper.WriteFileLog("SQl代码错误：" + sSql + "\r\n" + ex.Message, "SQl错误", "GetDataTable");
                throw ex;
            }
            finally
            {
                da.Dispose();
                conn.Close();
            }

            //return null;
        }

        /// <summary>
        /// 向数据集添加表
        /// </summary>
        /// <param name="sSql">SQL语句</param>
        /// <param name="ds">要添加表的数据集</param>
        /// <param name="tableName">表名</param>
        public static void AddTableToDataSet(string sSql, DataSet ds, string tableName)
        {
            sSql = XmlHelper.RefreshLanguageID(sSql);
            SqlConnection conn = new SqlConnection(sConnStr);
            SqlDataAdapter da = new SqlDataAdapter(sSql, conn);
            try
            {
                conn.Open();
                da.Fill(ds, tableName);
            }
            catch (SqlException ex)
            {

                XmlHelper.WriteFileLog("SQl代码错误：" + sSql + "\r\n" + ex.Message, "SQl错误", "AddTableToDataSet");
                throw new Exception(ex.Message);
            }
            finally
            {
                da.Dispose();
                conn.Close();
            }
        }


        /// <summary>
        /// 返回数据集
        /// </summary>
        /// <param name="sSql">SQL语句</param>
        /// <returns></returns>
        public static DataSet GetDataSet(string sSql, params int[] TimeOut)
        {
            sSql = XmlHelper.RefreshLanguageID(sSql);
            SqlConnection conn = new SqlConnection(sConnStr);
            DataSet ds = new DataSet();
            SqlDataAdapter da = new SqlDataAdapter(sSql, conn);
            if (TimeOut.Length > 0)
            {
                int t = TimeOut[0];
                da.SelectCommand.CommandTimeout = t;
            }
            try
            {
                conn.Open();
                da.Fill(ds);
            }
            catch (SqlException ex)
            {

                XmlHelper.WriteFileLog("SQl代码错误：" + sSql + "\r\n" + ex.Message, "SQl错误", "GetDataSet");
                throw new Exception(ex.Message);
           
            }
            finally
            {
                da.Dispose();
                conn.Close();
            }
            return ds;
        }

        /// <summary>
        /// 返回数据集
        /// </summary>
        /// <param name="sSql">SQL语句</param>
        /// <param name="sTableName">想要的表名称</param>
        /// <returns></returns>
        public static DataSet GetDataSet(string sSql, string sTableName, params int[] TimeOut)
        {
            sSql = XmlHelper.RefreshLanguageID(sSql);
            SqlConnection conn = new SqlConnection(sConnStr);
            DataSet ds = new DataSet();
            SqlDataAdapter da = new SqlDataAdapter(sSql, conn);
            if (TimeOut.Length > 0)
            {
                int t = TimeOut[0];
                da.SelectCommand.CommandTimeout = t;
            }
            try
            {
                conn.Open();
                da.Fill(ds, sTableName);
            }
            catch (SqlException ex)
            {

                XmlHelper.WriteFileLog("SQl代码错误：" + sSql + "\r\n" + ex.Message, "SQl错误", "getdataset");
                throw new Exception(ex.Message);
            }
            finally
            {
                da.Dispose();
                conn.Close();
                conn.Dispose();
            }
            return ds;
        }

        /// <summary>
        /// 分页返回数据集
        /// </summary>
        /// <param name="sSql">ＳＱＬ语句</param>
        /// <param name="sTableName">要设定的表名</param>
        /// <param name="iPageNum">当前页码</param>        
        /// <param name="iPageCount">每页显示的条数</param>
        /// <returns></returns>
        public static DataSet GetDataSet(string sSql, string sTableName, int iPageNum, int iPageCount)
        {
            sSql = XmlHelper.RefreshLanguageID(sSql);
            SqlConnection conn = new SqlConnection(sConnStr);
            iPageNum -= 1;
            if (iPageNum <= 0) iPageNum = 0;
            if (iPageCount <= 0) iPageCount = 10; //默认为１０条

            DataSet ds = new DataSet();
            SqlDataAdapter da = new SqlDataAdapter(sSql, conn);
            try
            {
                conn.Open();
                da.Fill(ds, iPageNum * iPageCount, iPageCount, sTableName);
            }
            catch (SqlException ex)
            {

                XmlHelper.WriteFileLog("SQl代码错误：" + sSql + "\r\n" + ex.Message, "SQl错误", "getdataset");
                throw new Exception(ex.Message);
            }
            finally
            {
                da.Dispose();
                conn.Close();
            }
            return ds;
        }

        /// <summary>
        /// 返回数据
        /// </summary>
        /// <param name="sSql"></param>
        /// <returns></returns>
        //public static SqlDataReader dr_DataReader;
        public static SqlDataReader GetDataReader(string sSql, params int[] TimeOut)
        {
            sSql = XmlHelper.RefreshLanguageID(sSql);
            SqlConnection conn = new SqlConnection(sConnStr);
            SqlCommand cmd = new SqlCommand(sSql, conn);
            if (TimeOut.Length > 0)
            {
                int t = TimeOut[0];
                cmd.CommandTimeout = t;
            }
            SqlDataReader dr;
            try
            {
                conn.Open();
                dr = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
            }
            catch (Exception ex)
            {
                XmlHelper.WriteFileLog("SQl代码错误：" + sSql + "\r\n" + ex.Message, "SQl错误", "getdatareader");
                throw new Exception(ex.Message);
            }
            finally
            {

            }
            return dr;
        }

        /// <summary>
        /// 关闭连接
        /// </summary>
        /// <param name="sSql"></param>
        /// <returns></returns>
        public static void Colse_Conn()
        {
            //SqlConnection conn = new SqlConnection(sConnStr);
            //SqlDataReader dr;
            //if (dr != null)
            //{
            //    dr.Close();
            //}
            //conn.Close();
            //if (conn.State == ConnectionState.Open)
            //{
            //    conn.Close();
            //}
        }

        /// <summary>
        /// 返回一行一列的值
        /// </summary>
        /// <param name="sSql"></param>
        /// <returns></returns>
        public static string FetFirstCol(string sSql, params int[] TimeOut)
        {
            sSql = XmlHelper.RefreshLanguageID(sSql);
            SqlConnection conn = new SqlConnection(sConnStr);
            SqlCommand cmd = new SqlCommand(sSql, conn);
            if (TimeOut.Length > 0)
            {
                int t = TimeOut[0];
                cmd.CommandTimeout = t;
            }

            object obj;
            try
            {
                conn.Open();
                obj = cmd.ExecuteScalar();
                if (obj == null)
                {
                    return "";
                }
                else
                {
                    return obj.ToString();
                }
            }
            catch (Exception ex)
            {
                XmlHelper.WriteFileLog("SQl代码错误：" + sSql + "\r\n" + ex.Message, "SQl错误", "getfirstcol");
                throw new Exception(ex.Message);
            }
            finally
            {
                conn.Close();
            }

        }

        /// <summary>
        /// 事务处理
        /// </summary>
        /// <param name="sSql"></param>
        /// <returns></returns>
        public static int ExecuteTransaction(System.Collections.ArrayList sSql)
        {
            SqlConnection conn = new SqlConnection(sConnStr);
            System.Data.SqlClient.SqlTransaction Trans;
            SqlCommand cmd = new SqlCommand();
            conn.Open();
            Trans = conn.BeginTransaction();
            cmd.Transaction = Trans;
            int i = 0, iResult = 0;

            cmd.Connection = conn;
            try
            {
                for (i = 0; i < sSql.Count; i++)
                {
                    cmd.CommandText = sSql[i].ToString();
                    iResult = cmd.ExecuteNonQuery();
                }
                Trans.Commit();
            }
            catch (Exception ex)
            {
                XmlHelper.WriteFileLog("SQl代码错误：" + sSql + "\r\n" + ex.Message, "SQl错误", "ExecuteTransaction");
                Trans.Rollback();
                throw ex;
                //return false;
            }
            finally
            {
                conn.Close();
            }
            return iResult;
        }

        /// <summary>
        /// 返回存储过程返回值
        /// </summary>
        /// <param name="sSql"></param>
        /// <returns></returns>
        public static string ExecuteProcedure(string sSql)
        {
            #region ExecuteProcedure
            sSql = XmlHelper.RefreshLanguageID(sSql);
            SqlConnection conn = new SqlConnection(sConnStr);
            SqlCommand cmd = new SqlCommand(sSql, conn);
            object str;

            //cmd.Parameters[0] = new SqlParameter("@RETURN_VALUE", SqlDbType.Int);
            //cmd.Parameters[0].Direction = ParameterDirection.ReturnValue;   //添加获得返回值的参数       

            cmd.Parameters.Add("@RETURN_VALUE", "").Direction = ParameterDirection.ReturnValue;   //添加获得返回值的参数       

            try
            {


                conn.Open();
                cmd.ExecuteNonQuery();
                str = cmd.Parameters["@RETURN_VALUE"].Value; //获得返回值的地方
                if (str == null)
                {
                    return "";
                }
                else
                {
                    return str.ToString();
                }
            }
            catch (Exception ex)
            {

                XmlHelper.WriteFileLog("SQl代码错误：" + sSql + "\r\n" + ex.Message, "SQl错误", "ExecuteProcedure");

                throw new Exception(ex.Message);
            }
            finally
            {
                conn.Close();
            }

            #endregion
        }

        /// <summary>
        /// 返回存储过程输出值
        /// </summary>
        /// <param name="sSql"></param>
        /// <returns></returns>
        public static string ExecuteProcedureOut(string sSql, int iType, string iID)
        {
            #region ExecuteProcedure
            sSql = XmlHelper.RefreshLanguageID(sSql);
            SqlConnection conn = new SqlConnection(sConnStr);

            SqlCommand cmd = new SqlCommand();
            object str;

            cmd.Connection = conn;
            cmd.CommandText = sSql;

            cmd.Parameters.AddWithValue("@iType", iType);
            cmd.Parameters.AddWithValue("@iBillID", iID);
            cmd.Parameters.Add("@RETURN_VALUE", SqlDbType.NVarChar, 200).Direction = ParameterDirection.Output;
            cmd.CommandType = CommandType.StoredProcedure;

            try
            {
                conn.Open();
                cmd.ExecuteNonQuery();
                str = cmd.Parameters["@RETURN_VALUE"].Value; //获得返回值的地方
                if (str == null)
                {
                    return "";
                }
                else
                {
                    return str.ToString();
                }
            }
            catch (Exception ex)
            {

                XmlHelper.WriteFileLog("SQl代码错误：" + sSql + "\r\n" + ex.Message, "SQl错误", "ExecuteProcedureOut");

                throw new Exception(ex.Message);
            }
            finally
            {
                conn.Close();
            }

            #endregion
        }

        /// <summary>
        /// 执行过程返回一个数据集
        /// </summary>
        /// <param name="Procedure_name"></param>
        /// <param name="Table_name"></param>
        /// <param name="_Ht"></param>
        /// <returns></returns>
        public static DataSet GetDataSetByProcedure(string Procedure_name, string Table_name, Hashtable _Ht)
        {
            SqlConnection conn = new SqlConnection(sConnStr);

            SqlCommand cmd = new SqlCommand(Procedure_name, conn);
            cmd.CommandType = CommandType.StoredProcedure;

            AddInParaValues(conn, cmd, _Ht);

            DataSet ds = new DataSet();
            SqlDataAdapter da = new SqlDataAdapter();
            try
            {
                conn.Open();
                da.SelectCommand = cmd;
                da.Fill(ds, Table_name);
                conn.Close();
                return ds;
            }
            catch (SqlException ex)
            {
                XmlHelper.WriteFileLog("SQl代码错误：" + Procedure_name + "\r\n" + ex.Message, "SQl错误", "GetDataSetByProcedure");
                throw new Exception(ex.Message);
            }
            finally
            {
                da.Dispose();
                conn.Close();
            }
        }

        /// <summary>
        /// 为 SqlCommand 添加参数及赋值
        /// </summary>
        /// <param name="comm">SqlCommand</param>
        /// <param name="paraValues">参数数组(必须遵循存储过程参数列表的顺序)</param>
        public static void AddInParaValues(SqlConnection conn, SqlCommand comm, Hashtable htParametersValues)
        {
            comm.Parameters.Add(new SqlParameter("@RETURN_VALUE", SqlDbType.Int));
            comm.Parameters["@RETURN_VALUE"].Direction = ParameterDirection.ReturnValue;
            if (htParametersValues != null)
            {
                DataTable dt = GetParameters(conn, comm.CommandText);
                int i = 0;
                foreach (DataRow row in dt.Rows)
                {
                    string key = row[3].ToString();
                    if (key != "@RETURN_VALUE")
                    {
                        int value = int.Parse(row[4].ToString());
                        if (value == 1)
                        {
                            comm.Parameters.AddWithValue(key, htParametersValues[key]);
                        }
                        else if (value == 2)//value为2则是输出参数
                        {
                            comm.Parameters.AddWithValue(key, htParametersValues[key]).Direction = ParameterDirection.Output;
                            //comm.Parameters[key].Direction = ParameterDirection.Output;
                        }
                        i++;
                    }
                }
            }
        }

        /// <summary>
        /// 获取存储过程的参数列表
        /// </summary>
        /// <param name="proc_Name">存储过程名称</param>
        /// <returns>DataTable</returns>
        public static DataTable GetParameters(SqlConnection conn, string proc_Name)
        {
            SqlCommand comm = new SqlCommand("dbo.sp_sproc_columns", conn);
            comm.CommandType = CommandType.StoredProcedure;
            comm.Parameters.AddWithValue("@procedure_name", (object)proc_Name);
            SqlDataAdapter sda = new SqlDataAdapter(comm);
            DataTable dt = new DataTable();
            sda.Fill(dt);
            return dt;
        }

        #region 存储过程操作

        /// <summary>
        /// 执行存储过程，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader RunProcedure(string storedProcName, IDataParameter[] parameters)
        {
            SqlConnection conn = new SqlConnection(sConnStr);
            SqlDataReader returnReader;
            conn.Open();
            SqlCommand command = BuildQueryCommand(conn, storedProcName, parameters);
            command.CommandType = CommandType.StoredProcedure;
            returnReader = command.ExecuteReader(CommandBehavior.CloseConnection);
            return returnReader;
        }

        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <param name="tableName">DataSet结果中的表名</param>
        /// <returns>DataSet</returns>
        public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName)
        {
            using (SqlConnection connection = new SqlConnection(sConnStr))
            {
                DataSet dataSet = new DataSet();
                connection.Open();
                SqlDataAdapter sqlDA = new SqlDataAdapter();
                sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
                sqlDA.Fill(dataSet, tableName);
                connection.Close();
                return dataSet;
            }
        }

        /// <summary>
        /// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <returns>SqlCommand</returns>
        private static SqlCommand BuildQueryCommand(SqlConnection conn, string storedProcName, IDataParameter[] parameters)
        {
            SqlCommand cmd = new SqlCommand(storedProcName, conn);
            cmd.CommandType = CommandType.StoredProcedure;
            foreach (SqlParameter parameter in parameters)
            {
                if (parameter != null)
                {
                    // 检查未分配值的输出参数,将其分配以DBNull.Value.
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    cmd.Parameters.Add(parameter);
                }
            }

            return cmd;
        }

        /// <summary>
        /// 创建 SqlCommand 对象实例(用来返回一个整数值)    
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <returns>SqlCommand 对象实例</returns>
        private static SqlCommand BuildIntCommand(SqlConnection conn, string storedProcName, IDataParameter[] parameters)
        {
            SqlCommand cmd = BuildQueryCommand(conn, storedProcName, parameters);
            cmd.Parameters.Add(new SqlParameter("ReturnValue",
                SqlDbType.Int, 4, ParameterDirection.ReturnValue,
                false, 0, 0, string.Empty, DataRowVersion.Default, null));
            return cmd;
        }

        #endregion

        /// <summary>
        /// 分页参数
        /// </summary>
        /// <returns></returns>
        public static SqlParameter[] pagePara()
        {
            SqlParameter[] parameter = {
            new SqlParameter("@TableName",SqlDbType.VarChar,255),//表名，如tb_testtable
            new SqlParameter("@ReturnFields",SqlDbType.VarChar,1000),//字段名，如id,userName
            new SqlParameter("@Orderfld",SqlDbType.VarChar,255),//排序的字段名，如id
            new SqlParameter("@PageSize",SqlDbType.Int,4),//一页大小，如10
            new SqlParameter("@PageIndex",SqlDbType.Int,4),//当前页码
            new SqlParameter("@OrderType",SqlDbType.Int,4),//设置排序类型，非0则降序
            new SqlParameter("@Where",SqlDbType.VarChar,1500),//查询条件(注意不要加：where)
            new SqlParameter("@RecordCount",SqlDbType.Int,4)};
            return parameter;
        }
    }
}

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Web;
using System.IO;
using System.Windows.Forms;
namespace clsLibrarySQLHelper
{
    /// <summary>
    ///
    /// 用于 读取XML中的SQL语句用
    /// </summary>
    public class XmlHelper
    {


        /// <summary>
        /// 得到SQL语句可以指定参数
        /// </summary>
        /// <param name="FileName"></param>
        /// <param name="NameSpace"></param>
        /// <param name="ClassName"></param>
        /// <param name="FunctionName"></param>
        /// <param name="Remark"></param>
        /// <param name="SID"></param>
        /// <param name="table">参数列表</param>
        /// <returns></returns>
        public static string GetXmlStr(string FileName, string NameSpace, string ClassName, string FunctionName, string Remark, string SID, System.Collections.Hashtable table)
        {
            string sqlStr = GetXmlStr(FileName, NameSpace, ClassName, FunctionName, Remark, SID);

            System.Collections.IDictionaryEnumerator Idiction = table.GetEnumerator();
            while (Idiction.MoveNext())
            {
                if (Idiction.Key == null)
                    continue;
                string key = string.Empty, value = string.Empty;
                key = Idiction.Key.ToString();

                if (Idiction.Value != null)
                {
                    value = Idiction.Value.ToString();
                }
                else
                {
                    value = "NULL";
                }

                sqlStr = sqlStr.Replace(key, value);

            }
            return sqlStr;
        }


        /// <summary>
        /// 得到SQL语句
        /// </summary>
        /// <param name="FileName"></param>
        /// <param name="NameSpace"></param>
        /// <param name="ClassName"></param>
        /// <param name="FunctionName"></param>
        /// <param name="Remark"></param>
        /// <param name="SID"></param>
        /// <returns></returns>
        public static string GetXmlStr(string FileName, string NameSpace, string ClassName, string FunctionName, string Remark, string SID)
        {
            string sql = string.Empty;
            try
            {
                XmlDocument doc = new XmlDocument();
                string XmlPath = System.Configuration.ConfigurationManager.AppSettings["XmlPath"].Replace("\\", "//");
                doc.Load(XmlPath + "/" + FileName);

                sql = GetXmlNodeStr("/root/NameSpace/Class/Function[@SID='" + SID + "']", doc);
            }
            catch (Exception)
            {
                throw;
            }
            return sql;

        }

        public static string RefreshLanguageID(string sql)
        {
            if (sql.Contains("LanguageID"))
            {
                if (System.Web.HttpContext.Current.Request.Cookies["ERCookie"] == null)
                {
                    if (sql.IndexOf("#LanguageID") > 0)
                        sql = sql.Replace("#LanguageID", "1");
                    else
                        sql = sql.Replace("@LanguageID", "1");
                }
                else
                {
                    string languageid = System.Web.HttpContext.Current.Request.Cookies["ERCookie"].Values["LanguageID"];
                    if (!string.IsNullOrEmpty(languageid))
                    {
                        if (sql.IndexOf("#LanguageID") > 0)
                            sql = sql.Replace("#LanguageID", languageid);
                        else
                            sql = sql.Replace("@LanguageID", languageid);
                    }
                }
            }
            return sql;

        }

        public static String GetXmlNodeStr(string xpath, XmlDocument doc)
        {
            XmlNode node = doc.SelectSingleNode(xpath);
            if (node != null)
                return node.InnerText;
            else
                return string.Empty;
        }

        public static XmlNode GetXmlNode(XmlNodeList list, string Name)
        {
            foreach (XmlNode nod in list)
            {
                if (nod.Attributes["Name"].Value == Name)
                {
                    return nod;
                }
            }
            return null;
        }
        static XmlNodeList GetXmlNodeList(string Name)
        {
            XmlDocument doc = new XmlDocument();
            return doc.GetElementsByTagName(Name);
        }
        static XmlNode GetFunctionSqlStr(XmlNode ClassName, string FunctionName, string Sid)
        {
            foreach (XmlNode nod in ClassName.ChildNodes)
            {
                if (nod.Attributes["Name"].Value == FunctionName)
                {
                    if (nod.Attributes["SID"].Value == Sid)
                    {
                        return nod;
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// 写入错误信息文件 注：适用于SQL 错误
        /// </summary>
        /// <param name="logs"></param>
        /// <param name="type"></param>
        /// <param name="SourceFn"></param>
        public static void WriteFileLog(string logs, string type, string SourceFn)
        {
            string UName = string.Empty;
            string IP = string.Empty;
            if (HttpContext.Current != null)
            {
                HttpCookie cook = System.Web.HttpContext.Current.Request.Cookies["ERCookie"];
                if (cook != null)
                {
                    UName = HttpUtility.UrlDecode(cook.Values["cUserName"]);
                }
                IP = System.Web.HttpContext.Current.Request.UserHostAddress;
            }
            string xmlpath = Application.StartupPath + "\\Log\\Logs.log";

            string line = "====================================================================================================================================================\r\n";
            logs = line + "【时间：" + DateTime.Now.ToString() + "】\r\n" + "【信息：" + logs + "】\r\n";
            logs += line;
            File.AppendAllText(xmlpath, logs);

        }

        /// <summary>
        /// 写入错误信息文件 注：适用于SQL 错误
        /// </summary>
        /// <param name="logs"></param>
        /// <param name="type"></param>
        /// <param name="SourceFn"></param>
        public static void WriteFileLog(string logs)
        {

            string xmlpath = Application.StartupPath + "\\Log\\Logs.log";

            string line = "====================================================================================================================================================\r\n";
            logs = line + "【时间：" + DateTime.Now.ToString() + "】\r\n" + "【信息：" + logs + "】\r\n";
            logs += line;
            File.AppendAllText(xmlpath, logs);

        }


        /// <summary>
        /// 写入错误信息文件 注：适用于web页面发生的未知请求错误
        /// </summary>
        /// <param name="logs"></param>
        /// <param name="type"></param>
        /// <param name="SourceFn"></param>
        public static void WriteFileLogForWeb(string logs, string type, string SourceFn)
        {
            string UName = string.Empty;
            string IP = string.Empty;
            if (HttpContext.Current != null)
            {
                HttpCookie cook = System.Web.HttpContext.Current.Request.Cookies["ERCookie"];
                if (cook != null)
                {
                    UName = HttpUtility.UrlDecode(cook.Values["cUserName"]);
                }
                IP = System.Web.HttpContext.Current.Request.UserHostAddress;
            }
            string xmlpath = System.Web.HttpContext.Current.Server.MapPath("~/WebError.log");
            //string xmlpath = System.Configuration.ConfigurationManager.AppSettings["XmlPath"].ToString().Replace("XML\\", "");
            //string path = xmlpath += "\\WebError.log";
            string line = "====================================================================================================================================================\r\n";
            logs = line + "用户：" + UName + "\t时间：" + DateTime.Now.ToString() + "\tIP：" + IP + "\r\n错误类型：" + type + "\t请求页面：" + SourceFn + "\r\n" + "错误信息：" + logs + "\r\n";
            logs += line;
            File.AppendAllText(xmlpath, logs);

        }

    }

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;

namespace clsLibrarySQLHelper
{
    /// <summary>
    /// 读取config配置文件
    /// </summary>
    public class clsConfig
    {
        public clsConfig()
        {
            ///
            /// TODO: 在此处添加构造函数逻辑
            ///
        }
        /// <summary>
        /// 写操作
        /// </summary>
        /// <param name="strExecutablePath"></param>
        /// <param name="AppKey"></param>
        /// <param name="AppValue"></param>
        public static void ConfigSetValue(string strExecutablePath, string AppKey, string AppValue)
        {
            #region ConfigSetValue

            XmlDocument xDoc = new XmlDocument();
            //获取可执行文件的路径和名称
            xDoc.Load(strExecutablePath + ".config");

            XmlNode xNode;
            XmlElement xElem1;
            XmlElement xElem2;
            xNode = xDoc.SelectSingleNode("//connectionStrings");
            // xDoc.Load(System.Windows.Forms.Application.ExecutablePath + ".config");
            xElem1 = (XmlElement)xNode.SelectSingleNode("//add[@name='" + AppKey + "']");
            if (xElem1 != null) xElem1.SetAttribute("connectionString", AppValue);
            else
            {
                xElem2 = xDoc.CreateElement("add");
                xElem2.SetAttribute("name", AppKey);
                xElem2.SetAttribute("connectionString", AppValue);
                xNode.AppendChild(xElem2);
            }
            xDoc.Save(strExecutablePath + ".config");

            #endregion
        }

        /// <summary>
        /// 读操作
        /// </summary>
        /// <param name="strExecutablePath"></param>
        /// <param name="appKey"></param>
        /// <returns></returns>
        public string ConfigGetValue(string strExecutablePath, string appKey)
        {
            #region ConfigGetValue

            XmlDocument xDoc = new XmlDocument();
            try
            {
                xDoc.Load(strExecutablePath + ".config");

                XmlNode xNode;
                XmlElement xElem;
                xNode = xDoc.SelectSingleNode("//settings");
                xElem = (XmlElement)xNode.SelectSingleNode("//add[@key='" + appKey + "']");
                if (xElem != null)
                    return xElem.GetAttribute("value");
                else
                    return "";
            }
            catch (Exception)
            {
                return "";
            }

            #endregion
        }
    }
}