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;

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());

            Console.WriteLine("创建数据库代理DBProxy...\n");

            //从数据库配置文件中读取数据库连接信息
            ReadDbConnectionInfo(@"MesDB.cfg");

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

            _connLifeTimeA = int.Parse(ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None).AppSettings.Settings["connLifeTimeA"].Value.ToString().ToLower());
            _connLifeTimeB = int.Parse(ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None).AppSettings.Settings["connLifeTimeB"].Value.ToString().ToLower());
            _connLifeTimeC = int.Parse(ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None).AppSettings.Settings["connLifeTimeC"].Value.ToString().ToLower());

            //创建一个线程，用来定时清除已经断开连接的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
            _ConnectionsListenerThread = new Thread(new ThreadStart(ConnectionsListener));
            _ConnectionsListenerThread.Start();
            #endregion
            _init = true;
            _reference++;
        }

        //没有显示调用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();
                                }
                            }
                        }
                    }
                }
            }
            // 关闭线程

            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");
            }
            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);

                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);
                }
                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;

            conn = GetDbConnection(dbName, priority, Sql);

            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);
            }
            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();
            }

            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, priority, Sql);

            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);
            }
            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, priority, Sql);

            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);
            }
            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, priority, Sql);

            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);
            }
            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, priority, Sql);

            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);
            }
            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;//受影响的行数

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

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

            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);
            }
            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, priority, Sql);

            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);
            }
            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, priority, Sql);

            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);
            }
            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, priority, "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, priority, methodName);

                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);
                }
                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("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;
        }

        //  获取数据库连接
        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;
        }

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

            foreach (DictionaryEntry it in _dbConfigInfo)
            {
                DBConnectionInfo info = (DBConnectionInfo)it.Value;
                DataProvider.IDataProvider dataProvider = GetDataProvider(info.dbType);
                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("启动成功！数据库连接池创建成功！");
        }

        #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()
        {
            while (true)
            {
                lock (lockObj)
                {
                    CheckConnActive();
                    FixConnections();
                    Thread.Sleep(1 * 60 * 1000);
                }
            }
        }

        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;
            // <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;

    }
}
