XinYu_ZHBMES_XGMES_PlatForm/新钢代码更新2012-10-10/ServerSolution/DBProxy/DBProxy.cs

using System;
using System.Collections;
using System.Data;
using System.Data.SqlClient;
using System.Data.OleDb;
using System.Data.OracleClient;
using System.Xml;
using System.IO;
using System.Text;
using System.Threading;
using System.Runtime.Remoting.Lifetime;
using System.Data.Common;
using System.Configuration;

using NHibernate;
using NHibernate.Cfg;


namespace STMes
{
    /// <summary>
    /// DBProxy 的摘要说明。
    /// </summary>
    public class DBProxy : MarshalByRefObject, IDisposable
    {
        private static Hashtable _dataProviderNameList = Hashtable.Synchronized(new Hashtable(5));
        private static Hashtable _dataProviderTypeList = Hashtable.Synchronized(new Hashtable(5));

        private CoreWriteLogFile cwl = new CoreWriteLogFile();

        public DBProxy()
        {
            AddDataProvider(new DataProvider.SqlDataProvider());
            AddDataProvider(new DataProvider.OleDbDataProvider());
            AddDataProvider(new DataProvider.OdbcDataProvider());
            AddDataProvider(new DataProvider.OracleDataProvider());
            AddDataProvider(new DataProvider.ODPDataProvider());
 
            
            //从数据库配置文件中读取数据库连接信息
            ReadDbConnectionInfo(@"MesDB.cfg");
            
            Console.WriteLine("创建数据库代理DBProxy...\n");

           

            //预先创建所有连接...
            CreateAllConnections();

            //_connLifeTimeA = int.Parse(System.Configuration.ConfigurationManager.AppSettings["connLifeTimeA"]);
            //_connLifeTimeB = int.Parse(System.Configuration.ConfigurationManager.AppSettings["connLifeTimeB"]);
            //_connLifeTimeC = int.Parse(System.Configuration.ConfigurationManager.AppSettings["connLifeTimeC"]);

            //创建一个线程，用来定时清除已经断开连接的DBManager
            #region 原来代码 maliang 2011-10-19
            /*
            _checkConnThread = new Thread(new ThreadStart(CheckConnActive));
            _checkConnThread.Start();
            _fixConnThread = new Thread(new ThreadStart(FixConnections));
            _fixConnThread.Start();
             */
            #endregion
            #region 变更代码 maliang 2011-10-19
            System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
            timer.Interval = 1 * 60 * 1000;
            timer.Tick += new EventHandler(timer_Tick);
            timer.Start();
            GC.KeepAlive(timer);
            #endregion
            //_init = true;
            _reference++;
        }

        void timer_Tick(object sender, EventArgs e)
        {
            ConnectionsListener();
        }

        //没有显示调用Dispose()时调用
        ~DBProxy()
        {
            Dispose(false);
        }

        #region IDisposable 成员

        public void Dispose()
        {
            Dispose(true);

            GC.Collect();
        }

        protected virtual void Dispose(bool disposing)
        {
            _reference--;

            if (disposing == true)
            {
                //释放受控资源
            }

            //释放未受控资源
            //回滚所有DBManager事务
            foreach (DictionaryEntry it in _transList)
            {
                TransInfo info = (TransInfo)it.Value;
                IDbConnection conn = info.dbConnection;

                try
                {
                    info.dbTransaction.Rollback();
                }
                catch (Exception)
                {

                }


                if (_reference == 0)
                {
                    //关闭数据库连接
                    //foreach (DictionaryEntry it1 in _connList)
                    //{
                    //    Hashtable ht1 = (Hashtable)it1.Value;
                    //    foreach (DictionaryEntry it2 in ht1)
                    //    {
                    //        Hashtable ht2 = (Hashtable)it2.Value;
                    //        foreach (DictionaryEntry it3 in ht2)
                    //        {
                    //            ArrayList arr = it3.Value as ArrayList;
                    //            foreach (object obj in arr)
                    //            {
                    //                IDbConnection db = (IDbConnection)obj;
                    //                db.Close();
                    //            }
                    //        }
                    //    }
                    //}


                    //add longjing 10-9

                    foreach (DictionaryEntry po in pool)
                    {
                        ISessionFactory factory = (ISessionFactory)po.Value;
                        
                        factory.Close();
                    }
                }
            }
            // 关闭线程
            //try
            //{
            //    if (_ConnectionsListenerThread != null)
            //    {
            //        _ConnectionsListenerThread.Abort();
            //    }
            //}
            //catch { }

            //try
            //{
            //    if (_checkConnThread != null)
            //        _checkConnThread.Abort();
            //}
            //catch (Exception) { }

            //try
            //{
            //    if (_fixConnThread != null)
            //        _fixConnThread.Abort();
            //}
            //catch (Exception) { }
        }
        #endregion

        //返回由DBProxy为每个DBManager对象分配的ID
        public long GetDBManagerID()
        {
            lock (_dbManagerID)
            {
                ++_dbManagerID[0];
                if (_dbManagerID[0] > 3000000)
                    _dbManagerID[0] = 1;
                return _dbManagerID[0];
            }
        }


        ////设置DBManager对应的数据库信息
        //public void SetDbInfo(long dbManagerID, string dbName, string priority)
        //{
        //    if (_dbList.Contains(dbManagerID))
        //    {
        //        _dbList.Remove(dbManagerID);
        //    }
        //    ArrayList arr = new ArrayList();
        //    arr.Add(dbName);
        //    arr.Add(priority);
        //    _dbList.Add(dbManagerID, arr);

        //}

        //获取数据库类型，用字符串"SQLServer","Oracle", "OleDb"分别表示不同类型的数据库
        public string GetDbType(string name, out string err)
        {
            err = "";

            //未找到该数据库对应的配置信息
            if (_dbConfigInfo.Contains(name) == false)
            {
                err = "未找到指定的数据库";
                return "";
            }

            //获取该数据库对应优先级的配置信息
            DBConnectionInfo dbInfo = (DBConnectionInfo)_dbConfigInfo[name];

            return dbInfo.dbType;
        }



        #region"数据操作"
        //执行带参数的SQL语句，返回DataSet
        //事务处理
        public DataSet ExecuteQuery(string dbName, string priority, Guid guid, string Sql, CommandType cmdType, IDataParameter[] Params, object[] Values, out string err)
        {
            return ExecuteQueryBase(dbName, priority, guid, Sql, cmdType, Params, Values, out err);
        }

        private DataSet ExecuteQueryBase(string dbName, string priority, Guid guid, string Sql, CommandType cmdType, IDataParameter[] Params, object[] Values, out string err)
        {


            ///////////////////
            err = "";
            DataSet ds = new DataSet();

            //获取数据库连接...
            IDbConnection conn = null;
            IDbTransaction trans = null;
            if (guid != null)
            {

                //如果是事务
                if (_transList.Contains(guid))
                {
                    TransInfo info = (TransInfo)_transList[guid];
                    conn = info.dbConnection;
                    trans = info.dbTransaction;

                    //如果事务已经失效，则返回
                    if (trans.Connection == null)
                    {
                        err = "事务已经失效！";
                        return ds;
                    }
                }
                else
                {
                    err = "未找到请求的事务！";
                    cwl.WriteLog("未找到请求的事务", LogInfoLevel.Error, "ExecuteQuery", "ExecuteQueryBase");
                    return ds;
                }
            }
            if (conn == null)
            {
                err = "获取数据库连接失败!";
                cwl.WriteLog("获取数据库连接失败", LogInfoLevel.Error, "ExecuteQuery", "ExecuteQueryBase");
                return ds;
            }
            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                IDbCommand command = conn.CreateCommand();
                DbDataAdapter adapter = dataProvider.CreateDataAdapterObject();
                ((IDbDataAdapter)adapter).SelectCommand = command;

                command.CommandText = Sql;
                command.CommandType = cmdType;
                //设置事务
                if (trans != null)
                {
                    command.Transaction = trans;
                }

                //给所有的参数赋值
                if (Params != null && Values != null)
                {
                    for (int i = 0; i < Params.Length; i++)
                    {
                        command.Parameters.Add(Params[i]);
                        ((IDbDataParameter)command.Parameters[i]).Value = Values[i];
                    }
                }

                adapter.Fill(ds);


            }
            catch (Exception ex)
            {
                err = ex.Message;
                cwl.WriteLog(err, LogInfoLevel.Error, "ExecuteQuery", "ExecuteQueryBase");
            }
            //////add longjing////////
            bool logflag = false;
            try
            {
                logflag = Convert.ToBoolean(GetConfigAttribute("ShowLog"));
                
            }
            catch { }

            if (logflag)
            {
                
                cwl.WriteLog(logflag, ds, Sql);
            }

            /////////////////////////
            return ds;
        }

        public DataSet ExecuteQuery(string dbName, string priority, string Sql, CommandType cmdType, IDataParameter[] Params, object[] Values, out string err)
        {
            return this.ExecuteQuery(dbName, priority, Sql, cmdType, Params, Values, out err, false);
        }

        //非事务处理
        public DataSet ExecuteQuery(string dbName, string priority, string Sql, CommandType cmdType, IDataParameter[] Params, object[] Values, out string err, bool ifDBLink)

        {
            if (ifDBLink)
            {
                return ExecuteQueryDBLink(dbName, priority, Sql, cmdType, Params, Values, out err);
            }
            else
            {
                err = "";
                DataSet ds = new DataSet();

                //获取数据库连接...
                //IDbConnection conn = GetDbConnection(dbName, priority, Sql);
                

                ISession session = null;
                IDbConnection conn = null;
                session = GetSession(dbName, Sql);
                conn = session.Connection;

                if (conn == null)
                {
                    err = "获取数据库连接失败!";
                    return ds;
                }
                try
                {
                    DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                    IDbCommand command = conn.CreateCommand();
                    DbDataAdapter adapter = dataProvider.CreateDataAdapterObject();
                    ((IDbDataAdapter)adapter).SelectCommand = command;

                    command.CommandText = Sql;
                    command.CommandType = cmdType;

                    //给所有的参数赋值
                    if (Params != null && Values != null)
                    {
                        for (int i = 0; i < Params.Length; i++)
                        {
                            command.Parameters.Add(Params[i]);
                            ((IDbDataParameter)command.Parameters[i]).Value = Values[i];
                        }
                    }
                    adapter.Fill(ds);

                }
                catch (Exception ex)
                {
                    err = ex.Message;
                }
                finally
                {
                    //ReleaseDbConnection(dbName, priority, conn, Sql);
                    if(session!=null)
                        session.Close();

             
                }
                //////add longjing////////
                bool logflag = false;
                try
                {
                    logflag = Convert.ToBoolean(GetConfigAttribute("ShowLog"));
                }
                catch { }

                if (logflag)
                {
                    
                    cwl.WriteLog(logflag, ds, Sql);
                }

                /////////////////////////
                return ds;
            }
        }
        //非事务处理
        private DataSet ExecuteQueryDBLink(string dbName, string priority, string Sql, CommandType cmdType, IDataParameter[] Params, object[] Values, out string err)
        {
            err = "";
            DataSet ds = new DataSet();

            //获取数据库连接...
            IDbConnection conn = null;
            IDbTransaction trans = null;
            ISession session = null;

            //conn = GetDbConnection(dbName, Sql);
            //conn = GetDbConnection(dbName, priority, Sql);

            session = GetSession(dbName, Sql);
            conn = session.Connection;

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return ds;
            }
            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                IDbCommand command = conn.CreateCommand();
                DbDataAdapter adapter = dataProvider.CreateDataAdapterObject();
                ((IDbDataAdapter)adapter).SelectCommand = command;

                trans = conn.BeginTransaction();

                command.CommandText = Sql;
                command.CommandType = cmdType;
                command.Transaction = trans;

                //给所有的参数赋值
                if (Params != null && Values != null)
                {
                    for (int i = 0; i < Params.Length; i++)
                    {
                        command.Parameters.Add(Params[i]);
                        ((IDbDataParameter)command.Parameters[i]).Value = Values[i];
                    }
                }

                adapter.Fill(ds);

                command.Transaction.Commit();
                command.CommandText = "begin dbms_session.close_database_link('XGCX');end;";
                command.ExecuteNonQuery();

            }
            catch (Exception ex)
            {
                err = ex.Message;
                if (trans != null)
                {
                    trans.Rollback();
                }
            }
            finally
            {
                //ReleaseDbConnection(dbName, priority, conn, Sql);
                if (session != null)
                    session.Close();
            }
            //////add longjing////////
            bool logflag = false;
            try
            {
                logflag = Convert.ToBoolean(GetConfigAttribute("ShowLog"));
            }
            catch { }

            if (logflag)
            {
                //cwl.WriteLog(logflag, ds, Sql, "ExecuteQuery", "ExecuteQueryDBLink");
                cwl.WriteLog(logflag, ds, Sql);
            }

            /////////////////////////
            return ds;
        }


        //执行带参数的SQL语句，返回DataSet
        //事务处理
        public DataSet ExecuteQuery(string dbName, string priority, Guid guid, string Sql, CommandType cmdType, string[] ParameterNames, DbType[] DbTypes, ParameterDirection[] Directions, bool[] IsNullables, string[] SourceColumns, DataRowVersion[] SourceVersions, object[] Values, ref ArrayList OutputValues, out string err)
        {
            err = "";
            DataSet ds = null;
            ds = new DataSet();

            //获取数据库连接...
            IDbConnection conn = null;
            IDbTransaction trans = null;

            //如果是事务
            if (_transList.Contains(guid))
            {
                //Console.WriteLine("事务：执行数据库操作{0}...\n", Sql);
                TransInfo info = (TransInfo)_transList[guid];
                conn = info.dbConnection;
                trans = info.dbTransaction;

                //如果事务已经失效，则返回
                if (trans.Connection == null)
                {
                    err = "事务已经失效！";
                    return ds;
                }
            }
            else
            {
                err = "未找到请求的事务！";
                return ds;
            }

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return ds;
            }
            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                IDbCommand command = conn.CreateCommand();
                DbDataAdapter adapter = dataProvider.CreateDataAdapterObject();
                ((IDbDataAdapter)adapter).SelectCommand = command;

                command.CommandText = Sql;
                command.CommandType = cmdType;
                //设置事务
                if (trans != null)
                {
                    command.Transaction = trans;
                }

                //给所有的参数赋值
                if (ParameterNames != null)
                {
                    for (int i = 0; i < ParameterNames.Length; i++)
                    {
                        IDbDataParameter parameter = dataProvider.CreateDataParameter();


                        parameter.ParameterName = ParameterNames[i];
                        if (conn is System.Data.OracleClient.OracleConnection)
                        {
                            try
                            {
                                ((System.Data.OracleClient.OracleParameter)parameter).OracleType = (System.Data.OracleClient.OracleType)DbTypes[i];
                            }
                            catch
                            {
                                parameter.DbType = DbTypes[i];
                            }
                        }
                        else
                        {
                            parameter.DbType = DbTypes[i];
                        }
                        if (parameter.Direction != System.Data.ParameterDirection.Input)
                            parameter.Size = 200;
                        parameter.Value = Values[i];
                        parameter.Direction = Directions[i];
                        //							parameter.IsNullable = IsNullables[i];
                        //							parameter.SourceColumn = SourceColumns[i];
                        //							parameter.SourceVersion = SourceVersions[i];						
                        command.Parameters.Add(parameter);
                    }
                }

                adapter.Fill(ds);

                //返回输出参数值
                if (OutputValues != null)
                {
                    for (int k = 0; k < command.Parameters.Count; k++)
                    {
                        if (((IDbDataParameter)command.Parameters[k]).Direction != ParameterDirection.Input)
                        {
                            OutputValues.Add(((IDbDataParameter)command.Parameters[k]).Value);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                err = ex.Message;
                trans.Rollback();
            }
            //////add longjing////////
            bool logflag = false;
            try
            {
                logflag = Convert.ToBoolean(GetConfigAttribute("ShowLog"));
            }
            catch { }

            if (logflag)
            {
                
                cwl.WriteLog(logflag, ds, Sql);
            }

            /////////////////////////
            return ds;
        }

        public DataSet ExecuteQuery(string dbName, string priority, string Sql, CommandType cmdType, string[] ParameterNames, DbType[] DbTypes, ParameterDirection[] Directions, bool[] IsNullables, string[] SourceColumns, DataRowVersion[] SourceVersions, object[] Values, ref ArrayList OutputValues, out string err)
        {
            return ExecuteQuery(dbName, priority, Sql, cmdType, ParameterNames, DbTypes, Directions, IsNullables, SourceColumns, SourceVersions, Values, ref OutputValues, out err, false);
        }
        //非事务处理
        public DataSet ExecuteQuery(string dbName, string priority, string Sql, CommandType cmdType, string[] ParameterNames, DbType[] DbTypes, ParameterDirection[] Directions, bool[] IsNullables, string[] SourceColumns, DataRowVersion[] SourceVersions, object[] Values, ref ArrayList OutputValues, out string err, bool ifDBLink)
        {
            err = "";
            DataSet ds = null;
            ds = new DataSet();

            //获取数据库连接...
            IDbConnection conn = null;
            //获取数据库连接
            //conn = GetDbConnection(dbName, Sql);
            ISession session = null;
            session = GetSession(dbName, Sql);
            conn = session.Connection;

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return ds;
            }
            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                IDbCommand command = conn.CreateCommand();
                DbDataAdapter adapter = dataProvider.CreateDataAdapterObject();
                ((IDbDataAdapter)adapter).SelectCommand = command;

                command.CommandText = Sql;
                command.CommandType = cmdType;

                //给所有的参数赋值
                if (ParameterNames != null)
                {
                    for (int i = 0; i < ParameterNames.Length; i++)
                    {
                        IDbDataParameter parameter = dataProvider.CreateDataParameter();


                        parameter.ParameterName = ParameterNames[i];
                        if (conn is System.Data.OracleClient.OracleConnection)
                        {
                            try
                            {
                                ((System.Data.OracleClient.OracleParameter)parameter).OracleType = (System.Data.OracleClient.OracleType)DbTypes[i];
                            }
                            catch
                            {
                                parameter.DbType = DbTypes[i];
                            }
                        }
                        else
                        {
                            parameter.DbType = DbTypes[i];
                        }
                        if (parameter.Direction != System.Data.ParameterDirection.Input)
                            parameter.Size = 200; parameter.Value = Values[i];
                        parameter.Direction = Directions[i];
                        //							parameter.IsNullable = IsNullables[i];
                        //							parameter.SourceColumn = SourceColumns[i];
                        //							parameter.SourceVersion = SourceVersions[i];						
                        command.Parameters.Add(parameter);
                    }
                }

                adapter.Fill(ds);

                //返回输出参数值
                if (OutputValues != null)
                {
                    for (int k = 0; k < command.Parameters.Count; k++)
                    {
                        if (((IDbDataParameter)command.Parameters[k]).Direction != ParameterDirection.Input)
                        {
                            OutputValues.Add(((IDbDataParameter)command.Parameters[k]).Value);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                err = ex.Message;
            }
            finally
            {
                //释放连接
                //ReleaseDbConnection(dbName, priority, conn, Sql);
                if (session != null)
                    session.Close();
            }
            //////add longjing////////
            bool logflag = false;
            try
            {
                logflag = Convert.ToBoolean(GetConfigAttribute("ShowLog"));
            }
            catch { }

            if (logflag)
            {
                
                cwl.WriteLog(logflag, ds, Sql);

            }

            /////////////////////////
            return ds;
        }


        //不通过DBServer时使用
        //事务处理
        public int ExecuteNonQuery_NoDBSever(string dbName, string priority, Guid guid, string Sql, CommandType cmdType, IDataParameter[] Params, out string err)
        {
            err = "";
            int lines = -1;//受影响的行数

            //获取数据库连接...
            IDbConnection conn = null;
            IDbTransaction trans = null;

            //如果是事务

            if (_transList.Contains(guid))
            {
                //Console.WriteLine("事务：执行数据库操作{0}...\n", Sql);
                TransInfo info = (TransInfo)_transList[guid];
                conn = info.dbConnection;
                trans = info.dbTransaction;

                //如果事务已经失效，则返回
                if (trans.Connection == null)
                {
                    err = "事务已经失效！";
                    return lines;
                }
            }
            else
            {
                err = "未找到请求的事务！";
                return lines;
            }

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return lines;
            }
            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                IDbCommand command = conn.CreateCommand();
                command.CommandText = Sql;
                command.CommandType = cmdType;
                command.Transaction = trans;

                //给所有的参数赋值
                if (Params != null)
                {
                    for (int i = 0; i < Params.Length; i++)
                    {
                        command.Parameters.Add(Params[i]);
                    }
                }

                lines = command.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                trans.Rollback();
                err = ex.Message;
            }
            return lines;
        }
        //非事务处理
        public int ExecuteNonQuery_NoDBSever(string dbName, string priority, string Sql, CommandType cmdType, IDataParameter[] Params, out string err)
        {
            err = "";
            int lines = -1;//受影响的行数

            //获取数据库连接
            IDbConnection conn = null;
            //获取数据库连接
            //conn = GetDbConnection(dbName, Sql);
            ISession session = null;
            session = GetSession(dbName, Sql);
            conn = session.Connection;

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return lines;
            }
            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                IDbCommand command = conn.CreateCommand();
                command.CommandText = Sql;
                command.CommandType = cmdType;
                //给所有的参数赋值
                if (Params != null)
                {
                    for (int i = 0; i < Params.Length; i++)
                    {
                        command.Parameters.Add(Params[i]);
                    }
                }

                lines = command.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                err = ex.Message;
            }
            finally
            {
                //ReleaseDbConnection(dbName, priority, conn, Sql);
                if (session != null)
                    session.Close();
            }
            return lines;
        }

        //执行带参数的SQL语句，返回受影响的行数
        //事务处理
        public int ExecuteNonQuery(string dbName, string priority, Guid guid, string Sql, CommandType cmdType, IDataParameter[] Params, object[] Values, out string err)
        {
            err = "";
            int lines = -1;//受影响的行数

            //获取数据库连接...
            IDbConnection conn = null;
            IDbTransaction trans = null;

            //如果是事务

            if (_transList.Contains(guid))
            {
                //Console.WriteLine("事务：执行数据库操作{0}...\n", Sql);
                TransInfo info = (TransInfo)_transList[guid];
                conn = info.dbConnection;
                trans = info.dbTransaction;

                //如果事务已经失效，则返回
                if (trans.Connection == null)
                {
                    err = "事务已经失效！";
                    return lines;
                }
            }
            else
            {
                err = "未找到请求的事务！";
                return lines;
            }

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return lines;
            }
            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                IDbCommand command = conn.CreateCommand();
                command.CommandText = Sql;
                command.CommandType = cmdType;
                command.Transaction = trans;

                //给所有的参数赋值
                if (Params != null && Values != null)
                {
                    for (int i = 0; i < Params.Length; i++)
                    {
                        command.Parameters.Add(Params[i]);
                        ((IDbDataParameter)command.Parameters[i]).Value = Values[i];
                    }
                }
                lines = command.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                err = ex.Message;
                trans.Rollback();
            }
            return lines;
        }
        //非事务处理
        public int ExecuteNonQuery(string dbName, string priority, string Sql, CommandType cmdType, IDataParameter[] Params, object[] Values, out string err)
        {
            err = "";
            int lines = -1;//受影响的行数

            //获取数据库连接...
            IDbConnection conn = null;
            //获取数据库连接
            //conn = GetDbConnection(dbName, Sql);
            ISession session = null;
            session = GetSession(dbName, Sql);
            conn = session.Connection;

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return lines;
            }
            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                IDbCommand command = conn.CreateCommand();
                command.CommandText = Sql;
                command.CommandType = cmdType;

                //给所有的参数赋值
                if (Params != null && Values != null)
                {
                    for (int i = 0; i < Params.Length; i++)
                    {
                        command.Parameters.Add(Params[i]);
                        ((IDbDataParameter)command.Parameters[i]).Value = Values[i];
                    }
                }

                lines = command.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                err = ex.Message;
            }
            finally
            {
                //释放连接
                //ReleaseDbConnection(dbName, priority, conn, Sql);
                if (session != null)
                    session.Close();
            }
            return lines;
        }

        //执行带参数的SQL语句，返回受影响的行数
        // 事务操作
        public int ExecuteNonQuery(string dbName, string priority, Guid guid, string Sql, CommandType cmdType, string[] ParameterNames, DbType[] DbTypes, ParameterDirection[] Directions, bool[] IsNullables, string[] SourceColumns, DataRowVersion[] SourceVersions, object[] Values, ref ArrayList OutputValues, out string err)
        {
            err = "";
            int lines = -1;//受影响的行数

            //获取数据库连接...
            IDbConnection conn = null;
            IDbTransaction trans = null;

            //如果是事务
            if (_transList.Contains(guid))
            {
                TransInfo info = (TransInfo)_transList[guid];
                conn = info.dbConnection;
                trans = info.dbTransaction;

                //如果事务已经失效，则返回
                if (trans.Connection == null)
                {
                    err = "事务已经失效！";
                    return lines;
                }
            }
            else
            {
                err = "未找到请求的事务！";
                return lines;
            }

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return lines;
            }
            showsql(Sql);
            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                IDbCommand command = conn.CreateCommand();
                command.CommandText = Sql;
                command.CommandType = cmdType;
                //设置事务
                command.Transaction = trans;

                if (ParameterNames != null)
                {
                    for (int i = 0; i < ParameterNames.Length; i++)
                    {
                        IDbDataParameter parameter = dataProvider.CreateDataParameter();
                        parameter.ParameterName = ParameterNames[i];
                        parameter.Value = Values[i];
                        parameter.Direction = Directions[i];
                        if (conn is System.Data.OracleClient.OracleConnection)
                        {
                            try
                            {
                                ((System.Data.OracleClient.OracleParameter)parameter).OracleType = (System.Data.OracleClient.OracleType)DbTypes[i];
                            }
                            catch
                            {
                                parameter.DbType = DbTypes[i];
                            }
                        }
                        else
                        {
                            parameter.DbType = DbTypes[i];
                        }
                        if (parameter.Direction != System.Data.ParameterDirection.Input)
                            parameter.Size = 200;
                        parameter.Direction = Directions[i];
                        command.Parameters.Add(parameter);
                    }
                }
                lines = command.ExecuteNonQuery();
                //返回输出参数值
                if (OutputValues != null)
                {
                    for (int k = 0; k < command.Parameters.Count; k++)
                    {
                        if (((IDbDataParameter)command.Parameters[k]).Direction != ParameterDirection.Input)
                        {
                            OutputValues.Add(((IDbDataParameter)command.Parameters[k]).Value);
                        }
                    }
                }
            }
            catch (System.Exception ex)
            {
                err = ex.Message;
                trans.Rollback();
            }
            return lines;
        }
        //非事务处理
        public int ExecuteNonQuery(string dbName, string priority, string Sql, CommandType cmdType, string[] ParameterNames, DbType[] DbTypes, ParameterDirection[] Directions, bool[] IsNullables, string[] SourceColumns, DataRowVersion[] SourceVersions, object[] Values, ref ArrayList OutputValues, out string err)
        {
            err = "";
            int lines = -1;//受影响的行数


            IDbConnection conn = null;
            //获取数据库连接
            //conn = GetDbConnection(dbName, Sql);
            ISession session = null;
            session = GetSession(dbName, Sql);
            conn = session.Connection;

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return lines;
            }
            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                IDbCommand command = conn.CreateCommand();
                command.CommandText = Sql;
                command.CommandType = cmdType;

                //给所有的参数赋值
                if (ParameterNames != null)
                {
                    for (int i = 0; i < ParameterNames.Length; i++)
                    {
                        IDbDataParameter parameter = dataProvider.CreateDataParameter();
                        parameter.ParameterName = ParameterNames[i];
                        parameter.Value = Values[i];
                        parameter.Direction = Directions[i];
                        if (conn is System.Data.OracleClient.OracleConnection)
                        {
                            try
                            {
                                ((System.Data.OracleClient.OracleParameter)parameter).OracleType = (System.Data.OracleClient.OracleType)DbTypes[i];
                            }
                            catch
                            {
                                parameter.DbType = DbTypes[i];
                            }
                        }
                        else
                        {
                            parameter.DbType = DbTypes[i];
                        }
                        if (parameter.Direction != System.Data.ParameterDirection.Input)
                            parameter.Size = 200;
                        parameter.Direction = Directions[i];
                        command.Parameters.Add(parameter);
                    }
                }

                lines = command.ExecuteNonQuery();

                //返回输出参数值
                if (OutputValues != null)
                {
                    for (int k = 0; k < command.Parameters.Count; k++)
                    {
                        if (((IDbDataParameter)command.Parameters[k]).Direction != ParameterDirection.Input)
                        {
                            OutputValues.Add(((IDbDataParameter)command.Parameters[k]).Value);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                err = ex.Message;
            }
            finally
            {
                //释放连接
                //ReleaseDbConnection(dbName, priority, conn, Sql);
                if (session != null)
                    session.Close();
            }
            return lines;
        }
        //事务处理
        public int ExecuteNonQuery(string dbName, string priority, Guid guid, string Sql, CommandType cmdType, string[] ParameterNames, DbType[] DbTypes, ParameterDirection[] Directions, bool[] IsNullables, string[] SourceColumns, DataRowVersion[] SourceVersions, int[] Sizes, object[] Values, ref ArrayList OutputValues, out string err)
        {
            err = "";
            int lines = -1;//受影响的行数

            //获取数据库连接...
            IDbConnection conn = null;
            IDbTransaction trans = null;

            //如果是事务
            if (_transList.Contains(guid))
            {
                //Console.WriteLine("事务：执行数据库操作{0}...\n", Sql);
                TransInfo info = (TransInfo)_transList[guid];
                conn = info.dbConnection;
                trans = info.dbTransaction;

                //如果事务已经失效，则返回
                if (trans.Connection == null)
                {
                    err = "事务已经失效！";
                    return lines;
                }
            }
            else
            {
                err = "未找到请求的事务！";
                return lines;
            }

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return lines;
            }
            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                DbDataAdapter adapter = dataProvider.CreateDataAdapterObject();

                IDbCommand command = conn.CreateCommand();
                command.CommandText = Sql;
                command.CommandType = cmdType;
                command.Transaction = trans;


                //给所有的参数赋值
                if (ParameterNames != null && DbTypes != null && Values != null)
                {
                    for (int i = 0; i < ParameterNames.Length; i++)
                    {
                        IDbDataParameter parameter = dataProvider.CreateDataParameter();
                        parameter.ParameterName = ParameterNames[i];
                        if (conn is System.Data.OracleClient.OracleConnection)
                        {
                            try
                            {
                                ((System.Data.OracleClient.OracleParameter)parameter).OracleType = (System.Data.OracleClient.OracleType)DbTypes[i];
                            }
                            catch
                            {
                                parameter.DbType = DbTypes[i];
                            }
                        }
                        else
                        {
                            parameter.DbType = DbTypes[i];
                        }
                        parameter.Direction = Directions[i];

                        if (parameter.Direction != System.Data.ParameterDirection.Input)
                            parameter.Size = 200;
                        parameter.Direction = Directions[i];
                        parameter.Value = Values[i];
                        command.Parameters.Add(parameter);
                    }
                }
                lines = command.ExecuteNonQuery();

                //返回输出参数值
                if (OutputValues != null)
                {
                    for (int k = 0; k < command.Parameters.Count; k++)
                    {
                        if (((IDbDataParameter)command.Parameters[k]).Direction != ParameterDirection.Input)
                        {
                            OutputValues.Add(((IDbDataParameter)command.Parameters[k]).Value);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                err = ex.Message;
                trans.Rollback();
            }
            return lines;
        }
        //非事务处理
        public int ExecuteNonQuery(string dbName, string priority, string Sql, CommandType cmdType, string[] ParameterNames, DbType[] DbTypes, ParameterDirection[] Directions, bool[] IsNullables, string[] SourceColumns, DataRowVersion[] SourceVersions, int[] Sizes, object[] Values, ref ArrayList OutputValues, out string err)
        {
            err = "";
            int lines = -1;//受影响的行数

            ISession session = null;
            //获取数据库连接...
            IDbConnection conn = null;

            //获取数据库连接
            
            //conn = GetDbConnection(dbName, Sql);
            
            session = GetSession(dbName, Sql);
            conn = session.Connection;

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return lines;
            }
            showsql(Sql);
            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                DbDataAdapter adapter = dataProvider.CreateDataAdapterObject();

                IDbCommand command = conn.CreateCommand();
                command.CommandText = Sql;
                command.CommandType = cmdType;

                //给所有的参数赋值
                if (ParameterNames != null && DbTypes != null && Values != null)
                {
                    for (int i = 0; i < ParameterNames.Length; i++)
                    {
                        IDbDataParameter parameter = dataProvider.CreateDataParameter();
                        parameter.ParameterName = ParameterNames[i];
                        if (conn is System.Data.OracleClient.OracleConnection)
                        {
                            try
                            {
                                ((System.Data.OracleClient.OracleParameter)parameter).OracleType = (System.Data.OracleClient.OracleType)DbTypes[i];
                            }
                            catch
                            {
                                parameter.DbType = DbTypes[i];
                            }
                        }
                        else
                        {
                            parameter.DbType = DbTypes[i];
                        }
                        parameter.Direction = Directions[i];
                        parameter.Size = Sizes[i];
                        parameter.Value = Values[i];
                        command.Parameters.Add(parameter);
                    }
                }
                lines = command.ExecuteNonQuery();

                //返回输出参数值
                if (OutputValues != null)
                {
                    for (int k = 0; k < command.Parameters.Count; k++)
                    {
                        if (((IDbDataParameter)command.Parameters[k]).Direction != ParameterDirection.Input)
                        {
                            OutputValues.Add(((IDbDataParameter)command.Parameters[k]).Value);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                err = ex.Message;
            }
            finally
            {
                //ReleaseDbConnection(dbName, priority, conn, Sql);
                if (session != null)
                    session.Close();

                
                
            }
            return lines;
        }

        public bool UpdateTable(string dbName, string priority, Guid guid, string Sql, CommandType cmdType, IDataParameter[] Params, object[] Values, DataTable dt, out string err)
        {
            err = "";
            bool result = true;
            //获取数据库连接...
            IDbConnection conn = null;
            IDbTransaction trans = null;

            //如果是事务
            if (_transList.Contains(guid))
            {
                //Console.WriteLine("事务：更新DataSet<{0}>...\n", Sql);
                TransInfo info = (TransInfo)_transList[guid];
                conn = info.dbConnection;
                trans = info.dbTransaction;

                //如果事务已经失效，则返回
                if (trans.Connection == null)
                {
                    err = "事务已经失效！";
                    return false;
                }
            }
            else
            {
                err = "未找到请求的事务！";
                return false;
            }

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return false;
            }

            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                DbDataAdapter adapter = dataProvider.CreateDataAdapterObject();

                IDbCommand command = conn.CreateCommand();
                command.CommandText = Sql;
                command.CommandType = cmdType;
                command.Transaction = trans;

                ((IDbDataAdapter)adapter).SelectCommand = command;

                //给所有的参数赋值
                if (Params != null && Values != null)
                {
                    for (int i = 0; i < Params.Length; i++)
                    {
                        command.Parameters.Add(Params[i]);

                    }
                }
                //自动生成SqlCommand命令
                object CB = dataProvider.CreateCommandBuilder(adapter);

                //提交数据更改
                adapter.Update(dt);
            }
            catch (Exception ex)
            {
                err = ex.Message;
                trans.Rollback();
                result = false;
            }
            return result;
        }

        //非事务处理
        public bool UpdateTable(string dbName, string priority, string Sql, CommandType cmdType, IDataParameter[] Params, object[] Values, DataTable dt, out string err)
        {
            err = "";
            bool result = false;
            //获取数据库连接...
            IDbConnection conn = null;

            //获取数据库连接
            //conn = GetDbConnection(dbName, Sql);

            ISession session = null;
            session = GetSession(dbName, Sql);
            conn = session.Connection;

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return false;
            }

            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                DbDataAdapter adapter = dataProvider.CreateDataAdapterObject();

                IDbCommand command = conn.CreateCommand();
                command.CommandText = Sql;
                command.CommandType = cmdType;

                ((IDbDataAdapter)adapter).SelectCommand = command;

                //给所有的参数赋值
                if (Params != null && Values != null)
                {
                    for (int i = 0; i < Params.Length; i++)
                    {
                        command.Parameters.Add(Params[i]);
                        ((IDbDataParameter)command.Parameters[i]).Value = Values[i];
                    }
                }

                //自动生成SqlCommand命令
                object CB = dataProvider.CreateCommandBuilder(adapter);

                //提交数据更改
                adapter.Update(dt);

            }
            catch (Exception ex)
            {
                err = ex.Message;
                result = false;
            }
            finally
            {
                //ReleaseDbConnection(dbName, priority, conn, Sql);
                if (session != null)
                    session.Close();
            }
            return result;
        }
        //事务处理
        public bool UpdateTable(string dbName, string priority, Guid guid, string Sql, CommandType cmdType, string[] ParameterNames, DbType[] DbTypes, object[] Values, DataTable dt, out string err)
        {
            err = "";
            bool result = true;
            //获取数据库连接...
            IDbConnection conn = null;
            IDbTransaction trans = null;

            //如果是事务
            if (_transList.Contains(guid))
            {
                //Console.WriteLine("事务：更新DataSet<{0}>...\n", Sql);
                TransInfo info = (TransInfo)_transList[guid];
                conn = info.dbConnection;
                trans = info.dbTransaction;

                //如果事务已经失效，则返回
                if (trans.Connection == null)
                {
                    err = "事务已经失效!";
                    cwl.WriteLog(err, LogInfoLevel.Error, "UpdateTable", "事务1");
                    return false;
                }
            }
            else
            {
                err = "未找到请求的事务！";
                return false;
            }

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return false;
            }
            try
            {
                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                DbDataAdapter adapter = dataProvider.CreateDataAdapterObject();
                IDbCommand command = conn.CreateCommand();
                command.CommandText = Sql;
                command.CommandType = cmdType;
                command.Transaction = trans;

                //给所有的参数赋值
                if (ParameterNames != null && DbTypes != null && Values != null)
                {
                    for (int i = 0; i < ParameterNames.Length; i++)
                    {
                        IDbDataParameter parameter = dataProvider.CreateDataParameter();
                        parameter.ParameterName = ParameterNames[i];
                        if (conn is System.Data.OracleClient.OracleConnection)
                        {
                            try
                            {
                                ((System.Data.OracleClient.OracleParameter)parameter).OracleType = (System.Data.OracleClient.OracleType)DbTypes[i];
                            }
                            catch
                            {
                                parameter.DbType = DbTypes[i];
                            }
                        }
                        else
                        {
                            parameter.DbType = DbTypes[i];
                        }
                        parameter.Value = Values[i];

                        command.Parameters.Add(parameter);
                    }
                }

                ((IDbDataAdapter)adapter).SelectCommand = command;

                //自动生成SqlCommand命令
                object CB = dataProvider.CreateCommandBuilder(adapter);

                //提交数据更改
                adapter.Update(dt);
            }
            catch (Exception ex)
            {
                err = ex.Message;
                trans.Rollback();

                result = false;
            }

            return result;
        }

        //非事务处理
        public bool UpdateTable(string dbName, string priority, string Sql, CommandType cmdType, string[] ParameterNames, DbType[] DbTypes, object[] Values, DataTable dt, out string err)
        {
            err = "";
            bool result = true;
            //获取数据库连接...
            IDbConnection conn = null;

            //获取数据库连接
            //conn = GetDbConnection(dbName, Sql);
            ISession session = null;
            session = GetSession(dbName, Sql);
            conn = session.Connection;

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return false;
            }
            try
            {

                DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
                DbDataAdapter adapter = dataProvider.CreateDataAdapterObject();
                IDbCommand command = conn.CreateCommand();
                command.CommandText = Sql;
                command.CommandType = cmdType;

                //给所有的参数赋值
                if (ParameterNames != null && DbTypes != null && Values != null)
                {
                    for (int i = 0; i < ParameterNames.Length; i++)
                    {
                        IDbDataParameter parameter = dataProvider.CreateDataParameter();
                        parameter.ParameterName = ParameterNames[i];
                        if (conn is System.Data.OracleClient.OracleConnection)
                        {
                            try
                            {
                                ((System.Data.OracleClient.OracleParameter)parameter).OracleType = (System.Data.OracleClient.OracleType)DbTypes[i];
                            }
                            catch
                            {
                                parameter.DbType = DbTypes[i];
                            }
                        }
                        else
                        {
                            parameter.DbType = DbTypes[i];
                        }
                        parameter.Value = Values[i];

                        command.Parameters.Add(parameter);
                    }
                }

                ((IDbDataAdapter)adapter).SelectCommand = command;

                //自动生成SqlCommand命令
                object CB = dataProvider.CreateCommandBuilder(adapter);

                //提交数据更改
                adapter.Update(dt);
            }
            catch (Exception ex)
            {
                err = ex.Message;
                result = false;
            }
            finally
            {
                //释放连接
                //ReleaseDbConnection(dbName, priority, conn, Sql);
                if (session != null)
                    session.Close();
            }
            return result;
        }


        #endregion

        #region"基础操作"
        public IDbCommand GetCommand(string dbName, string priority, Guid guid, out string err)
        {
            err = "";

            //获取数据库连接...
            IDbConnection conn = null;
            IDbTransaction trans = null;

            //如果是事务
            if (_transList.Contains(guid))
            {
                //Console.WriteLine("事务：更新DataSet<{0}>...\n", Sql);
                TransInfo info = (TransInfo)_transList[guid];
                conn = info.dbConnection;
                trans = info.dbTransaction;

                //如果事务已经失效，则返回
                if (trans.Connection == null)
                {
                    err = "事务已经失效";
                    return null;
                }
            }
            else
            {
                //Console.WriteLine("更新DataSet<{0}>...\n", Sql);
                //获取数据库连接
                //conn = GetDbConnection(dbName,  "GetCommand");
            }

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return null;
            }
            IDbCommand command = conn.CreateCommand();
            return command;
        }

        public IDbTransaction GetTransaction(string dbName, string priority, Guid guid, out string err)
        {
            err = "";
            IDbConnection conn = null;

            IDbTransaction trans = null;

            //如果是事务
            if (_transList.Contains(guid))
            {
                //Console.WriteLine("事务：更新DataSet<{0}>...\n", Sql);
                TransInfo info = (TransInfo)_transList[guid];
                trans = info.dbTransaction;
                conn = info.dbConnection;

                //如果事务已经失效，则返回
                if (trans.Connection == null)
                {
                    err = "事务已经失效";
                    return null;
                }

            }
            else
            {
                err = "没有事务!";
                return null;
            }

            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return null;
            }
            return trans;
        }
        /// <summary>
        /// 获取连接提供者
        /// </summary>
        /// <param name="configurationString"></param>
        /// <returns></returns>
        private static DataProvider.IDataProvider GetDataProvider(string dbType)
        {


            DataProvider.IDataProvider dataProvider =
                (DataProvider.IDataProvider)_dataProviderNameList[dbType.ToUpper()];


            return dataProvider;
        }

        public DataProvider.IDataProvider GetDataProvider(string dbName, out string err)
        {
            err = "";

            return GetDataProvider(this.GetDbType(dbName, out err));
        }
        public DataProvider.IDataProvider GetDataProvider(Guid guid, out string err)
        {
            err = "";
            IDbConnection conn = null;


            //如果是事务
            if (_transList.Contains(guid))
            {
                //Console.WriteLine("事务：更新DataSet<{0}>...\n", Sql);
                TransInfo info = (TransInfo)_transList[guid];
                conn = info.dbConnection;

            }
            if (conn == null)
            {
                err = "获取数据库连接失败!";
                return null;
            }

            return GetDataProvider(conn.GetType());
        }
        private static DataProvider.IDataProvider GetDataProvider(System.Type dbType)
        {


            DataProvider.IDataProvider dataProvider =
                (DataProvider.IDataProvider)_dataProviderTypeList[dbType];


            return dataProvider;
        }

        public System.Guid BeginTransaction(string dbName, string priority, long dbManagerID, double minutes, out string err)
        {
            return BeginTransaction("", dbName, priority, dbManagerID, minutes, out err);
        }
        /// <summary>
        /// 开始处理事务，同时指定该事务最长处理时间,单位为分钟，返回结果表示是否成功
        /// 不支持嵌套事务
        /// </summary>
        /// <param name="dbName"></param>
        /// <param name="priority"></param>
        /// <param name="dbManagerID"></param>
        /// <param name="minutes"></param>
        /// <param name="err"></param>
        /// <returns></returns>
        public System.Guid BeginTransaction(string methodName, string dbName, string priority, long dbManagerID, double minutes, out string err)
        {
            lock (_transList)
            {
                err = "";
                Guid guid = Guid.NewGuid();
               

                //获取数据库连接
                //IDbConnection conn = GetDbConnection(dbName, methodName);
                IDbConnection conn = null;
                ISession session = null;
                session = GetSession(dbName, methodName);
                conn = session.Connection;
               
                if (conn == null)
                {
                    err = "获取数据库连接失败!";
                    return guid;
                }

                //设置事务信息，包括数据库连接、事务、事务开始时间等
                TransInfo info = new TransInfo();
                info.dbConnection = conn;

               
                info.beginTime = DateTime.Now;
                info.dbManagerID = dbManagerID;
                try
                {
                    info.dbTransaction = conn.BeginTransaction(); ;
                    _transList.Add(guid, info);
                }
                catch (Exception ex)
                {
                    err = ex.Message;
                    //ReleaseDbConnection(dbName, priority, conn, err);
                    if (session != null)
                        session.Close();
                }
                return guid;
            }
        }

        //提交当前事务，返回结果表示是否成功
        public bool Commit(string dbName, string priority, Guid guid, out string err)
        {
            lock (_transList)
            {
                bool result = true;
                err = "";

                if (!_transList.Contains(guid))
                {
                    err = "不存在要提交的事务";
                    return false;
                }

                TransInfo info = (TransInfo)_transList[guid];

                IDbConnection conn = info.dbConnection;
                IDbTransaction trans = info.dbTransaction;
                try
                {
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    err = ex.Message;
                    result = false;
                    cwl.WriteLog(err, LogInfoLevel.Error, "Rollback", "");
                }
                finally
                {
                    //删除事务
                    ReleaseDbConnection(dbName, priority, conn, "Commit:" + guid.ToString());
                    _transList.Remove(guid);
                }
                return result;
            }
        }

        //回滚当前事务，返回结果表示是否成功
        public bool Rollback(string dbName, string priority, Guid guid, out string err)
        {
            lock (_transList)
            {
                bool result = true;
                err = "";

                if (!_transList.Contains(guid))
                {
                    err = "不存在要回滚的事务";
                    return false;
                }

                TransInfo info = (TransInfo)_transList[guid];
                IDbConnection conn = info.dbConnection;
                IDbTransaction trans = info.dbTransaction;

                try
                {
                    trans.Rollback();
                }
                catch (Exception ex)
                {
                    err = ex.Message;
                    result = false;
                    cwl.WriteLog(err, LogInfoLevel.Error, "Rollback", "");
                }
                finally
                {
                    //删除事务
                    ReleaseDbConnection(dbName, priority, conn, "Rollback:" + guid.ToString());

                    _transList.Remove(guid);
                }
                return result;
            }
        }




        /// <summary>
        /// 从数据库配置文件中读取数据库连接信息
        /// </summary>
        /// <param name="fileName">文件名称</param>
        /// <returns>是否成功</returns>
        private bool ReadDbConnectionInfo(string fileName)
        {
            _dbConfigInfo = new Hashtable();

            //如果文件存在则读取配置文件
            if (File.Exists(fileName) == true)
            {
                try
                {
                    XmlTextReader reader = null;

                    try
                    {
                        //打开数据库配置文件，并忽略所有的空格
                        reader = new XmlTextReader(fileName);
                        reader.WhitespaceHandling = WhitespaceHandling.None;

                        string dbName = "";
                        DBConnectionInfo dbConnectionInfo = new DBConnectionInfo();
                        //dbConnectionInfo.connectionPool = new Hashtable();

                        string type = "";
                        //string priority = "";
                        //string maxNum = "";


                        //解释XML文件
                        while (reader.Read())
                        {
                            //bool bFlag = false;

                            switch (reader.NodeType)
                            {
                                case XmlNodeType.Element:
                                    type = reader.Name;

                                    break;
                                case XmlNodeType.Text:
                                    if (type.Equals("name"))
                                    {
                                        dbName = reader.Value;
                                        dbConnectionInfo.dbName = dbName;
                                    }
                                    else
                                    {
                                        if (type.Equals("type"))
                                        {
                                            dbConnectionInfo.dbType = reader.Value;
                                        }

                                        else
                                        {
                                            if (type.Equals("connectionString"))
                                            {
                                                dbConnectionInfo.connectionString = reader.Value;
                                            }

                                            else
                                            {
                                                if (type.Equals("connectionDriver"))
                                                {
                                                    dbConnectionInfo.connectionDriver = reader.Value;
                                                }
                                                else
                                                {
                                                    if (type.Equals("connectionDialect"))
                                                    {
                                                        dbConnectionInfo.connectionDialect = reader.Value;
                                                    }

                                                }

                                            }

                                            //else
                                            //{
                                            //    if (type.Equals("connectionPool"))
                                            //    {
                                            //        //dbConnectionInfo.connectionPool = new Hashtable();
                                            //    }
                                            //    else
                                            //    {
                                            //        if (type.Equals("priority"))
                                            //        {
                                            //            priority = reader.Value;
                                            //        }
                                            //        else
                                            //        {
                                            //            if (type.Equals("maxConnectionNum"))
                                            //            {
                                            //                maxNum = reader.Value;
                                            //            }
                                            //        }
                                            //    }

                                            //}
                                    
                                        }
                                    }
                                    type = "";
                                    break;
                                case XmlNodeType.EndElement:
                                    //if (reader.Name.Equals("connectionPool"))
                                    //{
                                    //    dbConnectionInfo.connectionPool.Add(priority, maxNum);
                                    //    priority = "";
                                    //    maxNum = "";
                                    //}
                                    //else
                                    //{
                                        if (reader.Name.Equals("database"))
                                        {
                                            _dbConfigInfo.Add(dbName, dbConnectionInfo);
                                            dbName = "";
                                            dbConnectionInfo = new DBConnectionInfo();
                                            //dbConnectionInfo.connectionPool = new Hashtable();
                                        }
                                    //}
                                    break;
                            }
                        }
                    }

                    finally
                    {
                        if (reader != null)
                            reader.Close();
                    }


                }
                catch (Exception ex)
                {
                    return false;
                }
            }
            else//读取默认设置
            {
                return false;
            }

            return true;
        }

        //  获取Session
        private ISession GetSession(string dbName, string sqlstr)
        {

            ISession session = null;
            
            try
            {

                if (pool.Count > 0)
                {
                    session = (pool[dbName] as ISessionFactory).OpenSession();
                    return session;
                }

                else
                {
                    return null;
                }
            }
            catch (Exception ex)
            {
                cwl.WriteLog(ex.Message, LogInfoLevel.Error, "", "GetSession");
                return null;
            }

        }
        //add longjing 10-8 动态获取配置节点的值
        private string GetConfigAttribute(string appKey)
        {
            XmlDocument xDoc = new XmlDocument();
            try
            {
                xDoc.Load(System.Windows.Forms.Application.ExecutablePath + ".config");

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

        ////  获取数据库连接
        //private IDbConnection GetDbConnection(string dbName, string sqlstr)
        //{

        //    ISession session = null;
        //    IDbConnection conn = null;
        //    try
        //    {

        //        if (pool.Count > 0)
        //        {
        //            session = (pool[dbName] as ISessionFactory).OpenSession();
        //            conn = session.Connection;
                    

        //            return conn;
        //        }

        //        else
        //        {
        //            return null;
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        cwl.WriteLog(ex.Message, LogInfoLevel.Error, "", "GetDbConnection");
        //        return null;
        //    }

        //}


        ////  获取数据库连接
        //private IDbConnection GetDbConnection(string dbName, string priority, string sqlstr)
        //{
        //    IDbConnection conn = null;
        
            
            ////直接从数据库连接池中取连接，无连接则直接返回
            //Hashtable ht1 = (Hashtable)_connList[dbName];
            //if (ht1 == null)
            //{
            //    cwl.WriteLog("获取数据库连接失败!", LogInfoLevel.Message, "ht1:" + dbName, "GetDbConnection");
            //    return conn;
            //}
            //Hashtable ht2 = (Hashtable)ht1[priority];
            //if (ht2 == null)
            //{
            //    cwl.WriteLog("获取数据库连接失败!", LogInfoLevel.Message, "ht2:" + dbName + "/" + priority, "GetDbConnection");
            //    return conn;
            //}
            //lock (ht2)
            //{
            //    ArrayList freeList = ht2[0] as ArrayList;
            //    //排队，最长时间1秒
            //    //{
            //    //    for (int i = 0; i < 10; i++)
            //    //    {
            //    //        Thread.Sleep(100);
            //    //        if (freeList.Count > 0)
            //    //        {
            //    //            i = 10;
            //    //        }
            //    //    }
            //    //}
            //    if (freeList.Count <= 0)
            //    {
            //        ArrayList al = ht2[1] as ArrayList;
            //        if (al == null) al = new ArrayList();
            //        cwl.WriteLog("数据库忙，请稍后再试!", LogInfoLevel.Message, "<<<>>> " + dbName + " <<<>>>  freeList||" + al.Count.ToString(), "GetDbConnection");
            //        return null;
            //    }

            //    conn = (IDbConnection)freeList[0];

            //    freeList.Remove(conn);
            //    Hashtable busyList = (Hashtable)ht2[1];
            //    if (busyList == null)
            //    {
            //        busyList = new Hashtable();
            //        ht2.Add(1, busyList);
            //    }

            //    DataProvider.IDataProvider dataProvider = GetDataProvider(conn.GetType());
            //    try
            //    {
            //        if (conn.State != ConnectionState.Open)
            //        {
            //            string strConnState = conn.State.ToString();


            //            conn.Close();
            //            conn.Dispose();
            //            conn = null;
            //            GC.Collect();

            //            foreach (DictionaryEntry it in _dbConfigInfo)
            //            {
            //                DBConnectionInfo info = (DBConnectionInfo)it.Value;
            //                if (info.dbName == dbName)
            //                {
            //                    conn = dataProvider.CreateConnectionObject(info.connectionString);
            //                    conn.Open();
            //                    cwl.WriteLog("重连成功！||连接状态：" + strConnState, LogInfoLevel.Message, info.dbName, "GetDbConnection");
            //                    break;
            //                }
            //            }
            //        }
            //    }
            //    catch (Exception ex)
            //    {
            //        cwl.WriteLog(ex.Message, LogInfoLevel.Error, "", "GetDbConnection");
            //        return null;
            //    }

            //    CurrConnOperateInfo cco = new CurrConnOperateInfo();
            //    cco.dt = DateTime.Now;
            //    cco.sqlstr = sqlstr;
            //    cco.SID = dataProvider.GetSID(ref conn);
            //    busyList.Add(conn, cco);
            //    return conn;
            //}
            
        //}

        private void ReleaseDbConnection(string dbName, string priority, IDbConnection conn, string SqlText)
        {
            
            //if (conn == null) { return; }
            

            //Hashtable ht1 = (Hashtable)_connList[dbName];
            //if (ht1 == null) { return; }

            //Hashtable ht2 = (Hashtable)ht1[priority];
            //if (ht2 == null) { return; }

            //lock (ht2)
            //{
            //    Hashtable busyList = (Hashtable)ht2[1];
            //    if (busyList != null)
            //    {
            //        if (!busyList.Contains(conn))
            //        {
            //            // 连接已被检验线程处理，此处不在处理

            //            //cwl.WriteLog(SqlText, LogInfoLevel.Message, "", "ReleaseDbConnection");
            //            return;
            //        }
            //        busyList.Remove(conn);
            //    }

            //    ArrayList freeList = ht2[0] as ArrayList;
            //    if (freeList == null)
            //    {
            //        freeList = new ArrayList();
            //        ht2.Add(0, freeList);
            //    }
            //    freeList.Add(conn);
            //}
        }

        /// <summary>
        /// 初始化数据提供接口
        /// </summary>
        /// <param name="dataProvider"></param>
        public static void AddDataProvider(DataProvider.IDataProvider dataProvider)
        {
            _dataProviderNameList[dataProvider.Name.ToUpper()] = dataProvider;
            _dataProviderTypeList[dataProvider.ConnectionType] = dataProvider;
        }



        Hashtable pool = new Hashtable();

        private void CreateAllConnections()
        {

            try
            {

                //如果连接已经创建，则返回
                if (pool.Count > 0)
                {
                    return;
                }

                if (_dbConfigInfo.Count != 0)
                {
                    foreach (DictionaryEntry it in _dbConfigInfo)
                    {
                        DBConnectionInfo info = (DBConnectionInfo)it.Value;
                        DataProvider.IDataProvider dataProvider = GetDataProvider(info.dbType);



                        ISessionFactory factory = NHibernateHelper.NHibernateHelper.GetSessionFactory(info.connectionDialect, info.connectionDriver, info.connectionString);
                        //IDbConnection conn = session.Connection;
                        pool.Add(info.dbName, factory);
                        
                        //Hashtable ht1 = new Hashtable();
                        //foreach (DictionaryEntry pool in info.connectionPool)
                        //{
                        //    Hashtable ht2 = new Hashtable();
                        //    ArrayList connList = new ArrayList();
                        //    for (int i = 0; i < Convert.ToInt32(pool.Value); i++)
                        //    {
                        //        try
                        //        {
                        //            IDbConnection conn = dataProvider.CreateConnectionObject(info.connectionString);

                        //            conn.Open();

                        //            connList.Add(conn);
                        //        }
                        //        catch (Exception ex)
                        //        {
                        //            cwl.WriteLog("创建数据库连接" + info.dbName + " " + pool.Key + " " + i.ToString() + "失败！", LogInfoLevel.Error, info.dbName, "CreateAllConnections");
                        //            break;
                        //        }
                        //    }
                        //    ht2.Add(0, connList);
                        //    ht1.Add(pool.Key, ht2);
                        //}
                        //_connList.Add(info.dbName, ht1);
                    }
                    cwl.WriteLog("启动成功！数据库连接池创建成功！");
                }
            }
            catch(Exception ex)
            {
                cwl.WriteLog("数据库连接池创建失败！原因是："+ex.Message);
            }
        }

        #region 原来代码 maliang 2011-10-19
        /*
        private void FixConnections()
        {
            while (true)
            {
                try
                {
                    foreach (DictionaryEntry it in _dbConfigInfo)
                    {
                        DBConnectionInfo info = (DBConnectionInfo)it.Value;
                        DataProvider.IDataProvider dataProvider = GetDataProvider(info.dbType);
                        Hashtable ht1 = (Hashtable)_connList[info.dbName];
                        foreach (DictionaryEntry pool in info.connectionPool)
                        {
                            Hashtable ht2 = (Hashtable)ht1[pool.Key];
                            lock (ht2)
                            {
                                ArrayList connList = ht2[0] as ArrayList;
                                Hashtable busyConnList = (Hashtable)ht2[1];
                                int connNumber = 0;
                                if (connList != null)
                                {
                                    connNumber = connList.Count;
                                }
                                else
                                {
                                    connList = new ArrayList();
                                    ht2.Remove(0);
                                    ht2.Add(0, connList);
                                }
                                if (busyConnList != null)
                                {
                                    connNumber += busyConnList.Count;
                                }
                                if (connNumber < Convert.ToInt32(pool.Value))
                                {
                                    cwl.WriteLog("有数据库连接意外销毁，增加数据库连接！", LogInfoLevel.Message, info.dbName, "FixConnections");

                                    for (int i = connNumber; i < Convert.ToInt32(pool.Value); i++)
                                    {
                                        try
                                        {
                                            IDbConnection conn = dataProvider.CreateConnectionObject(info.connectionString);
                                            conn.Open();
                                            connList.Add(conn);
                                            cwl.WriteLog("增加数据库连接" + info.dbName + " " + pool.Key + " " + i.ToString() + "成功！", LogInfoLevel.Message, info.dbName, "FixConnections");
                                        }
                                        catch (Exception ex)
                                        {
                                            cwl.WriteLog("增加数据库连接" + info.dbName + " " + pool.Key + " " + i.ToString() + "失败！", LogInfoLevel.Error, info.dbName, "FixConnections");
                                            Console.WriteLine("增加数据库连接" + info.dbName + " " + pool.Key + " " + "失败！" + ex.Message + "\n");
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    cwl.WriteLog(ex.Message, LogInfoLevel.Error, "", "FixConnections");
                }

                Thread.Sleep(3 * 60 * 1000);
            }

        }
        private void CheckConnActive()
        {
            while (true)
            {
                try
                {
                    if (_init)
                    {
                        foreach (DictionaryEntry it in _connList)
                        {
                            Hashtable ht1 = (Hashtable)it.Value;
                            string dbName = it.Key as string;
                            DBConnectionInfo info = (DBConnectionInfo)_dbConfigInfo[dbName];
                            DataProvider.IDataProvider dataProvider = GetDataProvider(info.dbType);

                            foreach (DictionaryEntry it2 in ht1)
                            {
                                ArrayList connList = ((Hashtable)it2.Value)[0] as ArrayList;
                                #region // 检查闲列表
                                //for ( int l = 0 ; l< connList.Count ;l++)
                                //{
                                //    IDbConnection conn = connList[l] as IDbConnection ; 
                                //    if(conn!=null)
                                //    {
                                //        if(!dataProvider.Ping(ref conn)  )
                                //        {
                                //            //Thread.Sleep( 1000);
                                //            //if(!dataProvider.Ping(ref conn)  )
                                //            //{
                                //                cwl.WriteLog("连接失效，重新连接中......", LogInfoLevel.Message, info.dbName, "CheckConnActive");
                                //                Console.WriteLine(info.dbName + "连接失效，重新连接中......\n");
                                //                //connList.Remove(conn);
                                //                if (conn != null )
                                //                {
                                //                    conn.Close();
                                //                    conn.Dispose();
                                //                    conn = null;
                                //                    GC.Collect();
                                //                }
                                //                try
                                //                {
                                //                    conn = dataProvider.CreateConnectionObject(info.connectionString);
                                //                    conn.Open();
                                //                    connList[l] = conn;
                                //                    cwl.WriteLog("重连成功！", LogInfoLevel.Message, info.dbName, "CheckConnActive");
                                //                    Console.WriteLine(info.dbName + "重连成功！\n");

                                //                }
                                //                catch(Exception ex)
                                //                {
                                //                    cwl.WriteLog("重连失败！", LogInfoLevel.Error, info.dbName, "CheckConnActive");
                                //                    Console.WriteLine(info.dbName + "重连失败！" +ex.Message + "\n");

                                //                }

                                //            //}

                                //        }
                                //    }
                                //    else
                                //    {
                                //        try
                                //        {
                                //            conn = dataProvider.CreateConnectionObject(info.connectionString);
                                //            conn.Open();
                                //            connList[l]= conn;
                                //            Console.WriteLine(info.dbName + "重连成功！\n");
                                //            cwl.WriteLog("重连成功！", LogInfoLevel.Message, info.dbName, "CheckConnActive");

                                //        }
                                //        catch(Exception ex)
                                //        {
                                //            Console.WriteLine("重连失败！" + ex.Message + "\n");
                                //            cwl.WriteLog("重连失败！", LogInfoLevel.Error, info.dbName, "CheckConnActive");

                                //        }
                                //    }
                                //}
                                #endregion

                                #region // 检查忙列表
                                if (((Hashtable)it2.Value).Count < 2) continue;

                                Hashtable busyConnList = ((Hashtable)it2.Value)[1] as Hashtable;
                                if (busyConnList != null)
                                {
                                    Hashtable m_busyConnList = busyConnList.Clone() as Hashtable;
                                    foreach (DictionaryEntry busyConn in m_busyConnList)
                                    {
                                        DateTime dt = ((CurrConnOperateInfo)busyConn.Value).dt;

                                        DateTime t = DateTime.Now;
                                        if ((string)it2.Key == "A")
                                        {
                                            t = dt.AddSeconds(_connLifeTimeA);
                                        }
                                        else if ((string)it2.Key == "B")
                                        {
                                            t = dt.AddSeconds(_connLifeTimeB);
                                        }
                                        else if ((string)it2.Key == "C")
                                        {
                                            t = dt.AddSeconds(_connLifeTimeC);
                                        }

                                        #region //判断是否已经超时
                                        if (t.CompareTo(DateTime.Now) < 0)
                                        {

                                            IDbConnection conn = busyConn.Key as IDbConnection;
                                            if (conn != null)
                                            {
                                                try
                                                {
                                                    cwl.WriteLog("有连接超时，将关闭重连！||忙连接数：" + busyConnList.Count.ToString() + "||闲连接数：" + connList.Count.ToString()
                                                        + " SID:" + ((CurrConnOperateInfo)busyConn.Value).SID.ToString()
                                                        + " SQL:" + ((CurrConnOperateInfo)busyConn.Value).sqlstr
                                                        + " 执行开始时间：" + ((CurrConnOperateInfo)busyConn.Value).dt.ToLongTimeString()
                                                        + " 当前时间：" + DateTime.Now.ToLongTimeString(),
                                                        LogInfoLevel.Error, info.dbName, "CheckConnActive");
                                                    busyConnList.Remove(conn);

                                                    conn.Close();
                                                    conn.Dispose();
                                                    conn = null;
                                                    GC.Collect();
                                                    conn = dataProvider.CreateConnectionObject(info.connectionString);
                                                    conn.Open();
                                                    if (connList == null)
                                                    {
                                                        connList = new ArrayList();
                                                        ht1.Remove(0);
                                                        ht1.Add(0, connList);
                                                    }
                                                    connList.Add(conn);
                                                    cwl.WriteLog("超时连接重连成功！||忙连接数：" + busyConnList.Count.ToString() + "||闲连接数：" + connList.Count.ToString(),
                                                        LogInfoLevel.Message, info.dbName, "CheckConnActive");
                                                }
                                                catch (Exception ex)
                                                {
                                                    cwl.WriteLog("重连失败,丢失一个连接！", LogInfoLevel.Error, info.dbName, "CheckConnActive");
                                                    Console.WriteLine("重连失败,丢失一个连接！" + ex.Message + "\n");

                                                }
                                            }
                                            else
                                            {
                                                try
                                                {
                                                    cwl.WriteLog("有连接失效，将关闭重连！", LogInfoLevel.Error, info.dbName, "CheckConnActive");
                                                    Console.WriteLine(info.dbName + "有连接失效，将关闭重连！\n");
                                                    busyConnList.Remove(conn);
                                                    conn = dataProvider.CreateConnectionObject(info.connectionString);
                                                    conn.Open();
                                                    if (connList == null)
                                                    {
                                                        connList = new ArrayList();
                                                        ht1.Remove(0);
                                                        ht1.Add(0, connList);
                                                    }
                                                    connList.Add(conn);
                                                }
                                                catch (Exception ex)
                                                {
                                                    cwl.WriteLog("重连失败,丢失一个连接！", LogInfoLevel.Error, info.dbName, "CheckConnActive");
                                                    Console.WriteLine("重连失败,丢失一个连接！" + ex.Message + "\n");
                                                }
                                            }
                                        }
                                        #endregion
                                    }
                                }
                                #endregion
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    cwl.WriteLog(ex.Message, LogInfoLevel.Error, "", "CheckConnActive");
                    // Console.WriteLine(ex.Message);
                }

                Thread.Sleep(1 * 60 * 1000);

            }
        }
        */
        #endregion

        #region 变更代码 maliang 2011-10-19
        private static object lockObj = new object();

        private void ConnectionsListener()
        {

            lock (lockObj)
            {
                //CheckConnActive();
                FixConnections();

            }

        }

        private void FixConnections()
        {

        //    try
        //    {
        //        foreach (DictionaryEntry it in _dbConfigInfo)
        //        {
        //            DBConnectionInfo info = (DBConnectionInfo)it.Value;
        //            DataProvider.IDataProvider dataProvider = GetDataProvider(info.dbType);
        //            Hashtable ht1 = (Hashtable)_connList[info.dbName];
        //            foreach (DictionaryEntry pool in info.connectionPool)
        //            {
        //                Hashtable ht2 = (Hashtable)ht1[pool.Key];
        //                lock (ht2)
        //                {
        //                    ArrayList connList = ht2[0] as ArrayList;
        //                    Hashtable busyConnList = (Hashtable)ht2[1];
        //                    int connNumber = 0;
        //                    if (connList != null)
        //                    {
        //                        connNumber = connList.Count;
        //                    }
        //                    else
        //                    {
        //                        connList = new ArrayList();
        //                        ht2.Remove(0);
        //                        ht2.Add(0, connList);
        //                    }
        //                    if (busyConnList != null)
        //                    {
        //                        connNumber += busyConnList.Count;
        //                    }
        //                    if (connNumber < Convert.ToInt32(pool.Value))
        //                    {
        //                        cwl.WriteLog("有数据库连接意外销毁，增加数据库连接！", LogInfoLevel.Message, info.dbName, "FixConnections");

        //                        for (int i = connNumber; i < Convert.ToInt32(pool.Value); i++)
        //                        {
        //                            try
        //                            {
        //                                IDbConnection conn = dataProvider.CreateConnectionObject(info.connectionString);
        //                                conn.Open();
        //                                connList.Add(conn);
        //                                cwl.WriteLog("增加数据库连接" + info.dbName + " " + pool.Key + " " + i.ToString() + "成功！", LogInfoLevel.Message, info.dbName, "FixConnections");
        //                            }
        //                            catch (Exception ex)
        //                            {
        //                                cwl.WriteLog("增加数据库连接" + info.dbName + " " + pool.Key + " " + i.ToString() + "失败！", LogInfoLevel.Error, info.dbName, "FixConnections");
        //                                Console.WriteLine("增加数据库连接" + info.dbName + " " + pool.Key + " " + "失败！" + ex.Message + "\n");
        //                                break;
        //                            }
        //                        }
        //                    }
        //                }
        //            }
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        cwl.WriteLog(ex.Message, LogInfoLevel.Error, "", "FixConnections");
        //    }



        //}
        //private void CheckConnActive()
        //{

        //    try
        //    {
        //        if (_init)
        //        {
        //            foreach (DictionaryEntry it in _connList)
        //            {
        //                Hashtable ht1 = (Hashtable)it.Value;
        //                string dbName = it.Key as string;
        //                DBConnectionInfo info = (DBConnectionInfo)_dbConfigInfo[dbName];
        //                DataProvider.IDataProvider dataProvider = GetDataProvider(info.dbType);

        //                foreach (DictionaryEntry it2 in ht1)
        //                {
        //                    ArrayList connList = ((Hashtable)it2.Value)[0] as ArrayList;


        //                    #region // 检查忙列表
        //                    if (((Hashtable)it2.Value).Count < 2) continue;

        //                    Hashtable busyConnList = ((Hashtable)it2.Value)[1] as Hashtable;
        //                    if (busyConnList != null)
        //                    {
        //                        Hashtable m_busyConnList = busyConnList.Clone() as Hashtable;
        //                        foreach (DictionaryEntry busyConn in m_busyConnList)
        //                        {
        //                            DateTime dt = ((CurrConnOperateInfo)busyConn.Value).dt;

        //                            DateTime t = DateTime.Now;
        //                            if ((string)it2.Key == "A")
        //                            {
        //                                t = dt.AddSeconds(_connLifeTimeA);
        //                            }
        //                            else if ((string)it2.Key == "B")
        //                            {
        //                                t = dt.AddSeconds(_connLifeTimeB);
        //                            }
        //                            else if ((string)it2.Key == "C")
        //                            {
        //                                t = dt.AddSeconds(_connLifeTimeC);
        //                            }

        //                            #region //判断是否已经超时
        //                            if (t.CompareTo(DateTime.Now) < 0)
        //                            {

        //                                IDbConnection conn = busyConn.Key as IDbConnection;
        //                                if (conn != null)
        //                                {
        //                                    try
        //                                    {
        //                                        cwl.WriteLog("有连接超时，将关闭重连！||忙连接数：" + busyConnList.Count.ToString() + "||闲连接数：" + connList.Count.ToString()
        //                                            + " SID:" + ((CurrConnOperateInfo)busyConn.Value).SID.ToString()
        //                                            + " SQL:" + ((CurrConnOperateInfo)busyConn.Value).sqlstr
        //                                            + " 执行开始时间：" + ((CurrConnOperateInfo)busyConn.Value).dt.ToLongTimeString()
        //                                            + " 当前时间：" + DateTime.Now.ToLongTimeString(),
        //                                            LogInfoLevel.Error, info.dbName, "CheckConnActive");
        //                                        busyConnList.Remove(conn);

        //                                        conn.Close();
        //                                        conn.Dispose();
        //                                        conn = null;
        //                                        GC.Collect();
        //                                        conn = dataProvider.CreateConnectionObject(info.connectionString);

        //                                        conn.Open();
        //                                        if (connList == null)
        //                                        {
        //                                            connList = new ArrayList();
        //                                            ht1.Remove(0);
        //                                            ht1.Add(0, connList);
        //                                        }
        //                                        connList.Add(conn);
        //                                        cwl.WriteLog("超时连接重连成功！||忙连接数：" + busyConnList.Count.ToString() + "||闲连接数：" + connList.Count.ToString(),
        //                                            LogInfoLevel.Message, info.dbName, "CheckConnActive");
        //                                    }
        //                                    catch (Exception ex)
        //                                    {
        //                                        cwl.WriteLog("重连失败,丢失一个连接！", LogInfoLevel.Error, info.dbName, "CheckConnActive");
        //                                        Console.WriteLine("重连失败,丢失一个连接！" + ex.Message + "\n");

        //                                    }
        //                                }
        //                                else
        //                                {
        //                                    try
        //                                    {
        //                                        cwl.WriteLog("有连接失效，将关闭重连！", LogInfoLevel.Error, info.dbName, "CheckConnActive");
        //                                        Console.WriteLine(info.dbName + "有连接失效，将关闭重连！\n");
        //                                        busyConnList.Remove(conn);
        //                                        conn = dataProvider.CreateConnectionObject(info.connectionString);
        //                                        conn.Open();
        //                                        if (connList == null)
        //                                        {
        //                                            connList = new ArrayList();
        //                                            ht1.Remove(0);
        //                                            ht1.Add(0, connList);
        //                                        }
        //                                        connList.Add(conn);
        //                                    }
        //                                    catch (Exception ex)
        //                                    {
        //                                        cwl.WriteLog("重连失败,丢失一个连接！", LogInfoLevel.Error, info.dbName, "CheckConnActive");
        //                                        Console.WriteLine("重连失败,丢失一个连接！" + ex.Message + "\n");
        //                                    }
        //                                }
        //                            }
        //                            #endregion
        //                        }
        //                    }
        //                    #endregion
        //                }
        //            }
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        cwl.WriteLog(ex.Message, LogInfoLevel.Error, "", "CheckConnActive");
        //        // Console.WriteLine(ex.Message);
        //    }




        }
        #endregion



        ///////////////////////////////////////////////////////////////////////////////
        ///私有数据成员
        //////////////////////////////////////////////////////////////////////////////


        //定义数据库连接信息
        private struct DBConnectionInfo
        {
            public string dbName;
            public string dbType;
            public string connectionString;
//add long
            public string connectionDriver;
            public string connectionDialect;
       
            //public Hashtable connectionPool;
        };

        //////定义数据库连接信息
        //private struct DBConnectionInfo
        //{
        //    public string dbName;
        //    public string dbType;
        //    public string connectionString;
        //    // <Key = priority Value = maxConnectionNum/>
        //    public Hashtable connectionPool;
        //};
        // 存储当前连接的操作信息
        //private struct CurrConnOperateInfo
        //{
        //    public DateTime dt;
        //    public string sqlstr;
        //    public int SID;
        //}

        /// <summary>
        /// 事务信息
        /// </summary>
        private struct TransInfo
        {
            public long dbManagerID;
            public IDbConnection dbConnection;
            public IDbTransaction dbTransaction;
            public DateTime beginTime;
        };
        private void showsql(string sql)
        {
            //Console.WriteLine(sql+"\n");
        }
        #endregion
        private static long[] _dbManagerID = new long[1] { 0 };//由DBProxy为每个DBManager对象分配的ID		

        //<Key = name Value DBConnectionInfo>
        private Hashtable _dbConfigInfo;//数据库配置信息


        private static Hashtable _connList = new Hashtable();

        private Hashtable _transList = new Hashtable();

        private Hashtable _dbList = new Hashtable();//每个DBManager对应的数据库信息

        //private double _connLifeTimeA;//数据库连接允许的最长无反应时间A级
        //private double _connLifeTimeB;//数据库连接允许的最长无反应时间B级
        //private double _connLifeTimeC;//数据库连接允许的最长无反应时间C级

        //private Thread _checkConnThread;//检查Conn是否有效
        //private Thread _fixConnThread;//检查Conn是否有足够数量

        //private Thread _ConnectionsListenerThread;//检查Conn是否有效和是否有足够数量


        private long _reference = 0;//DBProxy对象实例数
        //private bool _init = false;

    }
}